Add helpers for classes from well known fields/methods.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Change-Id: I91bdaf25bc17d9d35288aa7d7f1eb01da14850a9

17 files changed, 185 insertions, 98 deletions

diff --git a/dex2oat/driver/compiler_driver.cc b/dex2oat/driver/compiler_driver.cc
index 78fdc31718..f374ab3b3e 100644
--- a/dex2oat/driver/compiler_driver.cc
+++ b/dex2oat/driver/compiler_driver.cc
@@ -87,7 +87,7 @@
 #include "verifier/class_verifier.h"
 #include "verifier/verifier_deps.h"
 #include "verifier/verifier_enums.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -1041,21 +1041,22 @@ static void AddClassLoaderClasses(/* out */ HashSet<std::string>* image_classes)
 
 static void VerifyClassLoaderClassesAreImageClasses(/* out */ HashSet<std::string>* image_classes) {
   ScopedObjectAccess soa(Thread::Current());
-  jclass class_loader_classes[] = {
-      WellKnownClasses::dalvik_system_BaseDexClassLoader,
-      WellKnownClasses::dalvik_system_DelegateLastClassLoader,
-      WellKnownClasses::dalvik_system_DexClassLoader,
-      WellKnownClasses::dalvik_system_DexFile,
-      WellKnownClasses::dalvik_system_DexPathList,
-      WellKnownClasses::dalvik_system_DexPathList__Element,
-      WellKnownClasses::dalvik_system_InMemoryDexClassLoader,
-      WellKnownClasses::dalvik_system_PathClassLoader,
-      WellKnownClasses::java_lang_BootClassLoader,
-      WellKnownClasses::java_lang_ClassLoader,
+  ScopedAssertNoThreadSuspension sants(__FUNCTION__);
+  ObjPtr<mirror::Class> class_loader_classes[] = {
+      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_BaseDexClassLoader),
+      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DelegateLastClassLoader),
+      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_DexClassLoader),
+      WellKnownClasses::dalvik_system_DexFile.Get(),
+      WellKnownClasses::dalvik_system_DexPathList.Get(),
+      WellKnownClasses::dalvik_system_DexPathList__Element.Get(),
+      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_InMemoryDexClassLoader),
+      soa.Decode<mirror::Class>(WellKnownClasses::dalvik_system_PathClassLoader),
+      soa.Decode<mirror::Class>(WellKnownClasses::java_lang_BootClassLoader),
+      soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ClassLoader),
   };
