Compile time performance improvements focusing on interpret-only.
Reduce virtual method dispatch in the method verifier and make more code
inline-able.
Add a StringPiece with const char* equality operator to avoid redundant
StringPieces and strlens.
Remove back link from register line to verifier and pass as argument to reduce
size of RegisterLine.
Remove instruction length from instruction flags and compute from the
instruction, again to reduce size.
Add suspend checks to resolve and verify to allow for more easy monitor
inflation and reduce contention on Locks::thread_list_suspend_thread_lock_.
Change ThrowEarlierClassFailure to throw pre-allocated exception.
Avoid calls to Thread::Current() by passing self.
Template specialize IsValidClassName.
Make ANR reporting with SIGQUIT run using checkpoints rather than suspending
all threads. This makes the stack/lock analysis less lock error prone.
Extra Barrier assertions and condition variable time out is now returned as a
boolean both from Barrier and ConditionVariable::Wait.
2 threaded host x86-64 interpret-only numbers from 341 samples:
Before change: Avg 176.137ms 99% CI 3.468ms to 1060.770ms
After change: Avg 139.163% 99% CI 3.027ms to 838.257ms
Reduction in average compile time after change is 20.9%.
Slow-down without change is 26.5%.
Bug: 17471626 - Fix bug where RegTypeCache::JavaLangObject/String/Class/Throwable
could return unresolved type when class loading is disabled.
Bug: 17398101
Change-Id: Id59ce3cc520701c6ecf612f7152498107bc40684
diff --git a/runtime/verifier/reg_type.cc b/runtime/verifier/reg_type.cc
index 68c7849..41541b5 100644
--- a/runtime/verifier/reg_type.cc
+++ b/runtime/verifier/reg_type.cc
@@ -14,8 +14,7 @@
* limitations under the License.
*/
-#include "reg_type.h"
-
+#include "reg_type-inl.h"
#include "base/casts.h"
#include "class_linker-inl.h"
@@ -33,41 +32,23 @@
namespace art {
namespace verifier {
-UndefinedType* UndefinedType::instance_ = NULL;
-ConflictType* ConflictType::instance_ = NULL;
-BooleanType* BooleanType::instance = NULL;
-ByteType* ByteType::instance_ = NULL;
-ShortType* ShortType::instance_ = NULL;
-CharType* CharType::instance_ = NULL;
-FloatType* FloatType::instance_ = NULL;
-LongLoType* LongLoType::instance_ = NULL;
-LongHiType* LongHiType::instance_ = NULL;
-DoubleLoType* DoubleLoType::instance_ = NULL;
-DoubleHiType* DoubleHiType::instance_ = NULL;
-IntegerType* IntegerType::instance_ = NULL;
-
-int32_t RegType::ConstantValue() const {
- ScopedObjectAccess soa(Thread::Current());
- LOG(FATAL) << "Unexpected call to ConstantValue: " << *this;
- return 0;
-}
-
-int32_t RegType::ConstantValueLo() const {
- ScopedObjectAccess soa(Thread::Current());
- LOG(FATAL) << "Unexpected call to ConstantValueLo: " << *this;
- return 0;
-}
-
-int32_t RegType::ConstantValueHi() const {
- ScopedObjectAccess soa(Thread::Current());
- LOG(FATAL) << "Unexpected call to ConstantValueHi: " << *this;
- return 0;
-}
+const UndefinedType* UndefinedType::instance_ = nullptr;
+const ConflictType* ConflictType::instance_ = nullptr;
+const BooleanType* BooleanType::instance_ = nullptr;
+const ByteType* ByteType::instance_ = nullptr;
+const ShortType* ShortType::instance_ = nullptr;
+const CharType* CharType::instance_ = nullptr;
+const FloatType* FloatType::instance_ = nullptr;
+const LongLoType* LongLoType::instance_ = nullptr;
+const LongHiType* LongHiType::instance_ = nullptr;
+const DoubleLoType* DoubleLoType::instance_ = nullptr;
+const DoubleHiType* DoubleHiType::instance_ = nullptr;
+const IntegerType* IntegerType::instance_ = nullptr;
PrimitiveType::PrimitiveType(mirror::Class* klass, const std::string& descriptor, uint16_t cache_id)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: RegType(klass, descriptor, cache_id) {
- CHECK(klass != NULL);
+ CHECK(klass != nullptr);
CHECK(!descriptor.empty());
}
@@ -142,222 +123,160 @@
return "Integer";
}
-DoubleHiType* DoubleHiType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new DoubleHiType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-DoubleHiType* DoubleHiType::GetInstance() {
- CHECK(instance_ != NULL);
+const DoubleHiType* DoubleHiType::CreateInstance(mirror::Class* klass,
+ const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new DoubleHiType(klass, descriptor, cache_id);
return instance_;
}
void DoubleHiType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-DoubleLoType* DoubleLoType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new DoubleLoType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-DoubleLoType* DoubleLoType::GetInstance() {
- CHECK(instance_ != NULL);
+const DoubleLoType* DoubleLoType::CreateInstance(mirror::Class* klass,
+ const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new DoubleLoType(klass, descriptor, cache_id);
return instance_;
}
void DoubleLoType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-LongLoType* LongLoType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new LongLoType(klass, descriptor, cache_id);
- }
+const LongLoType* LongLoType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new LongLoType(klass, descriptor, cache_id);
return instance_;
}
-LongHiType* LongHiType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new LongHiType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-LongHiType* LongHiType::GetInstance() {
- CHECK(instance_ != NULL);
+const LongHiType* LongHiType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new LongHiType(klass, descriptor, cache_id);
return instance_;
}
void LongHiType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-LongLoType* LongLoType::GetInstance() {
- CHECK(instance_ != NULL);
- return instance_;
-}
-
void LongLoType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-FloatType* FloatType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new FloatType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-FloatType* FloatType::GetInstance() {
- CHECK(instance_ != NULL);
+const FloatType* FloatType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new FloatType(klass, descriptor, cache_id);
return instance_;
}
void FloatType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-CharType* CharType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new CharType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-CharType* CharType::GetInstance() {
- CHECK(instance_ != NULL);
+const CharType* CharType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new CharType(klass, descriptor, cache_id);
return instance_;
}
void CharType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-ShortType* ShortType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new ShortType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-ShortType* ShortType::GetInstance() {
- CHECK(instance_ != NULL);
+const ShortType* ShortType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new ShortType(klass, descriptor, cache_id);
return instance_;
}
void ShortType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-ByteType* ByteType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new ByteType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-ByteType* ByteType::GetInstance() {
- CHECK(instance_ != NULL);
+const ByteType* ByteType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new ByteType(klass, descriptor, cache_id);
return instance_;
}
void ByteType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-IntegerType* IntegerType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new IntegerType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-IntegerType* IntegerType::GetInstance() {
- CHECK(instance_ != NULL);
+const IntegerType* IntegerType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new IntegerType(klass, descriptor, cache_id);
return instance_;
}
void IntegerType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-ConflictType* ConflictType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new ConflictType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-ConflictType* ConflictType::GetInstance() {
- CHECK(instance_ != NULL);
+const ConflictType* ConflictType::CreateInstance(mirror::Class* klass,
+ const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new ConflictType(klass, descriptor, cache_id);
return instance_;
}
void ConflictType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
-BooleanType* BooleanType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
+const BooleanType* BooleanType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
uint16_t cache_id) {
- if (BooleanType::instance == NULL) {
- instance = new BooleanType(klass, descriptor, cache_id);
- }
- return BooleanType::instance;
-}
-
-BooleanType* BooleanType::GetInstance() {
- CHECK(BooleanType::instance != NULL);
- return BooleanType::instance;
+ CHECK(BooleanType::instance_ == nullptr);
+ instance_ = new BooleanType(klass, descriptor, cache_id);
+ return BooleanType::instance_;
}
void BooleanType::Destroy() {
- if (BooleanType::instance != NULL) {
- delete instance;
- instance = NULL;
+ if (BooleanType::instance_ != nullptr) {
+ delete instance_;
+ instance_ = nullptr;
}
}
@@ -365,23 +284,18 @@
return "Undefined";
}
-UndefinedType* UndefinedType::CreateInstance(mirror::Class* klass, const std::string& descriptor,
- uint16_t cache_id) {
- if (instance_ == NULL) {
- instance_ = new UndefinedType(klass, descriptor, cache_id);
- }
- return instance_;
-}
-
-UndefinedType* UndefinedType::GetInstance() {
- CHECK(instance_ != NULL);
+const UndefinedType* UndefinedType::CreateInstance(mirror::Class* klass,
+ const std::string& descriptor,
+ uint16_t cache_id) {
+ CHECK(instance_ == nullptr);
+ instance_ = new UndefinedType(klass, descriptor, cache_id);
return instance_;
}
void UndefinedType::Destroy() {
- if (instance_ != NULL) {
+ if (instance_ != nullptr) {
delete instance_;
- instance_ = NULL;
+ instance_ = nullptr;
}
}
@@ -528,18 +442,6 @@
return result.str();
}
-ConstantType::ConstantType(uint32_t constant, uint16_t cache_id)
- : RegType(NULL, "", cache_id), constant_(constant) {
-}
-
-const RegType& UndefinedType::Merge(const RegType& incoming_type, RegTypeCache* reg_types) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (incoming_type.IsUndefined()) {
- return *this; // Undefined MERGE Undefined => Undefined
- }
- return reg_types->Conflict();
-}
-
const RegType& RegType::HighHalf(RegTypeCache* cache) const {
DCHECK(IsLowHalf());
if (IsLongLo()) {
@@ -548,7 +450,8 @@
return cache->DoubleHi();
} else {
DCHECK(IsImpreciseConstantLo());
- return cache->FromCat2ConstHi(ConstantValue(), false);
+ const ConstantType* const_val = down_cast<const ConstantType*>(this);
+ return cache->FromCat2ConstHi(const_val->ConstantValue(), false);
}
}
@@ -586,24 +489,21 @@
bool UnresolvedType::IsNonZeroReferenceTypes() const {
return true;
}
+
std::set<uint16_t> UnresolvedMergedType::GetMergedTypes() const {
std::pair<uint16_t, uint16_t> refs = GetTopMergedTypes();
- const RegType& _left(reg_type_cache_->GetFromId(refs.first));
- RegType& __left(const_cast<RegType&>(_left));
- UnresolvedMergedType* left = down_cast<UnresolvedMergedType*>(&__left);
-
- RegType& _right(
- const_cast<RegType&>(reg_type_cache_->GetFromId(refs.second)));
- UnresolvedMergedType* right = down_cast<UnresolvedMergedType*>(&_right);
+ const RegType& left = reg_type_cache_->GetFromId(refs.first);
+ const RegType& right = reg_type_cache_->GetFromId(refs.second);
std::set<uint16_t> types;
- if (left->IsUnresolvedMergedReference()) {
- types = left->GetMergedTypes();
+ if (left.IsUnresolvedMergedReference()) {
+ types = down_cast<const UnresolvedMergedType*>(&left)->GetMergedTypes();
} else {
types.insert(refs.first);
}
- if (right->IsUnresolvedMergedReference()) {
- std::set<uint16_t> right_types = right->GetMergedTypes();
+ if (right.IsUnresolvedMergedReference()) {
+ std::set<uint16_t> right_types =
+ down_cast<const UnresolvedMergedType*>(&right)->GetMergedTypes();
types.insert(right_types.begin(), right_types.end());
} else {
types.insert(refs.second);
@@ -619,7 +519,7 @@
const RegType& RegType::GetSuperClass(RegTypeCache* cache) const {
if (!IsUnresolvedTypes()) {
mirror::Class* super_klass = GetClass()->GetSuperClass();
- if (super_klass != NULL) {
+ if (super_klass != nullptr) {
// A super class of a precise type isn't precise as a precise type indicates the register
// holds exactly that type.
std::string temp;
@@ -638,33 +538,6 @@
}
}
-bool RegType::CanAccess(const RegType& other) const {
- if (Equals(other)) {
- return true; // Trivial accessibility.
- } else {
- bool this_unresolved = IsUnresolvedTypes();
- bool other_unresolved = other.IsUnresolvedTypes();
- if (!this_unresolved && !other_unresolved) {
- return GetClass()->CanAccess(other.GetClass());
- } else if (!other_unresolved) {
- return other.GetClass()->IsPublic(); // Be conservative, only allow if other is public.
- } else {
- return false; // More complicated test not possible on unresolved types, be conservative.
- }
- }
-}
-
-bool RegType::CanAccessMember(mirror::Class* klass, uint32_t access_flags) const {
- if ((access_flags & kAccPublic) != 0) {
- return true;
- }
- if (!IsUnresolvedTypes()) {
- return GetClass()->CanAccessMember(klass, access_flags);
- } else {
- return false; // More complicated test not possible on unresolved types, be conservative.
- }
-}
-
bool RegType::IsObjectArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
// Primitive arrays will always resolve
@@ -704,106 +577,38 @@
return IsUnresolvedTypes() || (IsNonZeroReferenceTypes() && GetClass()->IsInstantiable());
}
-ImpreciseConstType::ImpreciseConstType(uint32_t constat, uint16_t cache_id)
- : ConstantType(constat, cache_id) {
-}
-
-static bool AssignableFrom(const RegType& lhs, const RegType& rhs, bool strict)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (lhs.Equals(rhs)) {
- return true;
- } else {
- if (lhs.IsBoolean()) {
- return rhs.IsBooleanTypes();
- } else if (lhs.IsByte()) {
- return rhs.IsByteTypes();
- } else if (lhs.IsShort()) {
- return rhs.IsShortTypes();
- } else if (lhs.IsChar()) {
- return rhs.IsCharTypes();
- } else if (lhs.IsInteger()) {
- return rhs.IsIntegralTypes();
- } else if (lhs.IsFloat()) {
- return rhs.IsFloatTypes();
- } else if (lhs.IsLongLo()) {
- return rhs.IsLongTypes();
- } else if (lhs.IsDoubleLo()) {
- return rhs.IsDoubleTypes();
- } else {
- CHECK(lhs.IsReferenceTypes())
- << "Unexpected register type in IsAssignableFrom: '"
- << lhs << "' := '" << rhs << "'";
- if (rhs.IsZero()) {
- return true; // All reference types can be assigned null.
- } else if (!rhs.IsReferenceTypes()) {
- return false; // Expect rhs to be a reference type.
- } else if (lhs.IsJavaLangObject()) {
- return true; // All reference types can be assigned to Object.
- } else if (!strict && !lhs.IsUnresolvedTypes() && lhs.GetClass()->IsInterface()) {
- // If we're not strict allow assignment to any interface, see comment in ClassJoin.
- return true;
- } else if (lhs.IsJavaLangObjectArray()) {
- return rhs.IsObjectArrayTypes(); // All reference arrays may be assigned to Object[]
- } else if (lhs.HasClass() && rhs.HasClass() &&
- lhs.GetClass()->IsAssignableFrom(rhs.GetClass())) {
- // We're assignable from the Class point-of-view.
- return true;
- } else {
- // Unresolved types are only assignable for null and equality.
- return false;
- }
- }
- }
-}
-
-bool RegType::IsAssignableFrom(const RegType& src) const {
- return AssignableFrom(*this, src, false);
-}
-
-bool RegType::IsStrictlyAssignableFrom(const RegType& src) const {
- return AssignableFrom(*this, src, true);
-}
-
-int32_t ConstantType::ConstantValueLo() const {
- DCHECK(IsConstantLo());
- return constant_;
-}
-
-int32_t ConstantType::ConstantValueHi() const {
- if (IsConstantHi() || IsPreciseConstantHi() || IsImpreciseConstantHi()) {
- return constant_;
- } else {
- DCHECK(false);
- return 0;
- }
-}
-
static const RegType& SelectNonConstant(const RegType& a, const RegType& b) {
return a.IsConstantTypes() ? b : a;
}
const RegType& RegType::Merge(const RegType& incoming_type, RegTypeCache* reg_types) const {
DCHECK(!Equals(incoming_type)); // Trivial equality handled by caller
- if (IsConflict()) {
+ // Perform pointer equality tests for conflict to avoid virtual method dispatch.
+ const ConflictType& conflict = reg_types->Conflict();
+ if (this == &conflict) {
+ DCHECK(IsConflict());
return *this; // Conflict MERGE * => Conflict
- } else if (incoming_type.IsConflict()) {
+ } else if (&incoming_type == &conflict) {
+ DCHECK(incoming_type.IsConflict());
return incoming_type; // * MERGE Conflict => Conflict
} else if (IsUndefined() || incoming_type.IsUndefined()) {
- return reg_types->Conflict(); // Unknown MERGE * => Conflict
+ return conflict; // Unknown MERGE * => Conflict
} else if (IsConstant() && incoming_type.IsConstant()) {
- int32_t val1 = ConstantValue();
- int32_t val2 = incoming_type.ConstantValue();
+ const ConstantType& type1 = *down_cast<const ConstantType*>(this);
+ const ConstantType& type2 = *down_cast<const ConstantType*>(&incoming_type);
+ int32_t val1 = type1.ConstantValue();
+ int32_t val2 = type2.ConstantValue();
if (val1 >= 0 && val2 >= 0) {
// +ve1 MERGE +ve2 => MAX(+ve1, +ve2)
if (val1 >= val2) {
- if (!IsPreciseConstant()) {
+ if (!type1.IsPreciseConstant()) {
return *this;
} else {
return reg_types->FromCat1Const(val1, false);
}
} else {
- if (!incoming_type.IsPreciseConstant()) {
- return incoming_type;
+ if (!type2.IsPreciseConstant()) {
+ return type2;
} else {
return reg_types->FromCat1Const(val2, false);
}
@@ -811,30 +616,30 @@
} else if (val1 < 0 && val2 < 0) {
// -ve1 MERGE -ve2 => MIN(-ve1, -ve2)
if (val1 <= val2) {
- if (!IsPreciseConstant()) {
+ if (!type1.IsPreciseConstant()) {
return *this;
} else {
return reg_types->FromCat1Const(val1, false);
}
} else {
- if (!incoming_type.IsPreciseConstant()) {
- return incoming_type;
+ if (!type2.IsPreciseConstant()) {
+ return type2;
} else {
return reg_types->FromCat1Const(val2, false);
}
}
} else {
// Values are +ve and -ve, choose smallest signed type in which they both fit
- if (IsConstantByte()) {
- if (incoming_type.IsConstantByte()) {
+ if (type1.IsConstantByte()) {
+ if (type2.IsConstantByte()) {
return reg_types->ByteConstant();
- } else if (incoming_type.IsConstantShort()) {
+ } else if (type2.IsConstantShort()) {
return reg_types->ShortConstant();
} else {
return reg_types->IntConstant();
}
- } else if (IsConstantShort()) {
- if (incoming_type.IsConstantShort()) {
+ } else if (type1.IsConstantShort()) {
+ if (type2.IsConstantShort()) {
return reg_types->ShortConstant();
} else {
return reg_types->IntConstant();
@@ -844,12 +649,16 @@
}
}
} else if (IsConstantLo() && incoming_type.IsConstantLo()) {
- int32_t val1 = ConstantValueLo();
- int32_t val2 = incoming_type.ConstantValueLo();
+ const ConstantType& type1 = *down_cast<const ConstantType*>(this);
+ const ConstantType& type2 = *down_cast<const ConstantType*>(&incoming_type);
+ int32_t val1 = type1.ConstantValueLo();
+ int32_t val2 = type2.ConstantValueLo();
return reg_types->FromCat2ConstLo(val1 | val2, false);
} else if (IsConstantHi() && incoming_type.IsConstantHi()) {
- int32_t val1 = ConstantValueHi();
- int32_t val2 = incoming_type.ConstantValueHi();
+ const ConstantType& type1 = *down_cast<const ConstantType*>(this);
+ const ConstantType& type2 = *down_cast<const ConstantType*>(&incoming_type);
+ int32_t val1 = type1.ConstantValueHi();
+ int32_t val2 = type2.ConstantValueHi();
return reg_types->FromCat2ConstHi(val1 | val2, false);
} else if (IsIntegralTypes() && incoming_type.IsIntegralTypes()) {
if (IsBooleanTypes() && incoming_type.IsBooleanTypes()) {
@@ -889,12 +698,12 @@
// Something that is uninitialized hasn't had its constructor called. Mark any merge
// of this type with something that is initialized as conflicting. The cases of a merge
// with itself, 0 or Object are handled above.
- return reg_types->Conflict();
+ return conflict;
} else { // Two reference types, compute Join
mirror::Class* c1 = GetClass();
mirror::Class* c2 = incoming_type.GetClass();
- DCHECK(c1 != NULL && !c1->IsPrimitive());
- DCHECK(c2 != NULL && !c2->IsPrimitive());
+ DCHECK(c1 != nullptr && !c1->IsPrimitive());
+ DCHECK(c2 != nullptr && !c2->IsPrimitive());
mirror::Class* join_class = ClassJoin(c1, c2);
if (c1 == join_class && !IsPreciseReference()) {
return *this;
@@ -906,7 +715,7 @@
}
}
} else {
- return reg_types->Conflict(); // Unexpected types => Conflict
+ return conflict; // Unexpected types => Conflict
}
}
@@ -933,7 +742,7 @@
mirror::Class* common_elem = ClassJoin(s_ct, t_ct);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
mirror::Class* array_class = class_linker->FindArrayClass(Thread::Current(), &common_elem);
- DCHECK(array_class != NULL);
+ DCHECK(array_class != nullptr);
return array_class;
} else {
size_t s_depth = s->Depth();
@@ -969,7 +778,7 @@
}
}
-void RegType::VisitRoots(RootCallback* callback, void* arg) {
+void RegType::VisitRoots(RootCallback* callback, void* arg) const {
if (!klass_.IsNull()) {
callback(reinterpret_cast<mirror::Object**>(&klass_), arg, 0, kRootUnknown);
}