ObjPtr<>-ify ArtMethod and mirror::Method.
And clean up some forgotten things after old CLs.
Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Bug: 31113334
Change-Id: I8af0e845c24d674d0efab21d80c29949b1cc0593
diff --git a/runtime/art_method-inl.h b/runtime/art_method-inl.h
index 18595cf..9da4a39 100644
--- a/runtime/art_method-inl.h
+++ b/runtime/art_method-inl.h
@@ -49,14 +49,14 @@
namespace art {
template <ReadBarrierOption kReadBarrierOption>
-inline mirror::Class* ArtMethod::GetDeclaringClassUnchecked() {
+inline ObjPtr<mirror::Class> ArtMethod::GetDeclaringClassUnchecked() {
GcRootSource gc_root_source(this);
return declaring_class_.Read<kReadBarrierOption>(&gc_root_source);
}
template <ReadBarrierOption kReadBarrierOption>
-inline mirror::Class* ArtMethod::GetDeclaringClass() {
- mirror::Class* result = GetDeclaringClassUnchecked<kReadBarrierOption>();
+inline ObjPtr<mirror::Class> ArtMethod::GetDeclaringClass() {
+ ObjPtr<mirror::Class> result = GetDeclaringClassUnchecked<kReadBarrierOption>();
if (kIsDebugBuild) {
if (!IsRuntimeMethod()) {
CHECK(result != nullptr) << this;
@@ -77,8 +77,8 @@
declaring_class_ = GcRoot<mirror::Class>(new_declaring_class);
}
-inline bool ArtMethod::CASDeclaringClass(mirror::Class* expected_class,
- mirror::Class* desired_class) {
+inline bool ArtMethod::CASDeclaringClass(ObjPtr<mirror::Class> expected_class,
+ ObjPtr<mirror::Class> desired_class) {
GcRoot<mirror::Class> expected_root(expected_class);
GcRoot<mirror::Class> desired_root(desired_class);
auto atomic_root_class = reinterpret_cast<Atomic<GcRoot<mirror::Class>>*>(&declaring_class_);
@@ -127,14 +127,14 @@
case kVirtual: {
// We have an error if we are direct or a non-copied (i.e. not part of a real class) interface
// method.
- mirror::Class* methods_class = GetDeclaringClass();
+ ObjPtr<mirror::Class> methods_class = GetDeclaringClass();
return IsDirect() || (methods_class->IsInterface() && !IsCopied());
}
case kSuper:
// Constructors and static methods are called with invoke-direct.
return IsConstructor() || IsStatic();
case kInterface: {
- mirror::Class* methods_class = GetDeclaringClass();
+ ObjPtr<mirror::Class> methods_class = GetDeclaringClass();
return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
}
default:
@@ -509,7 +509,7 @@
void ArtMethod::VisitRoots(RootVisitorType& visitor, PointerSize pointer_size) {
if (LIKELY(!declaring_class_.IsNull())) {
visitor.VisitRoot(declaring_class_.AddressWithoutBarrier());
- mirror::Class* klass = declaring_class_.Read<kReadBarrierOption>();
+ ObjPtr<mirror::Class> klass = declaring_class_.Read<kReadBarrierOption>();
if (UNLIKELY(klass->IsProxyClass())) {
// For normal methods, dex cache shortcuts will be visited through the declaring class.
// However, for proxies we need to keep the interface method alive, so we visit its roots.
@@ -522,8 +522,8 @@
template <typename Visitor>
inline void ArtMethod::UpdateObjectsForImageRelocation(const Visitor& visitor) {
- mirror::Class* old_class = GetDeclaringClassUnchecked<kWithoutReadBarrier>();
- mirror::Class* new_class = visitor(old_class);
+ ObjPtr<mirror::Class> old_class = GetDeclaringClassUnchecked<kWithoutReadBarrier>();
+ ObjPtr<mirror::Class> new_class = visitor(old_class.Ptr());
if (old_class != new_class) {
SetDeclaringClass(new_class);
}
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 09debb0..f5ef3fa 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -87,10 +87,10 @@
REQUIRES_SHARED(Locks::mutator_lock_);
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
- ALWAYS_INLINE mirror::Class* GetDeclaringClass() REQUIRES_SHARED(Locks::mutator_lock_);
+ ALWAYS_INLINE ObjPtr<mirror::Class> GetDeclaringClass() REQUIRES_SHARED(Locks::mutator_lock_);
template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
- ALWAYS_INLINE mirror::Class* GetDeclaringClassUnchecked()
+ ALWAYS_INLINE ObjPtr<mirror::Class> GetDeclaringClassUnchecked()
REQUIRES_SHARED(Locks::mutator_lock_);
mirror::CompressedReference<mirror::Object>* GetDeclaringClassAddressWithoutBarrier() {
@@ -100,7 +100,7 @@
void SetDeclaringClass(ObjPtr<mirror::Class> new_declaring_class)
REQUIRES_SHARED(Locks::mutator_lock_);
- bool CASDeclaringClass(mirror::Class* expected_class, mirror::Class* desired_class)
+ bool CASDeclaringClass(ObjPtr<mirror::Class> expected_class, ObjPtr<mirror::Class> desired_class)
REQUIRES_SHARED(Locks::mutator_lock_);
static MemberOffset DeclaringClassOffset() {
@@ -395,10 +395,10 @@
dex_method_index_ = new_idx;
}
- // Lookup the Class* from the type index into this method's dex cache.
+ // Lookup the Class from the type index into this method's dex cache.
ObjPtr<mirror::Class> LookupResolvedClassFromTypeIndex(dex::TypeIndex type_idx)
REQUIRES_SHARED(Locks::mutator_lock_);
- // Resolve the Class* from the type index into this method's dex cache.
+ // Resolve the Class from the type index into this method's dex cache.
ObjPtr<mirror::Class> ResolveClassFromTypeIndex(dex::TypeIndex type_idx)
REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 966d636..f80d34c 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -7150,7 +7150,7 @@
vtable->SetElementPtrSize(i, translated_method, pointer_size);
}
}
- klass_->SetVTable(vtable.Ptr());
+ klass_->SetVTable(vtable);
return vtable;
}
@@ -8760,7 +8760,7 @@
ObjPtr<mirror::ClassLoader> class_loader = ObjPtr<mirror::ClassLoader>::DownCast(
self->DecodeJObject(data.weak_root));
if (class_loader != nullptr) {
- visitor->Visit(class_loader.Ptr());
+ visitor->Visit(class_loader);
}
}
}
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index f75f47c..e607b31 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -1484,7 +1484,7 @@
if (m == nullptr) {
memset(location, 0, sizeof(*location));
} else {
- mirror::Class* c = m->GetDeclaringClass();
+ ObjPtr<mirror::Class> c = m->GetDeclaringClass();
location->type_tag = GetTypeTag(c);
location->class_id = gRegistry->AddRefType(c);
// The RI Seems to return 0 for all obsolete methods. For compatibility we shall do the same.
diff --git a/runtime/dex/dex_file_annotations.cc b/runtime/dex/dex_file_annotations.cc
index 9358cbe..b87bf8d 100644
--- a/runtime/dex/dex_file_annotations.cc
+++ b/runtime/dex/dex_file_annotations.cc
@@ -728,7 +728,7 @@
ObjPtr<mirror::Class> annotation_member_class =
WellKnownClasses::ToClass(WellKnownClasses::libcore_reflect_AnnotationMember);
Handle<mirror::Object> new_member(hs.NewHandle(annotation_member_class->AllocObject(self)));
- mirror::Method* method_obj_ptr;
+ ObjPtr<mirror::Method> method_obj_ptr;
DCHECK(!Runtime::Current()->IsActiveTransaction());
if (pointer_size == PointerSize::k64) {
method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k64, false>(
diff --git a/runtime/entrypoints/entrypoint_utils-inl.h b/runtime/entrypoints/entrypoint_utils-inl.h
index 40ef10f..0ed26d3 100644
--- a/runtime/entrypoints/entrypoint_utils-inl.h
+++ b/runtime/entrypoints/entrypoint_utils-inl.h
@@ -255,7 +255,7 @@
CHECK(klass->IsArrayClass()) << klass->PrettyClass();
}
if (kAccessCheck) {
- mirror::Class* referrer = method->GetDeclaringClass();
+ ObjPtr<mirror::Class> referrer = method->GetDeclaringClass();
if (UNLIKELY(!referrer->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referrer, klass);
*slow_path = true;
@@ -366,7 +366,7 @@
ThrowIncompatibleClassChangeErrorField(resolved_field, is_static, referrer);
return nullptr;
}
- mirror::Class* referring_class = referrer->GetDeclaringClass();
+ ObjPtr<mirror::Class> referring_class = referrer->GetDeclaringClass();
if (UNLIKELY(!referring_class->CheckResolvedFieldAccess(fields_class,
resolved_field,
referrer->GetDexCache(),
@@ -721,7 +721,7 @@
return nullptr; // Failure - Indicate to caller to deliver exception
}
// Perform access check if necessary.
- mirror::Class* referring_class = referrer->GetDeclaringClass();
+ ObjPtr<mirror::Class> referring_class = referrer->GetDeclaringClass();
if (verify_access && UNLIKELY(!referring_class->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referring_class, klass);
return nullptr; // Failure - Indicate to caller to deliver exception
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 505e183..9cae3ae 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -2146,7 +2146,7 @@
sm_.AdvancePointer(self->GetJniEnv());
if (is_static) {
- sm_.AdvanceHandleScope((**sp)->GetDeclaringClass());
+ sm_.AdvanceHandleScope((**sp)->GetDeclaringClass().Ptr());
} // else "this" reference is already handled by QuickArgumentVisitor.
}
}
diff --git a/runtime/fault_handler.cc b/runtime/fault_handler.cc
index 671079b..d0e78ab 100644
--- a/runtime/fault_handler.cc
+++ b/runtime/fault_handler.cc
@@ -70,7 +70,7 @@
CHECK_NE(-1, rc);
if (kVerifySafeImpls) {
- mirror::Class* actual_class = method->GetDeclaringClassUnchecked<kWithoutReadBarrier>();
+ ObjPtr<mirror::Class> actual_class = method->GetDeclaringClassUnchecked<kWithoutReadBarrier>();
CHECK_EQ(actual_class, cls.AsMirrorPtr());
}
diff --git a/runtime/hprof/hprof.cc b/runtime/hprof/hprof.cc
index c9e8426..dc42cfa 100644
--- a/runtime/hprof/hprof.cc
+++ b/runtime/hprof/hprof.cc
@@ -718,7 +718,7 @@
source_file = "";
}
__ AddStringId(LookupStringId(source_file));
- auto class_result = classes_.find(method->GetDeclaringClass());
+ auto class_result = classes_.find(method->GetDeclaringClass().Ptr());
CHECK(class_result != classes_.end());
__ AddU4(class_result->second);
__ AddU4(frame->ComputeLineNumber());
diff --git a/runtime/jni/check_jni.cc b/runtime/jni/check_jni.cc
index 7919c32..66bd74b 100644
--- a/runtime/jni/check_jni.cc
+++ b/runtime/jni/check_jni.cc
@@ -1286,7 +1286,7 @@
}
ArtMethod* m = jni::DecodeArtMethod(mid);
// TODO: Better check here.
- if (!Runtime::Current()->GetHeap()->IsValidObjectAddress(m->GetDeclaringClass())) {
+ if (!Runtime::Current()->GetHeap()->IsValidObjectAddress(m->GetDeclaringClass().Ptr())) {
Runtime::Current()->GetHeap()->DumpSpaces(LOG_STREAM(ERROR));
AbortF("invalid jmethodID: %p", mid);
return nullptr;
diff --git a/runtime/jni/java_vm_ext.cc b/runtime/jni/java_vm_ext.cc
index 44679a5..fdf0fee 100644
--- a/runtime/jni/java_vm_ext.cc
+++ b/runtime/jni/java_vm_ext.cc
@@ -1078,7 +1078,7 @@
void* JavaVMExt::FindCodeForNativeMethod(ArtMethod* m) {
CHECK(m->IsNative());
- mirror::Class* c = m->GetDeclaringClass();
+ ObjPtr<mirror::Class> c = m->GetDeclaringClass();
// If this is a static method, it could be called before the class has been initialized.
CHECK(c->IsInitializing()) << c->GetStatus() << " " << m->PrettyMethod();
std::string detail;
diff --git a/runtime/jni/jni_internal.cc b/runtime/jni/jni_internal.cc
index a02e76a..5200607 100644
--- a/runtime/jni/jni_internal.cc
+++ b/runtime/jni/jni_internal.cc
@@ -501,7 +501,7 @@
CHECK_NON_NULL_ARGUMENT(mid);
ScopedObjectAccess soa(env);
ArtMethod* m = jni::DecodeArtMethod(mid);
- mirror::Executable* method;
+ ObjPtr<mirror::Executable> method;
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
if (m->IsConstructor()) {
diff --git a/runtime/mirror/method.cc b/runtime/mirror/method.cc
index cf03b95..910a1fc 100644
--- a/runtime/mirror/method.cc
+++ b/runtime/mirror/method.cc
@@ -20,32 +20,33 @@
#include "class_root.h"
#include "mirror/class-inl.h"
#include "mirror/object-inl.h"
+#include "obj_ptr-inl.h"
namespace art {
namespace mirror {
template <PointerSize kPointerSize, bool kTransactionActive>
-Method* Method::CreateFromArtMethod(Thread* self, ArtMethod* method) {
+ObjPtr<Method> Method::CreateFromArtMethod(Thread* self, ArtMethod* method) {
DCHECK(!method->IsConstructor()) << method->PrettyMethod();
ObjPtr<Method> ret = ObjPtr<Method>::DownCast(GetClassRoot<Method>()->AllocObject(self));
if (LIKELY(ret != nullptr)) {
ObjPtr<Executable>(ret)->
CreateFromArtMethod<kPointerSize, kTransactionActive>(method);
}
- return ret.Ptr();
+ return ret;
}
-template Method* Method::CreateFromArtMethod<PointerSize::k32, false>(Thread* self,
- ArtMethod* method);
-template Method* Method::CreateFromArtMethod<PointerSize::k32, true>(Thread* self,
- ArtMethod* method);
-template Method* Method::CreateFromArtMethod<PointerSize::k64, false>(Thread* self,
- ArtMethod* method);
-template Method* Method::CreateFromArtMethod<PointerSize::k64, true>(Thread* self,
- ArtMethod* method);
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k32, false>(
+ Thread* self, ArtMethod* method);
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k32, true>(
+ Thread* self, ArtMethod* method);
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k64, false>(
+ Thread* self, ArtMethod* method);
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k64, true>(
+ Thread* self, ArtMethod* method);
template <PointerSize kPointerSize, bool kTransactionActive>
-Constructor* Constructor::CreateFromArtMethod(Thread* self, ArtMethod* method) {
+ObjPtr<Constructor> Constructor::CreateFromArtMethod(Thread* self, ArtMethod* method) {
DCHECK(method->IsConstructor()) << method->PrettyMethod();
ObjPtr<Constructor> ret =
ObjPtr<Constructor>::DownCast(GetClassRoot<Constructor>()->AllocObject(self));
@@ -53,16 +54,16 @@
ObjPtr<Executable>(ret)->
CreateFromArtMethod<kPointerSize, kTransactionActive>(method);
}
- return ret.Ptr();
+ return ret;
}
-template Constructor* Constructor::CreateFromArtMethod<PointerSize::k32, false>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k32, false>(
Thread* self, ArtMethod* method);
-template Constructor* Constructor::CreateFromArtMethod<PointerSize::k32, true>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k32, true>(
Thread* self, ArtMethod* method);
-template Constructor* Constructor::CreateFromArtMethod<PointerSize::k64, false>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k64, false>(
Thread* self, ArtMethod* method);
-template Constructor* Constructor::CreateFromArtMethod<PointerSize::k64, true>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k64, true>(
Thread* self, ArtMethod* method);
} // namespace mirror
diff --git a/runtime/mirror/method.h b/runtime/mirror/method.h
index aea15a7..a73cd45 100644
--- a/runtime/mirror/method.h
+++ b/runtime/mirror/method.h
@@ -20,6 +20,9 @@
#include "executable.h"
namespace art {
+
+template<class MirrorType> class ObjPtr;
+
namespace mirror {
class Class;
@@ -28,7 +31,7 @@
class MANAGED Method : public Executable {
public:
template <PointerSize kPointerSize, bool kTransactionActive>
- static Method* CreateFromArtMethod(Thread* self, ArtMethod* method)
+ static ObjPtr<Method> CreateFromArtMethod(Thread* self, ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
private:
@@ -39,7 +42,7 @@
class MANAGED Constructor: public Executable {
public:
template <PointerSize kPointerSize, bool kTransactionActive>
- static Constructor* CreateFromArtMethod(Thread* self, ArtMethod* method)
+ static ObjPtr<Constructor> CreateFromArtMethod(Thread* self, ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
private:
diff --git a/runtime/mirror/var_handle.h b/runtime/mirror/var_handle.h
index 48c9d74..0cfa51c 100644
--- a/runtime/mirror/var_handle.h
+++ b/runtime/mirror/var_handle.h
@@ -197,11 +197,6 @@
ArtField* GetField() REQUIRES_SHARED(Locks::mutator_lock_);
- static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_);
- static void SetClass(Class* klass) REQUIRES_SHARED(Locks::mutator_lock_);
- static void ResetClass() REQUIRES_SHARED(Locks::mutator_lock_);
- static void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_);
-
private:
static MemberOffset ArtFieldOffset() {
return MemberOffset(OFFSETOF_MEMBER(FieldVarHandle, art_field_));
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index 82e54e2..5a5fb16 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -544,8 +544,8 @@
if (MethodMatchesConstructor(&m, public_only, enforce_hidden_api)) {
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
- auto* constructor = mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize, false>(
- soa.Self(), &m);
+ ObjPtr<mirror::Constructor> constructor =
+ mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), &m);
if (UNLIKELY(constructor == nullptr)) {
soa.Self()->AssertPendingOOMException();
return nullptr;
@@ -605,7 +605,7 @@
IsDiscoverable(public_only, enforce_hidden_api, &m)) {
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
- auto* method =
+ ObjPtr<mirror::Method> method =
mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), &m);
if (method == nullptr) {
soa.Self()->AssertPendingException();
@@ -838,7 +838,7 @@
return nullptr;
}
// Verify that we can access the constructor.
- auto* declaring_class = constructor->GetDeclaringClass();
+ ObjPtr<mirror::Class> declaring_class = constructor->GetDeclaringClass();
if (!constructor->IsPublic()) {
if (caller == nullptr) {
caller.Assign(GetCallingClass(soa.Self(), 1));
diff --git a/runtime/stack.cc b/runtime/stack.cc
index f58fc3b..c4851e1 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -597,7 +597,7 @@
void StackVisitor::SanityCheckFrame() const {
if (kIsDebugBuild) {
ArtMethod* method = GetMethod();
- mirror::Class* declaring_class = method->GetDeclaringClass();
+ ObjPtr<mirror::Class> declaring_class = method->GetDeclaringClass();
// Runtime methods have null declaring class.
if (!method->IsRuntimeMethod()) {
CHECK(declaring_class != nullptr);
@@ -613,7 +613,7 @@
// We get the canonical method as copied methods may have their declaring
// class from another class loader.
ArtMethod* canonical = method->GetCanonicalMethod();
- mirror::Class* klass = canonical->GetDeclaringClass();
+ ObjPtr<mirror::Class> klass = canonical->GetDeclaringClass();
LinearAlloc* const class_linear_alloc = (klass != nullptr)
? runtime->GetClassLinker()->GetAllocatorForClassLoader(klass->GetClassLoader())
: linear_alloc;
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 47877bd..1a61f2b 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -157,7 +157,7 @@
std::string failure_message;
const DexFile& dex_file = klass->GetDexFile();
const DexFile::ClassDef* class_def = klass->GetClassDef();
- mirror::Class* super = klass->GetSuperClass();
+ ObjPtr<mirror::Class> super = klass->GetSuperClass();
std::string temp;
if (super == nullptr && strcmp("Ljava/lang/Object;", klass->GetDescriptor(&temp)) != 0) {
early_failure = true;
@@ -2955,7 +2955,7 @@
bool is_range = (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
ArtMethod* abs_method = VerifyInvocationArgs(inst, METHOD_INTERFACE, is_range);
if (abs_method != nullptr) {
- mirror::Class* called_interface = abs_method->GetDeclaringClass();
+ ObjPtr<mirror::Class> called_interface = abs_method->GetDeclaringClass();
if (!called_interface->IsInterface() && !called_interface->IsObjectClass()) {
Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected interface class in invoke-interface '"
<< abs_method->PrettyMethod() << "'";
@@ -3286,7 +3286,7 @@
// Special instructions.
case Instruction::RETURN_VOID_NO_BARRIER:
if (IsConstructor() && !IsStatic()) {
- auto& declaring_class = GetDeclaringClass();
+ const RegType& declaring_class = GetDeclaringClass();
if (declaring_class.IsUnresolvedReference()) {
// We must iterate over the fields, even if we cannot use mirror classes to do so. Do it
// manually over the underlying dex file.
@@ -3892,7 +3892,7 @@
// class. It would be wrong to use this for the type check (interface type checks are
// postponed to runtime).
if (res_method != nullptr && !res_method->IsMiranda()) {
- mirror::Class* klass = res_method->GetDeclaringClass();
+ ObjPtr<mirror::Class> klass = res_method->GetDeclaringClass();
std::string temp;
res_method_class = &FromClass(klass->GetDescriptor(&temp), klass,
klass->CannotBeAssignedFromOtherTypes());
@@ -4154,7 +4154,7 @@
}
bool MethodVerifier::CheckSignaturePolymorphicMethod(ArtMethod* method) {
- mirror::Class* klass = method->GetDeclaringClass();
+ ObjPtr<mirror::Class> klass = method->GetDeclaringClass();
const char* method_name = method->GetName();
const char* expected_return_descriptor;