-  for (jclass klass : class_loader_classes) {
+  for (ObjPtr<mirror::Class> klass : class_loader_classes) {
     std::string temp;
-    std::string_view descriptor = soa.Decode<mirror::Class>(klass)->GetDescriptor(&temp);
+    std::string_view descriptor = klass->GetDescriptor(&temp);
     CHECK(image_classes->find(descriptor) != image_classes->end());
   }
   ArtField* class_loader_fields[] = {
diff --git a/dex2oat/linker/image_writer.cc b/dex2oat/linker/image_writer.cc
index a8bd965be8..54f0d1142e 100644
--- a/dex2oat/linker/image_writer.cc
+++ b/dex2oat/linker/image_writer.cc
@@ -82,7 +82,7 @@
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.h"
 #include "subtype_check.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 using ::art::mirror::Class;
 using ::art::mirror::DexCache;
@@ -272,7 +272,7 @@ static void ClearDexFileCookies() REQUIRES_SHARED(Locks::mutator_lock_) {
   auto visitor = [](Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
     DCHECK(obj != nullptr);
     Class* klass = obj->GetClass();
-    if (klass == WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_DexFile)) {
+    if (klass == WellKnownClasses::dalvik_system_DexFile) {
       ArtField* field = WellKnownClasses::dalvik_system_DexFile_cookie;
       // Null out the cookie to enable determinism. b/34090128
       field->SetObject</*kTransactionActive*/false>(obj, nullptr);
@@ -2224,8 +2224,7 @@ void ImageWriter::LayoutHelper::VerifyImageBinSlotsAssigned() {
           CHECK(ref != nullptr);
           CHECK(image_writer_->IsImageBinSlotAssigned(ref.Ptr()));
           ObjPtr<mirror::Class> ref_klass = ref->GetClass<kVerifyNone, kWithoutReadBarrier>();
-          CHECK(ref_klass ==
-                DecodeGlobalWithoutRB<mirror::Class>(vm, WellKnownClasses::dalvik_system_DexFile));
+          CHECK(ref_klass == WellKnownClasses::dalvik_system_DexFile.Get<kWithoutReadBarrier>());
           // Note: The app class loader is used only for checking against the runtime
           // class loader, the dex file cookie is cleared and therefore we do not need
           // to run the finalizer even if we implement app image objects collection.
diff --git a/openjdkjvmti/ti_redefine.cc b/openjdkjvmti/ti_redefine.cc
index a8c4495689..c15cbe7126 100644
--- a/openjdkjvmti/ti_redefine.cc
+++ b/openjdkjvmti/ti_redefine.cc
@@ -130,7 +130,7 @@
 #include "transform.h"
 #include "verifier/class_verifier.h"
 #include "verifier/verifier_enums.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 #include "write_barrier.h"
 
 namespace openjdkjvmti {
@@ -456,8 +456,7 @@ jvmtiError Redefiner::GetClassRedefinitionError(art::Handle<art::mirror::Class>
     }
     // Check Thread specifically since it's not a root but too many things reach into it with Unsafe
     // too allow structural redefinition.
-    if (klass->IsAssignableFrom(
-            art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+    if (klass->IsAssignableFrom(art::WellKnownClasses::java_lang_Thread.Get())) {
       *error_msg =
           "java.lang.Thread has fields accessed using sun.misc.unsafe directly. It is not "
           "safe to structurally redefine it.";
diff --git a/openjdkjvmti/ti_stack.cc b/openjdkjvmti/ti_stack.cc
index 74dae8e9f7..c3aab4c213 100644
--- a/openjdkjvmti/ti_stack.cc
+++ b/openjdkjvmti/ti_stack.cc
@@ -82,7 +82,7 @@
 #include "thread_list.h"
 #include "thread_pool.h"
 #include "ti_thread.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace openjdkjvmti {
 
@@ -579,7 +579,7 @@ jvmtiError StackUtil::GetThreadListStackTraces(jvmtiEnv* env,
       return ERR(INVALID_THREAD);
     }
     art::ObjPtr<art::mirror::Object> thread = soa.Decode<art::mirror::Object>(thread_list[i]);
-    if (!thread->InstanceOf(art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+    if (!thread->InstanceOf(art::WellKnownClasses::java_lang_Thread.Get())) {
       return ERR(INVALID_THREAD);
     }
     data.handles.push_back(hs.NewHandle(thread));
diff --git a/openjdkjvmti/ti_thread.cc b/openjdkjvmti/ti_thread.cc
index 5c0c3854a4..0c0b569739 100644
--- a/openjdkjvmti/ti_thread.cc
+++ b/openjdkjvmti/ti_thread.cc
@@ -59,7 +59,7 @@
 #include "thread-current-inl.h"
 #include "thread_list.h"
 #include "ti_phase.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace openjdkjvmti {
 
@@ -192,8 +192,7 @@ void ThreadUtil::CacheData() {
   gThreadCallback.started = true;
   art::Thread* self = art::Thread::Current();
   art::ScopedObjectAccess soa(self);
-  art::ObjPtr<art::mirror::Class> thread_class =
-      art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass();
+  art::ObjPtr<art::mirror::Class> thread_class = art::WellKnownClasses::java_lang_Thread.Get();
   CHECK(thread_class != nullptr);
   context_class_loader_ = thread_class->FindDeclaredInstanceField("contextClassLoader",
                                                                   "Ljava/lang/ClassLoader;");
@@ -238,7 +237,7 @@ bool ThreadUtil::GetNativeThread(jthread thread,
     return true;
   }
   art::ObjPtr<art::mirror::Object> othread = soa.Decode<art::mirror::Object>(thread);
-  if (!othread->InstanceOf(art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+  if (!othread->InstanceOf(art::WellKnownClasses::java_lang_Thread.Get())) {
     *err = ERR(INVALID_THREAD);
     return false;
   } else {
@@ -619,8 +618,7 @@ jvmtiError ThreadUtil::GetThreadState(jvmtiEnv* env ATTRIBUTE_UNUSED,
 
   // Need to read the Java "started" field to know whether this is starting or terminated.
   art::Handle<art::mirror::Object> peer(hs.NewHandle(soa.Decode<art::mirror::Object>(thread)));
-  art::ObjPtr<art::mirror::Class> thread_klass =
-      art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass();
+  art::ObjPtr<art::mirror::Class> thread_klass = art::WellKnownClasses::java_lang_Thread.Get();
   if (!thread_klass->IsAssignableFrom(peer->GetClass())) {
     return ERR(INVALID_THREAD);
   }
@@ -826,7 +824,7 @@ jvmtiError ThreadUtil::RunAgentThread(jvmtiEnv* jvmti_env,
   {
     art::ScopedObjectAccess soa(self);
     art::ObjPtr<art::mirror::Object> othread = soa.Decode<art::mirror::Object>(thread);
-    if (!othread->InstanceOf(art::WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+    if (!othread->InstanceOf(art::WellKnownClasses::java_lang_Thread.Get())) {
       return ERR(INVALID_THREAD);
     }
     if (proc == nullptr) {
diff --git a/openjdkjvmti/ti_threadgroup.cc b/openjdkjvmti/ti_threadgroup.cc
index 979e3d1653..120024e8b2 100644
--- a/openjdkjvmti/ti_threadgroup.cc
+++ b/openjdkjvmti/ti_threadgroup.cc
@@ -47,7 +47,7 @@
 #include "scoped_thread_state_change-inl.h"
 #include "thread-current-inl.h"
 #include "thread_list.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace openjdkjvmti {
 
@@ -97,7 +97,7 @@ jvmtiError ThreadGroupUtil::GetThreadGroupInfo(jvmtiEnv* env,
   art::ScopedObjectAccess soa(art::Thread::Current());
   art::StackHandleScope<2> hs(soa.Self());
   art::Handle<art::mirror::Class> tg_class =
-      hs.NewHandle(art::WellKnownClasses::java_lang_ThreadGroup_add->GetDeclaringClass());
+      hs.NewHandle(art::WellKnownClasses::java_lang_ThreadGroup.Get());
   art::Handle<art::mirror::Object> thread_group =
       hs.NewHandle(soa.Decode<art::mirror::Object>(group));
   if (!thread_group->InstanceOf(tg_class.Get())) {
@@ -224,8 +224,7 @@ jvmtiError ThreadGroupUtil::GetThreadGroupChildren(jvmtiEnv* env,
   art::StackHandleScope<1> hs(soa.Self());
   art::Handle<art::mirror::Object> thread_group =
       hs.NewHandle(soa.Decode<art::mirror::Object>(group));
-  if (!thread_group->InstanceOf(
-          art::WellKnownClasses::java_lang_ThreadGroup_add->GetDeclaringClass())) {
+  if (!thread_group->InstanceOf(art::WellKnownClasses::java_lang_ThreadGroup.Get())) {
     return ERR(INVALID_THREAD_GROUP);
   }
 
diff --git a/runtime/class_loader_context.cc b/runtime/class_loader_context.cc
index 17bc2695c9..f2988c1fbc 100644
--- a/runtime/class_loader_context.cc
+++ b/runtime/class_loader_context.cc
@@ -44,7 +44,7 @@
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.h"
 #include "thread.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -1079,9 +1079,8 @@ static bool GetDexFilesFromDexElementsArray(
   ArtField* const cookie_field = WellKnownClasses::dalvik_system_DexFile_cookie;
   ArtField* const dex_file_field = WellKnownClasses::dalvik_system_DexPathList__Element_dexFile;
   const ObjPtr<mirror::Class> element_class =
-      WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_DexPathList__Element);
-  const ObjPtr<mirror::Class> dexfile_class =
-      WellKnownClasses::ToClass(WellKnownClasses::dalvik_system_DexFile);
+      WellKnownClasses::dalvik_system_DexPathList__Element.Get();
+  const ObjPtr<mirror::Class> dexfile_class = WellKnownClasses::dalvik_system_DexFile.Get();
 
   for (auto element : dex_elements.Iterate<mirror::Object>()) {
     // We can hit a null element here because this is invoked with a partially filled dex_elements
diff --git a/runtime/common_throws.cc b/runtime/common_throws.cc
index 0b7801ce71..75918a708e 100644
--- a/runtime/common_throws.cc
+++ b/runtime/common_throws.cc
@@ -36,7 +36,7 @@
 #include "nativehelper/scoped_local_ref.h"
 #include "obj_ptr-inl.h"
 #include "thread.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -755,8 +755,7 @@ void ThrowStackOverflowError(Thread* self) {
 
     // suppressedExceptions.
     {
-      ObjPtr<mirror::Class> j_u_c =
-          WellKnownClasses::java_util_Collections_EMPTY_LIST->GetDeclaringClass();
+      ObjPtr<mirror::Class> j_u_c = WellKnownClasses::java_util_Collections.Get();
       DCHECK(j_u_c->IsInitialized());
       ObjPtr<mirror::Object> empty_list =
           WellKnownClasses::java_util_Collections_EMPTY_LIST->GetObject(j_u_c);
@@ -774,8 +773,7 @@ void ThrowStackOverflowError(Thread* self) {
           ->SetObject</*kTransactionActive=*/ false>(exc.Get(), stack_state_val);
 
       // stackTrace.
-      ObjPtr<mirror::Class> l_u_ea =
-          WellKnownClasses::libcore_util_EmptyArray_STACK_TRACE_ELEMENT->GetDeclaringClass();
+      ObjPtr<mirror::Class> l_u_ea = WellKnownClasses::libcore_util_EmptyArray.Get();
       DCHECK(l_u_ea->IsInitialized());
       ObjPtr<mirror::Object> empty_ste =
           WellKnownClasses::libcore_util_EmptyArray_STACK_TRACE_ELEMENT->GetObject(l_u_ea);
diff --git a/runtime/jni/jni_internal.cc b/runtime/jni/jni_internal.cc
index f517dd71c7..8e6e84fc8c 100644
--- a/runtime/jni/jni_internal.cc
+++ b/runtime/jni/jni_internal.cc
@@ -64,7 +64,7 @@
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.h"
 #include "thread.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -2792,7 +2792,7 @@ class JNI {
     ObjPtr<mirror::Object> buffer = soa.Decode<mirror::Object>(java_buffer);
 
     // Return null if |java_buffer| is not a java.nio.Buffer instance.
-    if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer_address->GetDeclaringClass())) {
+    if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer.Get())) {
       return nullptr;
     }
 
@@ -2808,7 +2808,7 @@ class JNI {
     ScopedObjectAccess soa(env);
     StackHandleScope<1u> hs(soa.Self());
     Handle<mirror::Object> buffer = hs.NewHandle(soa.Decode<mirror::Object>(java_buffer));
-    if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer_capacity->GetDeclaringClass())) {
+    if (!buffer->InstanceOf(WellKnownClasses::java_nio_Buffer.Get())) {
       return -1;
     }
 
diff --git a/runtime/native/jdk_internal_misc_Unsafe.cc b/runtime/native/jdk_internal_misc_Unsafe.cc
index fa84f0e687..c10039b72c 100644
--- a/runtime/native/jdk_internal_misc_Unsafe.cc
+++ b/runtime/native/jdk_internal_misc_Unsafe.cc
@@ -34,7 +34,7 @@
 #include "art_field-inl.h"
 #include "native_util.h"
 #include "scoped_fast_native_object_access-inl.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -476,7 +476,7 @@ static void Unsafe_unpark(JNIEnv* env, jobject, jobject jthread) {
   art::ScopedFastNativeObjectAccess soa(env);
   ObjPtr<mirror::Object> mirror_thread = soa.Decode<mirror::Object>(jthread);
   if (mirror_thread == nullptr ||
-      !mirror_thread->InstanceOf(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+      !mirror_thread->InstanceOf(WellKnownClasses::java_lang_Thread.Get())) {
     ThrowIllegalArgumentException("Argument to unpark() was not a Thread");
     return;
   }
diff --git a/runtime/native/sun_misc_Unsafe.cc b/runtime/native/sun_misc_Unsafe.cc
index 52407db292..8a203cee1a 100644
--- a/runtime/native/sun_misc_Unsafe.cc
+++ b/runtime/native/sun_misc_Unsafe.cc
@@ -34,7 +34,7 @@
 #include "art_field-inl.h"
 #include "native_util.h"
 #include "scoped_fast_native_object_access-inl.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -523,7 +523,7 @@ static void Unsafe_unpark(JNIEnv* env, jobject, jobject jthread) {
   art::ScopedFastNativeObjectAccess soa(env);
   ObjPtr<mirror::Object> mirror_thread = soa.Decode<mirror::Object>(jthread);
   if (mirror_thread == nullptr ||
-      !mirror_thread->InstanceOf(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass())) {
+      !mirror_thread->InstanceOf(WellKnownClasses::java_lang_Thread.Get())) {
     ThrowIllegalArgumentException("Argument to unpark() was not a Thread");
     return;
   }
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 51a2c977cd..66a6d32ab1 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -178,7 +178,7 @@
 #include "transaction.h"
 #include "vdex_file.h"
 #include "verifier/class_verifier.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 #ifdef ART_TARGET_ANDROID
 #include <android/api-level.h>
@@ -890,8 +890,7 @@ static jobject CreateSystemClassLoader(Runtime* runtime) {
       runtime->GetJavaVM()->AddGlobalRef(soa.Self(), system_class_loader);
   soa.Self()->SetClassLoaderOverride(g_system_class_loader);
 
-  ObjPtr<mirror::Class> thread_class =
-      WellKnownClasses::java_lang_Thread_init->GetDeclaringClass();
+  ObjPtr<mirror::Class> thread_class = WellKnownClasses::java_lang_Thread.Get();
   ArtField* contextClassLoader =
       thread_class->FindDeclaredInstanceField("contextClassLoader", "Ljava/lang/ClassLoader;");
   CHECK(contextClassLoader != nullptr);
@@ -2236,8 +2235,7 @@ void Runtime::InitThreadGroups(Thread* self) {
   bool initialized = GetClassLinker()->EnsureInitialized(
       self, thread_group_class, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
   CHECK(initialized);
-  Handle<mirror::Class> thread_class =
-      hs.NewHandle(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass());
+  Handle<mirror::Class> thread_class = hs.NewHandle(WellKnownClasses::java_lang_Thread.Get());
   initialized = GetClassLinker()->EnsureInitialized(
       self, thread_class, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
   CHECK(initialized);
diff --git a/runtime/runtime_callbacks_test.cc b/runtime/runtime_callbacks_test.cc
index b0782a5e22..6f0b8a1d20 100644
--- a/runtime/runtime_callbacks_test.cc
+++ b/runtime/runtime_callbacks_test.cc
@@ -44,7 +44,7 @@
 #include "scoped_thread_state_change-inl.h"
 #include "thread-inl.h"
 #include "thread_list.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 namespace art {
 
@@ -165,7 +165,7 @@ TEST_F(ThreadLifecycleCallbackRuntimeCallbacksTest, ThreadLifecycleCallbackJava)
   cb_.state = CallbackState::kBase;  // Ignore main thread attach.
 
   ScopedObjectAccess soa(self);
-  MakeExecutable(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass());
+  MakeExecutable(WellKnownClasses::java_lang_Thread.Get());
 
   StackHandleScope<3u> hs(self);
   Handle<mirror::String> thread_name = hs.NewHandle(
@@ -509,12 +509,11 @@ TEST_F(MonitorWaitCallbacksTest, WaitUnlocked) {
     ASSERT_TRUE(started);
     {
       ScopedObjectAccess soa(self);
-      cb_.SetInterestingObject(
-          WellKnownClasses::java_util_Collections_EMPTY_LIST->GetDeclaringClass());
+      cb_.SetInterestingObject(WellKnownClasses::java_util_Collections.Get());
       Monitor::Wait(
           self,
           // Just a random class
-          WellKnownClasses::java_util_Collections_EMPTY_LIST->GetDeclaringClass(),
+          WellKnownClasses::java_util_Collections.Get(),
           /*ms=*/0,
           /*ns=*/0,
           /*interruptShouldThrow=*/false,
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 4312102b1a..da403b59bd 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -115,7 +115,7 @@
 #include "thread_list.h"
 #include "verifier/method_verifier.h"
 #include "verify_object.h"
-#include "well_known_classes.h"
+#include "well_known_classes-inl.h"
 
 #if ART_USE_FUTEXES
 #include "linux/futex.h"
@@ -1128,7 +1128,7 @@ void Thread::CreatePeer(const char* name, bool as_daemon, jobject thread_group)
 
   ScopedObjectAccess soa(self);
   StackHandleScope<4u> hs(self);
-  DCHECK(WellKnownClasses::java_lang_ThreadGroup_add->GetDeclaringClass()->IsInitialized());
+  DCHECK(WellKnownClasses::java_lang_ThreadGroup->IsInitialized());
   Handle<mirror::Object> thr_group = hs.NewHandle(soa.Decode<mirror::Object>(
       thread_group != nullptr ? thread_group : runtime->GetMainThreadGroup()));
   Handle<mirror::String> thread_name = hs.NewHandle(
@@ -1140,9 +1140,9 @@ void Thread::CreatePeer(const char* name, bool as_daemon, jobject thread_group)
   }
   jint thread_priority = GetNativePriority();
 
-  DCHECK(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass()->IsInitialized());
-  Handle<mirror::Object> peer = hs.NewHandle(
-      WellKnownClasses::java_lang_Thread_init->GetDeclaringClass()->AllocObject(self));
+  DCHECK(WellKnownClasses::java_lang_Thread->IsInitialized());
+  Handle<mirror::Object> peer =
+      hs.NewHandle(WellKnownClasses::java_lang_Thread->AllocObject(self));
   if (UNLIKELY(peer == nullptr)) {
     CHECK(IsExceptionPending());
     return;
@@ -1193,7 +1193,7 @@ ObjPtr<mirror::Object> Thread::CreateCompileTimePeer(const char* name,
 
   ScopedObjectAccessUnchecked soa(self);
   StackHandleScope<3u> hs(self);
-  DCHECK(WellKnownClasses::java_lang_ThreadGroup_add->GetDeclaringClass()->IsInitialized());
+  DCHECK(WellKnownClasses::java_lang_ThreadGroup->IsInitialized());
   Handle<mirror::Object> thr_group = hs.NewHandle(soa.Decode<mirror::Object>(
       thread_group != nullptr ? thread_group : runtime->GetMainThreadGroup()));
   Handle<mirror::String> thread_name = hs.NewHandle(
@@ -1205,9 +1205,9 @@ ObjPtr<mirror::Object> Thread::CreateCompileTimePeer(const char* name,
   }
   jint thread_priority = kNormThreadPriority;  // Always normalize to NORM priority.
 
-  DCHECK(WellKnownClasses::java_lang_Thread_init->GetDeclaringClass()->IsInitialized());
+  DCHECK(WellKnownClasses::java_lang_Thread->IsInitialized());
   Handle<mirror::Object> peer = hs.NewHandle(
-      WellKnownClasses::java_lang_Thread_init->GetDeclaringClass()->AllocObject(self));
+      WellKnownClasses::java_lang_Thread->AllocObject(self));
   if (peer == nullptr) {
     CHECK(Thread::Current()->IsExceptionPending());
     return nullptr;
diff --git a/runtime/well_known_classes-inl.h b/runtime/well_known_classes-inl.h
new file mode 100644
index 0000000000..23fe145f7c
--- /dev/null
+++ b/runtime/well_known_classes-inl.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_RUNTIME_WELL_KNOWN_CLASSES_INL_H_
+#define ART_RUNTIME_WELL_KNOWN_CLASSES_INL_H_
+
+#include "well_known_classes.h"
+
+#include "art_field-inl.h"
+#include "art_method-inl.h"
+
+namespace art {
+namespace detail {
+
+template <typename MemberType, MemberType** kMember>
+template <ReadBarrierOption kReadBarrierOption>
+ObjPtr<mirror::Class> ClassFromMember<MemberType, kMember>::Get() {
+  return (*kMember)->template GetDeclaringClass<kReadBarrierOption>();
+}
+
+template <typename MemberType, MemberType** kMember>
+mirror::Class* ClassFromMember<MemberType, kMember>::operator->() const {
+  return Get().Ptr();
+}
+
+template <typename MemberType, MemberType** kMember>
+inline bool operator==(const ClassFromMember<MemberType, kMember> lhs, ObjPtr<mirror::Class> rhs) {
+  return lhs.Get() == rhs;
+}
+
+template <typename MemberType, MemberType** kMember>
+inline bool operator==(ObjPtr<mirror::Class> lhs, const ClassFromMember<MemberType, kMember> rhs) {
+  return rhs == lhs;
+}
+
+template <typename MemberType, MemberType** kMember>
+bool operator!=(const ClassFromMember<MemberType, kMember> lhs, ObjPtr<mirror::Class> rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename MemberType, MemberType** kMember>
+bool operator!=(ObjPtr<mirror::Class> lhs, const ClassFromMember<MemberType, kMember> rhs) {
+  return !(rhs == lhs);
+}
+
+}  // namespace detail
+}  // namespace art
+
+#endif  // ART_RUNTIME_WELL_KNOWN_CLASSES_INL_H_
diff --git a/runtime/well_known_classes.cc b/runtime/well_known_classes.cc
index a30d2d05e4..c963de466c 100644
--- a/runtime/well_known_classes.cc
+++ b/runtime/well_known_classes.cc
@@ -51,9 +51,6 @@ jclass WellKnownClasses::dalvik_annotation_optimization_NeverInline;
 jclass WellKnownClasses::dalvik_system_BaseDexClassLoader;
 jclass WellKnownClasses::dalvik_system_DelegateLastClassLoader;
 jclass WellKnownClasses::dalvik_system_DexClassLoader;
-jclass WellKnownClasses::dalvik_system_DexFile;
-jclass WellKnownClasses::dalvik_system_DexPathList;
-jclass WellKnownClasses::dalvik_system_DexPathList__Element;
 jclass WellKnownClasses::dalvik_system_EmulatedStackFrame;
 jclass WellKnownClasses::dalvik_system_InMemoryDexClassLoader;
 jclass WellKnownClasses::dalvik_system_PathClassLoader;
@@ -76,7 +73,6 @@ jclass WellKnownClasses::java_lang_StackOverflowError;
 jclass WellKnownClasses::java_lang_String;
 jclass WellKnownClasses::java_lang_StringFactory;
 jclass WellKnownClasses::java_lang_System;
-jclass WellKnownClasses::java_lang_Throwable;
 jclass WellKnownClasses::java_lang_Void;
 jclass WellKnownClasses::libcore_reflect_AnnotationMember__array;
 
@@ -364,9 +360,6 @@ void WellKnownClasses::Init(JNIEnv* env) {
   dalvik_system_BaseDexClassLoader = CacheClass(env, "dalvik/system/BaseDexClassLoader");
   dalvik_system_DelegateLastClassLoader = CacheClass(env, "dalvik/system/DelegateLastClassLoader");
   dalvik_system_DexClassLoader = CacheClass(env, "dalvik/system/DexClassLoader");
-  dalvik_system_DexFile = CacheClass(env, "dalvik/system/DexFile");
-  dalvik_system_DexPathList = CacheClass(env, "dalvik/system/DexPathList");
-  dalvik_system_DexPathList__Element = CacheClass(env, "dalvik/system/DexPathList$Element");
   dalvik_system_EmulatedStackFrame = CacheClass(env, "dalvik/system/EmulatedStackFrame");
   dalvik_system_InMemoryDexClassLoader = CacheClass(env, "dalvik/system/InMemoryDexClassLoader");
   dalvik_system_PathClassLoader = CacheClass(env, "dalvik/system/PathClassLoader");
@@ -390,7 +383,6 @@ void WellKnownClasses::Init(JNIEnv* env) {
   java_lang_String = CacheClass(env, "java/lang/String");
   java_lang_StringFactory = CacheClass(env, "java/lang/StringFactory");
   java_lang_System = CacheClass(env, "java/lang/System");
-  java_lang_Throwable = CacheClass(env, "java/lang/Throwable");
   java_lang_Void = CacheClass(env, "java/lang/Void");
   libcore_reflect_AnnotationMember__array = CacheClass(env, "[Llibcore/reflect/AnnotationMember;");
 
@@ -438,7 +430,13 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
   java_lang_reflect_Parameter_init = CacheMethod(env, java_lang_reflect_Parameter, false, "<init>", "(Ljava/lang/String;ILjava/lang/reflect/Executable;I)V");
   java_lang_String_charAt = CacheMethod(env, java_lang_String, false, "charAt", "(I)C");
 
-  StackHandleScope<17u> hs(self);
+  StackHandleScope<21u> hs(self);
+  Handle<mirror::Class> d_s_df =
+      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/DexFile;"));
+  Handle<mirror::Class> d_s_dpl =
+      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/DexPathList;"));
+  Handle<mirror::Class> d_s_dpl_e =
+      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/DexPathList$Element;"));
   Handle<mirror::Class> d_s_vmr =
       hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/VMRuntime;"));
   Handle<mirror::Class> j_i_fd =
@@ -447,6 +445,8 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
       hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Thread;"));
   Handle<mirror::Class> j_l_tg =
       hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/ThreadGroup;"));
+  Handle<mirror::Class> j_l_Throwable =
+      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Throwable;"));
   Handle<mirror::Class> j_l_i_MethodHandle =
       hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodHandle;"));
   Handle<mirror::Class> j_l_i_MethodHandles =
@@ -576,17 +576,14 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
       d_s_bdcl, /*is_static=*/ false, "sharedLibraryLoaders", "[Ljava/lang/ClassLoader;");
   dalvik_system_BaseDexClassLoader_sharedLibraryLoadersAfter = CacheField(
       d_s_bdcl, /*is_static=*/ false, "sharedLibraryLoadersAfter", "[Ljava/lang/ClassLoader;");
-  ObjPtr<mirror::Class> d_s_df = soa.Decode<mirror::Class>(dalvik_system_DexFile);
   dalvik_system_DexFile_cookie = CacheField(
-      d_s_df, /*is_static=*/ false, "mCookie", "Ljava/lang/Object;");
+      d_s_df.Get(), /*is_static=*/ false, "mCookie", "Ljava/lang/Object;");
   dalvik_system_DexFile_fileName = CacheField(
-      d_s_df, /*is_static=*/ false, "mFileName", "Ljava/lang/String;");
-  ObjPtr<mirror::Class> d_s_dpl = soa.Decode<mirror::Class>(dalvik_system_DexPathList);
+      d_s_df.Get(), /*is_static=*/ false, "mFileName", "Ljava/lang/String;");
   dalvik_system_DexPathList_dexElements = CacheField(
-      d_s_dpl, /*is_static=*/ false, "dexElements", "[Ldalvik/system/DexPathList$Element;");
-  ObjPtr<mirror::Class> d_s_dpl_e = soa.Decode<mirror::Class>(dalvik_system_DexPathList__Element);
+      d_s_dpl.Get(), /*is_static=*/ false, "dexElements", "[Ldalvik/system/DexPathList$Element;");
   dalvik_system_DexPathList__Element_dexFile = CacheField(
-      d_s_dpl_e, /*is_static=*/ false, "dexFile", "Ldalvik/system/DexFile;");
+      d_s_dpl_e.Get(), /*is_static=*/ false, "dexFile", "Ldalvik/system/DexFile;");
 
   dalvik_system_VMRuntime_nonSdkApiUsageConsumer = CacheField(
       d_s_vmr.Get(),
@@ -630,17 +627,16 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
   java_lang_ThreadGroup_systemThreadGroup =
       CacheField(j_l_tg.Get(), /*is_static=*/ true, "systemThreadGroup", "Ljava/lang/ThreadGroup;");
 
-  ObjPtr<mirror::Class> j_l_Throwable = soa.Decode<mirror::Class>(java_lang_Throwable);
   java_lang_Throwable_cause = CacheField(
-      j_l_Throwable, /*is_static=*/ false, "cause", "Ljava/lang/Throwable;");
+      j_l_Throwable.Get(), /*is_static=*/ false, "cause", "Ljava/lang/Throwable;");
   java_lang_Throwable_detailMessage = CacheField(
-      j_l_Throwable, /*is_static=*/ false, "detailMessage", "Ljava/lang/String;");
+      j_l_Throwable.Get(), /*is_static=*/ false, "detailMessage", "Ljava/lang/String;");
   java_lang_Throwable_stackTrace = CacheField(
-      j_l_Throwable, /*is_static=*/ false, "stackTrace", "[Ljava/lang/StackTraceElement;");
+      j_l_Throwable.Get(), /*is_static=*/ false, "stackTrace", "[Ljava/lang/StackTraceElement;");
   java_lang_Throwable_stackState = CacheField(
-      j_l_Throwable, /*is_static=*/ false, "backtrace", "Ljava/lang/Object;");
+      j_l_Throwable.Get(), /*is_static=*/ false, "backtrace", "Ljava/lang/Object;");
   java_lang_Throwable_suppressedExceptions = CacheField(
-      j_l_Throwable, /*is_static=*/ false, "suppressedExceptions", "Ljava/util/List;");
+      j_l_Throwable.Get(), /*is_static=*/ false, "suppressedExceptions", "Ljava/util/List;");
 
   java_nio_Buffer_address = CacheField(j_n_b.Get(), /*is_static=*/ false, "address", "J");
   java_nio_Buffer_capacity = CacheField(j_n_b.Get(), /*is_static=*/ false, "capacity", "I");
@@ -706,9 +702,6 @@ void WellKnownClasses::Clear() {
   dalvik_system_BaseDexClassLoader = nullptr;
   dalvik_system_DelegateLastClassLoader = nullptr;
   dalvik_system_DexClassLoader = nullptr;
-  dalvik_system_DexFile = nullptr;
-  dalvik_system_DexPathList = nullptr;
-  dalvik_system_DexPathList__Element = nullptr;
   dalvik_system_EmulatedStackFrame = nullptr;
   dalvik_system_PathClassLoader = nullptr;
   java_lang_annotation_Annotation__array = nullptr;
@@ -730,7 +723,6 @@ void WellKnownClasses::Clear() {
   java_lang_String = nullptr;
   java_lang_StringFactory = nullptr;
   java_lang_System = nullptr;
-  java_lang_Throwable = nullptr;
   java_lang_Void = nullptr;
   libcore_reflect_AnnotationMember__array = nullptr;
 
diff --git a/runtime/well_known_classes.h b/runtime/well_known_classes.h
index 1f5b03f367..f8b50e3dd1 100644
--- a/runtime/well_known_classes.h
+++ b/runtime/well_known_classes.h
@@ -20,6 +20,7 @@
 #include "base/locks.h"
 #include "jni.h"
 #include "obj_ptr.h"
+#include "read_barrier_option.h"
 
 namespace art {
 
@@ -30,6 +31,34 @@ namespace mirror {
 class Class;
 }  // namespace mirror
 
+namespace detail {
+
+template <typename MemberType, MemberType** kMember>
+struct ClassFromMember {
+  template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
+  static ObjPtr<mirror::Class> Get() REQUIRES_SHARED(Locks::mutator_lock_);
+
+  mirror::Class* operator->() const REQUIRES_SHARED(Locks::mutator_lock_);
+};
+
+template <typename MemberType, MemberType** kMember>
+bool operator==(const ClassFromMember<MemberType, kMember> lhs, ObjPtr<mirror::Class> rhs)
+    REQUIRES_SHARED(Locks::mutator_lock_);
+
+template <typename MemberType, MemberType** kMember>
+bool operator==(ObjPtr<mirror::Class> lhs, const ClassFromMember<MemberType, kMember> rhs)
+    REQUIRES_SHARED(Locks::mutator_lock_);
+
+template <typename MemberType, MemberType** kMember>
+bool operator!=(const ClassFromMember<MemberType, kMember> lhs, ObjPtr<mirror::Class> rhs)
+    REQUIRES_SHARED(Locks::mutator_lock_);
+
+template <typename MemberType, MemberType** kMember>
+bool operator!=(ObjPtr<mirror::Class> lhs, const ClassFromMember<MemberType, kMember> rhs)
+    REQUIRES_SHARED(Locks::mutator_lock_);
+
+}  // namespace detail
+
 // Various classes used in JNI. We cache them so we don't have to keep looking them up.
 
 struct WellKnownClasses {
@@ -54,6 +83,12 @@ struct WellKnownClasses {
  private:
   static void InitFieldsAndMethodsOnly(JNIEnv* env);
 
+  template <ArtMethod** kMethod>
+  using ClassFromMethod = detail::ClassFromMember<ArtMethod, kMethod>;
+
+  template <ArtField** kField>
+  using ClassFromField = detail::ClassFromMember<ArtField, kField>;
+
  public:
   static jclass dalvik_annotation_optimization_CriticalNative;
   static jclass dalvik_annotation_optimization_FastNative;
@@ -62,9 +97,6 @@ struct WellKnownClasses {
   static jclass dalvik_system_BaseDexClassLoader;
   static jclass dalvik_system_DelegateLastClassLoader;
   static jclass dalvik_system_DexClassLoader;
-  static jclass dalvik_system_DexFile;
-  static jclass dalvik_system_DexPathList;
-  static jclass dalvik_system_DexPathList__Element;
   static jclass dalvik_system_EmulatedStackFrame;
   static jclass dalvik_system_InMemoryDexClassLoader;
   static jclass dalvik_system_PathClassLoader;
@@ -87,7 +119,6 @@ struct WellKnownClasses {
   static jclass java_lang_String;
   static jclass java_lang_StringFactory;
   static jclass java_lang_System;
-  static jclass java_lang_Throwable;
   static jclass java_lang_Void;
   static jclass libcore_reflect_AnnotationMember__array;
 
@@ -178,6 +209,18 @@ struct WellKnownClasses {
   static ArtField* org_apache_harmony_dalvik_ddmc_Chunk_length;
   static ArtField* org_apache_harmony_dalvik_ddmc_Chunk_offset;
   static ArtField* org_apache_harmony_dalvik_ddmc_Chunk_type;
+
+  static constexpr ClassFromField<&dalvik_system_DexFile_cookie> dalvik_system_DexFile;
+  static constexpr ClassFromField<&dalvik_system_DexPathList_dexElements> dalvik_system_DexPathList;
+  static constexpr ClassFromField<&dalvik_system_DexPathList__Element_dexFile>
+      dalvik_system_DexPathList__Element;
+  static constexpr ClassFromField<&java_lang_Thread_daemon> java_lang_Thread;
+  static constexpr ClassFromField<&java_lang_ThreadGroup_groups> java_lang_ThreadGroup;
+  static constexpr ClassFromField<&java_lang_Throwable_cause> java_lang_Throwable;
+  static constexpr ClassFromField<&java_nio_Buffer_address> java_nio_Buffer;
+  static constexpr ClassFromField<&java_util_Collections_EMPTY_LIST> java_util_Collections;
+  static constexpr ClassFromField<&libcore_util_EmptyArray_STACK_TRACE_ELEMENT>
+      libcore_util_EmptyArray;
 };
 
 }  // namespace art