Quelle  well_known_classes.cc

/*
 * Copyright (C) 2012 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.
 */

#include "well_known_classes.h"

#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <stdlib.h>

#include <cstddef>
#include <sstream>

#include "art_field.h"
#include "art_method-inl.h"
#include "art_method.h"
#include "base/casts.h"
#include "base/pointer_size.h"
#include "class_linker.h"
#include "class_root-inl.h"
#include "entrypoints/quick/quick_entrypoints_enum.h"
#include "handle_scope-inl.h"
#include "hidden_api.h"
#include "jni/java_vm_ext.h"
#include "jni/jni_internal.h"
#include "jni_id_type.h"
#include "mirror/class.h"
#include "mirror/throwable.h"
#include "nativehelper/scoped_local_ref.h"
#include "obj_ptr-inl.h"
#include "runtime.h"
#include "scoped_thread_state_change-inl.h"
#include "scoped_thread_state_change.h"
#include "thread-current-inl.h"

namespace art HIDDEN {

jclass WellKnownClasses::dalvik_annotation_optimization_CriticalNative;
jclass WellKnownClasses::dalvik_annotation_optimization_FastNative;
jclass WellKnownClasses::dalvik_annotation_optimization_NeverCompile;
jclass WellKnownClasses::dalvik_annotation_optimization_NeverInline;
jclass WellKnownClasses::dalvik_system_VirtualThreadFrame__array;
jclass WellKnownClasses::java_lang_annotation_Annotation__array;
jclass WellKnownClasses::java_lang_ClassValue;
jclass WellKnownClasses::java_lang_Record;
jclass WellKnownClasses::java_lang_reflect_Parameter__array;
jclass WellKnownClasses::java_lang_StringFactory;
jclass WellKnownClasses::java_lang_Void;
jclass WellKnownClasses::java_util_concurrent_atomic_AIFU;
jclass WellKnownClasses::java_util_concurrent_atomic_ALFU;
jclass WellKnownClasses::java_util_concurrent_atomic_ARFU;
jclass WellKnownClasses::jdk_internal_misc_Unsafe;
jclass WellKnownClasses::libcore_reflect_AnnotationMember__array;
jclass WellKnownClasses::sun_misc_Unsafe;

ArtMethod* WellKnownClasses::dalvik_system_BaseDexClassLoader_getLdLibraryPath;
ArtMethod* WellKnownClasses::dalvik_system_DelegateLastClassLoader_init;
ArtMethod* WellKnownClasses::dalvik_system_DexClassLoader_init;
ArtMethod* WellKnownClasses::dalvik_system_DexFile_init;
ArtMethod* WellKnownClasses::dalvik_system_DexPathList_init;
ArtMethod* WellKnownClasses::dalvik_system_DexPathList__Element_init;
ArtMethod* WellKnownClasses::dalvik_system_InMemoryDexClassLoader_init;
ArtMethod* WellKnownClasses::dalvik_system_PathClassLoader_init;
ArtMethod* WellKnownClasses::dalvik_system_VMRuntime_hiddenApiUsed;
ArtMethod* WellKnownClasses::dalvik_system_VirtualThreadParkedStates_init;
ArtMethod* WellKnownClasses::java_lang_Boolean_valueOf;
ArtMethod* WellKnownClasses::java_lang_BootClassLoader_init;
ArtMethod* WellKnownClasses::java_lang_Byte_valueOf;
ArtMethod* WellKnownClasses::java_lang_Byte_ByteCache_init;
ArtMethod* WellKnownClasses::java_lang_Character_valueOf;
ArtMethod* WellKnownClasses::java_lang_Character_CharacterCache_init;
ArtMethod* WellKnownClasses::java_lang_ClassLoader_loadClass;
ArtMethod* WellKnownClasses::java_lang_ClassNotFoundException_init;
ArtMethod* WellKnownClasses::java_lang_Daemons_start;
ArtMethod* WellKnownClasses::java_lang_Daemons_stop;
ArtMethod* WellKnownClasses::java_lang_Daemons_waitForDaemonStart;
ArtMethod* WellKnownClasses::java_lang_Double_doubleToRawLongBits;
ArtMethod* WellKnownClasses::java_lang_Double_valueOf;
ArtMethod* WellKnownClasses::java_lang_Error_init;
ArtMethod* WellKnownClasses::java_lang_Float_floatToRawIntBits;
ArtMethod* WellKnownClasses::java_lang_Float_valueOf;
ArtMethod* WellKnownClasses::java_lang_IllegalAccessError_init;
ArtMethod* WellKnownClasses::java_lang_Integer_valueOf;
ArtMethod* WellKnownClasses::java_lang_Integer_IntegerCache_init;
ArtMethod* WellKnownClasses::java_lang_Long_valueOf;
ArtMethod* WellKnownClasses::java_lang_Long_LongCache_init;
ArtMethod* WellKnownClasses::java_lang_NoClassDefFoundError_init;
ArtMethod* WellKnownClasses::java_lang_OutOfMemoryError_init;
ArtMethod* WellKnownClasses::java_lang_Runnable_run;
ArtMethod* WellKnownClasses::java_lang_Runtime_nativeLoad;
ArtMethod* WellKnownClasses::java_lang_RuntimeException_init;
ArtMethod* WellKnownClasses::java_lang_Short_valueOf;
ArtMethod* WellKnownClasses::java_lang_Short_ShortCache_init;
ArtMethod* WellKnownClasses::java_lang_StackOverflowError_init;
ArtMethod* WellKnownClasses::java_lang_String_charAt;
ArtMethod* WellKnownClasses::java_lang_System_identityHashCode;
ArtMethod* WellKnownClasses::java_lang_Thread_dispatchUncaughtException;
ArtMethod* WellKnownClasses::java_lang_Thread_init;
ArtMethod* WellKnownClasses::java_lang_Thread_parkVirtualInternal;
ArtMethod* WellKnownClasses::java_lang_Thread_run;
ArtMethod* WellKnownClasses::java_lang_ThreadGroup_add;
ArtMethod* WellKnownClasses::java_lang_ThreadGroup_threadTerminated;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandle_asType;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandle_invokeExact;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandleImpl_fieldInit;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandleImpl_init;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandles_lookup;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandles_makeIdentity;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodHandles_Lookup_findConstructor;
ArtMethod* WellKnownClasses::java_lang_invoke_MethodType_makeImpl;
ArtMethod* WellKnownClasses::java_lang_ref_FinalizerReference_add;
ArtMethod* WellKnownClasses::java_lang_ref_ReferenceQueue_add;
ArtMethod* WellKnownClasses::java_lang_reflect_InvocationTargetException_init;
ArtMethod* WellKnownClasses::java_lang_reflect_Parameter_init;
ArtMethod* WellKnownClasses::java_lang_reflect_Proxy_init;
ArtMethod* WellKnownClasses::java_lang_reflect_Proxy_invoke;
ArtMethod* WellKnownClasses::java_nio_Buffer_isDirect;
ArtMethod* WellKnownClasses::java_nio_DirectByteBuffer_init;
ArtMethod* WellKnownClasses::java_util_Collections_emptyList;
ArtMethod* WellKnownClasses::java_util_concurrent_ThreadLocalRandom_current;
ArtMethod* WellKnownClasses::java_util_function_Consumer_accept;
ArtMethod* WellKnownClasses::jdk_internal_foreign_NativeMemorySegmentImpl_isNative;
ArtMethod* WellKnownClasses::jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_D;
ArtMethod* WellKnownClasses::jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_F;
ArtMethod* WellKnownClasses::jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_getChars;
ArtMethod* WellKnownClasses::
    jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_toJavaFormatString;
ArtMethod* WellKnownClasses::jdk_internal_vm_Continuation_doYieldNative;
ArtMethod* WellKnownClasses::jdk_internal_vm_Continuation_enter;
ArtMethod* WellKnownClasses::jdk_internal_vm_Continuation_enterSpecial;
ArtMethod* WellKnownClasses::libcore_reflect_AnnotationFactory_createAnnotation;
ArtMethod* WellKnownClasses::libcore_reflect_AnnotationMember_init;
ArtMethod* WellKnownClasses::libcore_util_EmptyArray_init;
ArtMethod* WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_broadcast;
ArtMethod* WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_dispatch;

ArtField* WellKnownClasses::dalvik_system_BaseDexClassLoader_pathList;
ArtField* WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoaders;
ArtField* WellKnownClasses::dalvik_system_BaseDexClassLoader_sharedLibraryLoadersAfter;
ArtField* WellKnownClasses::dalvik_system_DexFile_cookie;
ArtField* WellKnownClasses::dalvik_system_DexFile_fileName;
ArtField* WellKnownClasses::dalvik_system_DexPathList_dexElements;
ArtField* WellKnownClasses::dalvik_system_DexPathList__Element_dexFile;
ArtField* WellKnownClasses::dalvik_system_VMRuntime_nonSdkApiUsageConsumer;
ArtField* WellKnownClasses::dalvik_system_VirtualThreadParkedStates_frames;
ArtField* WellKnownClasses::java_io_FileDescriptor_descriptor;
ArtField* WellKnownClasses::java_lang_invoke_MethodHandle_type;
ArtField* WellKnownClasses::java_lang_ref_Reference_disableIntrinsic;
ArtField* WellKnownClasses::java_lang_ref_Reference_slowPathEnabled;
ArtField* WellKnownClasses::java_lang_ClassLoader_parent;
ArtField* WellKnownClasses::java_lang_Object_shadowKlass;
ArtField* WellKnownClasses::java_lang_System_in;
ArtField* WellKnownClasses::java_lang_System_out;
ArtField* WellKnownClasses::java_lang_System_err;
ArtField* WellKnownClasses::java_lang_String_EMPTY;
ArtField* WellKnownClasses::java_lang_Thread_cont;
ArtField* WellKnownClasses::java_lang_Thread_parkBlocker;
ArtField* WellKnownClasses::java_lang_Thread_daemon;
ArtField* WellKnownClasses::java_lang_Thread_group;
ArtField* WellKnownClasses::java_lang_Thread_lock;
ArtField* WellKnownClasses::java_lang_Thread_name;
ArtField* WellKnownClasses::java_lang_Thread_niceness;
ArtField* WellKnownClasses::java_lang_Thread_nativePeer;
ArtField* WellKnownClasses::java_lang_Thread_priority;
ArtField* WellKnownClasses::java_lang_Thread_systemDaemon;
ArtField* WellKnownClasses::java_lang_Thread_unparkedBeforeStart;
ArtField* WellKnownClasses::java_lang_Thread_target;
ArtField* WellKnownClasses::java_lang_ThreadGroup_groups;
ArtField* WellKnownClasses::java_lang_ThreadGroup_ngroups;
ArtField* WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup;
ArtField* WellKnownClasses::java_lang_ThreadGroup_name;
ArtField* WellKnownClasses::java_lang_ThreadGroup_parent;
ArtField* WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup;
ArtField* WellKnownClasses::java_lang_Throwable_cause;
ArtField* WellKnownClasses::java_lang_Throwable_detailMessage;
ArtField* WellKnownClasses::java_lang_Throwable_stackTrace;
ArtField* WellKnownClasses::java_lang_Throwable_stackState;
ArtField* WellKnownClasses::java_lang_Throwable_suppressedExceptions;
ArtField* WellKnownClasses::jdk_internal_foreign_NativeMemorySegmentImpl_min;
ArtField* WellKnownClasses::jdk_internal_foreign_AbstractMemorySegmentImpl_length;
ArtField* WellKnownClasses::jdk_internal_foreign_AbstractMemorySegmentImpl_readOnly;
ArtField* WellKnownClasses::java_nio_Buffer_address;
ArtField* WellKnownClasses::java_nio_Buffer_capacity;
ArtField* WellKnownClasses::java_nio_Buffer_elementSizeShift;
ArtField* WellKnownClasses::java_nio_Buffer_limit;
ArtField* WellKnownClasses::java_nio_Buffer_position;
ArtField* WellKnownClasses::java_nio_ByteBuffer_hb;
ArtField* WellKnownClasses::java_nio_ByteBuffer_isReadOnly;
ArtField* WellKnownClasses::java_nio_ByteBuffer_offset;
ArtField* WellKnownClasses::java_util_Collections_EMPTY_LIST;
ArtField* WellKnownClasses::java_util_concurrent_ThreadLocalRandom_seeder;
ArtField* WellKnownClasses::jdk_internal_vm_Continuation_virtualThreadContext;
ArtField* WellKnownClasses::jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_buffer;
ArtField* WellKnownClasses::jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_image;
ArtField* WellKnownClasses::libcore_util_EmptyArray_STACK_TRACE_ELEMENT;
ArtField* WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_data;
ArtField* WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_length;
ArtField* WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_offset;
ArtField* WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_type;

ArtField* WellKnownClasses::java_lang_Byte_ByteCache_cache;
ArtField* WellKnownClasses::java_lang_Character_CharacterCache_cache;
ArtField* WellKnownClasses::java_lang_Short_ShortCache_cache;
ArtField* WellKnownClasses::java_lang_Integer_IntegerCache_cache;
ArtField* WellKnownClasses::java_lang_Long_LongCache_cache;

ArtField* WellKnownClasses::java_lang_Boolean_value;
ArtField* WellKnownClasses::java_lang_Float_value;
ArtField* WellKnownClasses::java_lang_Double_value;
ArtField* WellKnownClasses::java_lang_Byte_value;
ArtField* WellKnownClasses::java_lang_Character_value;
ArtField* WellKnownClasses::java_lang_Short_value;
ArtField* WellKnownClasses::java_lang_Integer_value;
ArtField* WellKnownClasses::java_lang_Long_value;

static ObjPtr<mirror::Class> FindSystemClass(ClassLinker* class_linker,
                                             Thread* self,
                                             const char* descriptor)
    REQUIRES_SHARED(Locks::mutator_lock_) {
  ObjPtr<mirror::Class> klass = class_linker->FindSystemClass(self, descriptor);
  CHECK(klass != nullptr) << "Couldn't find system class: " << descriptor;
  return klass;
}

static jclass CacheClass(JNIEnv* env, const char* jni_class_name) {
  ScopedLocalRef<jclass> c(env, env->FindClass(jni_class_name));
  if (c.get() == nullptr) {
    LOG(FATAL) << "Couldn't find class: " << jni_class_name;
  }
  return reinterpret_cast<jclass>(env->NewGlobalRef(c.get()));
}

static ArtField* CacheField(ObjPtr<mirror::Class> klass,
                            bool is_static,
                            const char* name,
                            const char* signature) REQUIRES_SHARED(Locks::mutator_lock_) {
  ArtField* field = is_static
      ? klass->FindDeclaredStaticField(name, signature)
      : klass->FindDeclaredInstanceField(name, signature);
  if (UNLIKELY(field == nullptr)) {
    std::ostringstream os;
    klass->DumpClass(os, mirror::Class::kDumpClassFullDetail);
    LOG(FATAL) << "Couldn't find " << (is_static ? "static" : "instance") << " field \""
               << name << "\" with signature \"" << signature << "\": " << os.str();
    UNREACHABLE();
  }
  return field;
}

static ArtMethod* CacheMethod(ObjPtr<mirror::Class> klass,
                              bool is_static,
                              const char* name,
                              const char* signature,
                              PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_) {
  ArtMethod* method = klass->IsInterface()
      ? klass->FindInterfaceMethod(name, signature, pointer_size)
      : klass->FindClassMethod(name, signature, pointer_size);
  if (UNLIKELY(method == nullptr) || UNLIKELY(is_static != method->IsStatic())) {
    std::ostringstream os;
    klass->DumpClass(os, mirror::Class::kDumpClassFullDetail);
    LOG(FATAL) << "Couldn't find " << (is_static ? "static" : "instance") << " method \""
               << name << "\" with signature \"" << signature << "\": " << os.str();
    UNREACHABLE();
  }
  DCHECK(method->GetDeclaringClass() == klass);
  return method;
}

static ArtMethod* CacheConstructor(ObjPtr<mirror::Class> klass,
                                   const char* signature,
                                   PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_) {
  return CacheMethod(klass, /*is_static=*/ false, "<init>", signature, pointer_size);
}

static ArtMethod* CachePrimitiveBoxingMethod(ClassLinker* class_linker,
                                             Thread* self,
                                             char prim_name,
                                             const char* boxed_name)
    REQUIRES_SHARED(Locks::mutator_lock_) {
  ObjPtr<mirror::Class> boxed_class = FindSystemClass(class_linker, self, boxed_name);
  PointerSize pointer_size = class_linker->GetImagePointerSize();
  std::string signature = android::base::StringPrintf("(%c)%s", prim_name, boxed_name);
  return CacheMethod(boxed_class, /*is_static=*/ true, "valueOf", signature.c_str(), pointer_size);
}

static ArtMethod* CachePrimitiveBoxingCacheConstructor(ClassLinker* class_linker,
                                                       Thread* self,
                                                       const char* cache_name,
                                                       PointerSize pointer_size)
    REQUIRES_SHARED(Locks::mutator_lock_) {
  ObjPtr<mirror::Class> cache_class = FindSystemClass(class_linker, self, cache_name);
  return CacheConstructor(cache_class, "()V", pointer_size);
}

static ArtField* CacheValueInBoxField(ArtMethod* boxed_class_valueOf, const char* cache_type)
    REQUIRES_SHARED(Locks::mutator_lock_) {
  ObjPtr<mirror::Class> boxed_class = boxed_class_valueOf->GetDeclaringClass();
  return CacheField(boxed_class, /*is_static=*/ false, "value", cache_type);
}

static ArtField* CacheBoxingCacheField(ArtMethod* cache_class_init, const char* cache_type)
    REQUIRES_SHARED(Locks::mutator_lock_) {
  ObjPtr<mirror::Class> cache_class = cache_class_init->GetDeclaringClass();
  return CacheField(cache_class, /*is_static=*/ true, "cache", cache_type);
}

#define STRING_INIT_LIST(V) \
  V(java_lang_String_init, "()V", newEmptyString, "newEmptyString", "()Ljava/lang/String;", NewEmptyString) \
  V(java_lang_String_init_B, "([B)V", newStringFromBytes_B, "newStringFromBytes", "([B)Ljava/lang/String;", NewStringFromBytes_B) \
  V(java_lang_String_init_BB, "([BB)V", newStringFromBytes_BB, "newStringFromBytes", "([BB)Ljava/lang/String;", NewStringFromBytes_BB) \
  V(java_lang_String_init_BI, "([BI)V", newStringFromBytes_BI, "newStringFromBytes", "([BI)Ljava/lang/String;", NewStringFromBytes_BI) \
  V(java_lang_String_init_BII, "([BII)V", newStringFromBytes_BII, "newStringFromBytes", "([BII)Ljava/lang/String;", NewStringFromBytes_BII) \
  V(java_lang_String_init_BIII, "([BIII)V", newStringFromBytes_BIII, "newStringFromBytes", "([BIII)Ljava/lang/String;", NewStringFromBytes_BIII) \
  V(java_lang_String_init_BIIString, "([BIILjava/lang/String;)V", newStringFromBytes_BIIString, "newStringFromBytes", "([BIILjava/lang/String;)Ljava/lang/String;", NewStringFromBytes_BIIString) \
  V(java_lang_String_init_BString, "([BLjava/lang/String;)V", newStringFromBytes_BString, "newStringFromBytes", "([BLjava/lang/String;)Ljava/lang/String;", NewStringFromBytes_BString) \
  V(java_lang_String_init_BIICharset, "([BIILjava/nio/charset/Charset;)V", newStringFromBytes_BIICharset, "newStringFromBytes", "([BIILjava/nio/charset/Charset;)Ljava/lang/String;", NewStringFromBytes_BIICharset) \
  V(java_lang_String_init_BCharset, "([BLjava/nio/charset/Charset;)V", newStringFromBytes_BCharset, "newStringFromBytes", "([BLjava/nio/charset/Charset;)Ljava/lang/String;", NewStringFromBytes_BCharset) \
  V(java_lang_String_init_C, "([C)V", newStringFromChars_C, "newStringFromChars", "([C)Ljava/lang/String;", NewStringFromChars_C) \
  V(java_lang_String_init_CII, "([CII)V", newStringFromChars_CII, "newStringFromChars", "([CII)Ljava/lang/String;", NewStringFromChars_CII) \
  V(java_lang_String_init_IIC, "(II[C)V", newStringFromChars_IIC, "newStringFromChars", "(II[C)Ljava/lang/String;", NewStringFromChars_IIC) \
  V(java_lang_String_init_String, "(Ljava/lang/String;)V", newStringFromString, "newStringFromString", "(Ljava/lang/String;)Ljava/lang/String;", NewStringFromString) \
  V(java_lang_String_init_StringBuffer, "(Ljava/lang/StringBuffer;)V", newStringFromStringBuffer, "newStringFromStringBuffer", "(Ljava/lang/StringBuffer;)Ljava/lang/String;", NewStringFromStringBuffer) \
  V(java_lang_String_init_III, "([III)V", newStringFromCodePoints, "newStringFromCodePoints", "([III)Ljava/lang/String;", NewStringFromCodePoints) \
  V(java_lang_String_init_StringBuilder, "(Ljava/lang/StringBuilder;)V", newStringFromStringBuilder, "newStringFromStringBuilder", "(Ljava/lang/StringBuilder;)Ljava/lang/String;", NewStringFromStringBuilder) \

#define STATIC_STRING_INIT(init_runtime_name, init_signature, new_runtime_name, ...) \
    static ArtMethod* init_runtime_name = nullptr; \
    static ArtMethod* new_runtime_name = nullptr;
    STRING_INIT_LIST(STATIC_STRING_INIT)
#undef STATIC_STRING_INIT

void WellKnownClasses::InitStringInit(ObjPtr<mirror::Class> string_class,
                                      ObjPtr<mirror::Class> string_builder_class) {
  PointerSize p_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
  auto find_method = [p_size](ObjPtr<mirror::Class> klass,
                              const char* name,
                              const char* sig,
                              bool expext_static) REQUIRES_SHARED(Locks::mutator_lock_) {
    ArtMethod* ret = klass->FindClassMethod(name, sig, p_size);
    CHECK(ret != nullptr);
    CHECK_EQ(expext_static, ret->IsStatic());
    return ret;
  };

  #define LOAD_STRING_INIT(init_runtime_name, init_signature, new_runtime_name,                  \
                           new_java_name, new_signature, ...)                                    \
      init_runtime_name = find_method(string_class, "<init>", init_signature, false);            \
      new_runtime_name = find_method(string_builder_class, new_java_name, new_signature, true);
      STRING_INIT_LIST(LOAD_STRING_INIT)
  #undef LOAD_STRING_INIT
}

void Thread::InitStringEntryPoints() {
  QuickEntryPoints* qpoints = &tlsPtr_.quick_entrypoints;
#define SET_ENTRY_POINT(init_runtime_name,                                        \
                        init_signature,                                           \
                        new_runtime_name,                                         \
                        new_java_name,                                            \
                        new_signature,                                            \
                        entry_point_name)                                         \
  DCHECK_IMPLIES(Runtime::Current()->IsStarted(), (new_runtime_name) != nullptr); \
  qpoints->p##entry_point_name = reinterpret_cast<void*>(new_runtime_name);
  STRING_INIT_LIST(SET_ENTRY_POINT)
#undef SET_ENTRY_POINT
}

ArtMethod* WellKnownClasses::StringInitToStringFactory(ArtMethod* string_init) {
  #define TO_STRING_FACTORY(init_runtime_name, init_signature, new_runtime_name,            \
                            new_java_name, new_signature, entry_point_name)                 \
      DCHECK((init_runtime_name) != nullptr);                                               \
      if (string_init == (init_runtime_name)) {                                             \
        DCHECK((new_runtime_name) != nullptr);                                              \
        return (new_runtime_name);                                                          \
      }
      STRING_INIT_LIST(TO_STRING_FACTORY)
  #undef TO_STRING_FACTORY
  LOG(FATAL) << "Could not find StringFactory method for String.<init>";
  UNREACHABLE();
}

uint32_t WellKnownClasses::StringInitToEntryPoint(ArtMethod* string_init) {
  #define TO_ENTRY_POINT(init_runtime_name, init_signature, new_runtime_name,               \
                         new_java_name, new_signature, entry_point_name)                    \
      if (string_init == (init_runtime_name)) {                                             \
        return kQuick ## entry_point_name;                                                  \
      }
      STRING_INIT_LIST(TO_ENTRY_POINT)
  #undef TO_ENTRY_POINT
  LOG(FATAL) << "Could not find StringFactory method for String.<init>";
  UNREACHABLE();
}
#undef STRING_INIT_LIST

void WellKnownClasses::Init(JNIEnv* env) {
  hiddenapi::ScopedHiddenApiEnforcementPolicySetting hiddenapi_exemption(
      hiddenapi::EnforcementPolicy::kDisabled);

  dalvik_annotation_optimization_CriticalNative =
      CacheClass(env, "dalvik/annotation/optimization/CriticalNative");
  dalvik_annotation_optimization_FastNative = CacheClass(env, "dalvik/annotation/optimization/FastNative");
  dalvik_annotation_optimization_NeverCompile =
      CacheClass(env, "dalvik/annotation/optimization/NeverCompile");
  dalvik_annotation_optimization_NeverInline =
      CacheClass(env, "dalvik/annotation/optimization/NeverInline");
  dalvik_system_VirtualThreadFrame__array = CacheClass(env, "[Ldalvik/system/VirtualThreadFrame;");

  java_lang_annotation_Annotation__array = CacheClass(env, "[Ljava/lang/annotation/Annotation;");
  java_lang_ClassValue = CacheClass(env, "java/lang/ClassValue");
  java_lang_Record = CacheClass(env, "java/lang/Record");
  java_lang_reflect_Parameter__array = CacheClass(env, "[Ljava/lang/reflect/Parameter;");
  java_lang_StringFactory = CacheClass(env, "java/lang/StringFactory");
  java_lang_Void = CacheClass(env, "java/lang/Void");
  java_util_concurrent_atomic_AIFU =
      CacheClass(env, "java/util/concurrent/atomic/AtomicIntegerFieldUpdater");
  java_util_concurrent_atomic_ALFU =
      CacheClass(env, "java/util/concurrent/atomic/AtomicLongFieldUpdater");
  java_util_concurrent_atomic_ARFU =
      CacheClass(env, "java/util/concurrent/atomic/AtomicReferenceFieldUpdater");
  jdk_internal_misc_Unsafe = CacheClass(env, "jdk/internal/misc/Unsafe");
  libcore_reflect_AnnotationMember__array = CacheClass(env, "[Llibcore/reflect/AnnotationMember;");
  sun_misc_Unsafe = CacheClass(env, "sun/misc/Unsafe");

  InitFieldsAndMethodsOnly(env);
}

void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
  hiddenapi::ScopedHiddenApiEnforcementPolicySetting hiddenapi_exemption(
      hiddenapi::EnforcementPolicy::kDisabled);

  Thread* self = Thread::ForEnv(env);
  ScopedObjectAccess soa(self);
  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
  PointerSize pointer_size = class_linker->GetImagePointerSize();

  java_lang_Boolean_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'Z', "Ljava/lang/Boolean;");
  java_lang_Byte_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'B', "Ljava/lang/Byte;");
  java_lang_Character_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'C', "Ljava/lang/Character;");
  java_lang_Double_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'D', "Ljava/lang/Double;");
  java_lang_Float_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'F', "Ljava/lang/Float;");
  java_lang_Integer_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'I', "Ljava/lang/Integer;");
  java_lang_Long_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'J', "Ljava/lang/Long;");
  java_lang_Short_valueOf =
      CachePrimitiveBoxingMethod(class_linker, self, 'S', "Ljava/lang/Short;");

  java_lang_Byte_ByteCache_init = CachePrimitiveBoxingCacheConstructor(
      class_linker, self, "Ljava/lang/Byte$ByteCache;", pointer_size);
  java_lang_Character_CharacterCache_init = CachePrimitiveBoxingCacheConstructor(
      class_linker, self, "Ljava/lang/Character$CharacterCache;", pointer_size);
  java_lang_Integer_IntegerCache_init = CachePrimitiveBoxingCacheConstructor(
      class_linker, self, "Ljava/lang/Integer$IntegerCache;", pointer_size);
  java_lang_Long_LongCache_init = CachePrimitiveBoxingCacheConstructor(
      class_linker, self, "Ljava/lang/Long$LongCache;", pointer_size);
  java_lang_Short_ShortCache_init = CachePrimitiveBoxingCacheConstructor(
      class_linker, self, "Ljava/lang/Short$ShortCache;", pointer_size);

  java_lang_Boolean_value = CacheValueInBoxField(java_lang_Boolean_valueOf, "Z");
  java_lang_Byte_value = CacheValueInBoxField(java_lang_Byte_valueOf, "B");
  java_lang_Character_value = CacheValueInBoxField(java_lang_Character_valueOf, "C");
  java_lang_Double_value = CacheValueInBoxField(java_lang_Double_valueOf, "D");
  java_lang_Float_value = CacheValueInBoxField(java_lang_Float_valueOf, "F");
  java_lang_Integer_value = CacheValueInBoxField(java_lang_Integer_valueOf, "I");
  java_lang_Long_value = CacheValueInBoxField(java_lang_Long_valueOf, "J");
  java_lang_Short_value = CacheValueInBoxField(java_lang_Short_valueOf, "S");

  java_lang_Byte_ByteCache_cache =
      CacheBoxingCacheField(java_lang_Byte_ByteCache_init, "[Ljava/lang/Byte;");
  java_lang_Character_CharacterCache_cache =
      CacheBoxingCacheField(java_lang_Character_CharacterCache_init, "[Ljava/lang/Character;");
  java_lang_Integer_IntegerCache_cache =
      CacheBoxingCacheField(java_lang_Integer_IntegerCache_init, "[Ljava/lang/Integer;");
  java_lang_Long_LongCache_cache =
      CacheBoxingCacheField(java_lang_Long_LongCache_init, "[Ljava/lang/Long;");
  java_lang_Short_ShortCache_cache =
      CacheBoxingCacheField(java_lang_Short_ShortCache_init, "[Ljava/lang/Short;");

  StackHandleScope<53u> hs(self);
  Handle<mirror::Class> d_s_bdcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/BaseDexClassLoader;"));
  Handle<mirror::Class> d_s_dlcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/DelegateLastClassLoader;"));
  Handle<mirror::Class> d_s_dcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/DexClassLoader;"));
  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_imdcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/InMemoryDexClassLoader;"));
  Handle<mirror::Class> d_s_pcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/PathClassLoader;"));
  Handle<mirror::Class> d_s_vmr =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ldalvik/system/VMRuntime;"));
  Handle<mirror::Class> d_s_vtps = hs.NewHandle(
      FindSystemClass(class_linker, self, "Ldalvik/system/VirtualThreadParkedStates;"));
  Handle<mirror::Class> j_i_fd =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/io/FileDescriptor;"));
  Handle<mirror::Class> j_l_bcl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/BootClassLoader;"));
  Handle<mirror::Class> j_l_cl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/ClassLoader;"));
  Handle<mirror::Class> j_l_cnfe =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/ClassNotFoundException;"));
  Handle<mirror::Class> j_l_Daemons =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Daemons;"));
  Handle<mirror::Class> j_l_Error =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Error;"));
  Handle<mirror::Class> j_l_IllegalAccessError =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/IllegalAccessError;"));
  Handle<mirror::Class> j_l_NoClassDefFoundError =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/NoClassDefFoundError;"));
  Handle<mirror::Class> j_l_OutOfMemoryError =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/OutOfMemoryError;"));
  Handle<mirror::Class> j_l_Runnable =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Runnable;"));
  Handle<mirror::Class> j_l_RuntimeException =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/RuntimeException;"));
  Handle<mirror::Class> j_l_StackOverflowError =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/StackOverflowError;"));
  Handle<mirror::Class> j_l_System =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/System;"));
  Handle<mirror::Class> j_l_Thread =
      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_i_MethodHandle =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodHandle;"));
  Handle<mirror::Class> j_l_i_MethodHandleImpl =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodHandleImpl;"));
  Handle<mirror::Class> j_l_i_MethodHandles =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodHandles;"));
  Handle<mirror::Class> j_l_i_MethodHandles_Lookup =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodHandles$Lookup;"));
  Handle<mirror::Class> j_l_i_MethodType =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/invoke/MethodType;"));
  Handle<mirror::Class> j_l_r_fr =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/ref/FinalizerReference;"));
  Handle<mirror::Class> j_l_r_rq =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/ref/ReferenceQueue;"));
  Handle<mirror::Class> j_l_rl_ite = hs.NewHandle(
      FindSystemClass(class_linker, self, "Ljava/lang/reflect/InvocationTargetException;"));
  Handle<mirror::Class> j_l_rl_Parameter =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/reflect/Parameter;"));
  Handle<mirror::Class> j_n_b =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/nio/Buffer;"));
  Handle<mirror::Class> j_n_bb =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/nio/ByteBuffer;"));
  Handle<mirror::Class> j_n_dbb =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/nio/DirectByteBuffer;"));
  Handle<mirror::Class> j_u_c =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/util/Collections;"));
  Handle<mirror::Class> j_u_c_tlr =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/util/concurrent/ThreadLocalRandom;"));
  Handle<mirror::Class> j_u_f_c =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/util/function/Consumer;"));
  Handle<mirror::Class> j_i_v_cont =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljdk/internal/vm/Continuation;"));
  Handle<mirror::Class> j_i_f_amsi = hs.NewHandle(
      FindSystemClass(class_linker, self, "Ljdk/internal/foreign/AbstractMemorySegmentImpl;"));
  Handle<mirror::Class> j_i_f_nmsi = hs.NewHandle(
      FindSystemClass(class_linker, self, "Ljdk/internal/foreign/NativeMemorySegmentImpl;"));
  Handle<mirror::Class> j_i_m_fd =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljdk/internal/math/FloatingDecimal;"));
  Handle<mirror::Class> j_i_m_fd_btab = hs.NewHandle(FindSystemClass(
      class_linker, self, "Ljdk/internal/math/FloatingDecimal$BinaryToASCIIBuffer;"));
  Handle<mirror::Class> j_i_m_fd_ebtab = hs.NewHandle(FindSystemClass(
      class_linker, self, "Ljdk/internal/math/FloatingDecimal$ExceptionalBinaryToASCIIBuffer;"));
  Handle<mirror::Class> l_r_af =
      hs.NewHandle(FindSystemClass(class_linker, self, "Llibcore/reflect/AnnotationFactory;"));
  Handle<mirror::Class> l_r_am =
      hs.NewHandle(FindSystemClass(class_linker, self, "Llibcore/reflect/AnnotationMember;"));
  Handle<mirror::Class> l_u_ea =
      hs.NewHandle(FindSystemClass(class_linker, self, "Llibcore/util/EmptyArray;"));
  Handle<mirror::Class> o_a_h_d_c =
      hs.NewHandle(FindSystemClass(class_linker, self, "Lorg/apache/harmony/dalvik/ddmc/Chunk;"));
  Handle<mirror::Class> o_a_h_d_d_ds =
      hs.NewHandle(FindSystemClass(class_linker, self, "Lorg/apache/harmony/dalvik/ddmc/DdmServer;"));

  ScopedAssertNoThreadSuspension sants(__FUNCTION__);

  dalvik_system_BaseDexClassLoader_getLdLibraryPath = CacheMethod(
      d_s_bdcl.Get(),
      /*is_static=*/ false,
      "getLdLibraryPath",
      "()Ljava/lang/String;",
      pointer_size);
  dalvik_system_DelegateLastClassLoader_init = CacheConstructor(
      d_s_dlcl.Get(), "(Ljava/lang/String;Ljava/lang/ClassLoader;)V", pointer_size);
  dalvik_system_DexClassLoader_init = CacheConstructor(
      d_s_dcl.Get(),
      "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/ClassLoader;)V",
      pointer_size);
  dalvik_system_DexFile_init =
      CacheConstructor(d_s_df.Get(), "(Ljava/lang/String;)V", pointer_size);
  dalvik_system_DexPathList_init = CacheConstructor(
      d_s_dpl.Get(),
      "(Ljava/lang/ClassLoader;Ljava/lang/String;Ljava/lang/String;Ljava/io/File;)V",
      pointer_size);
  dalvik_system_DexPathList__Element_init =
      CacheConstructor(d_s_dpl_e.Get(), "(Ldalvik/system/DexFile;Ljava/io/File;)V", pointer_size);
  dalvik_system_InMemoryDexClassLoader_init = CacheConstructor(
      d_s_imdcl.Get(), "(Ljava/nio/ByteBuffer;Ljava/lang/ClassLoader;)V", pointer_size);
  dalvik_system_PathClassLoader_init = CacheConstructor(
      d_s_pcl.Get(), "(Ljava/lang/String;Ljava/lang/ClassLoader;)V", pointer_size);
  dalvik_system_VirtualThreadParkedStates_init =
      CacheConstructor(d_s_vtps.Get(), "()V", pointer_size);

  dalvik_system_VMRuntime_hiddenApiUsed = CacheMethod(
      d_s_vmr.Get(),
      /*is_static=*/ true,
      "hiddenApiUsed",
      "(ILjava/lang/String;Ljava/lang/String;IZ)V",
      pointer_size);

  java_lang_BootClassLoader_init = CacheConstructor(j_l_bcl.Get(), "()V", pointer_size);
  java_lang_ClassLoader_loadClass = CacheMethod(
      j_l_cl.Get(),
      /*is_static=*/ false,
      "loadClass",
      "(Ljava/lang/String;)Ljava/lang/Class;",
      pointer_size);

  java_lang_ClassNotFoundException_init =
      CacheConstructor(j_l_cnfe.Get(), "(Ljava/lang/String;Ljava/lang/Throwable;)V", pointer_size);

  java_lang_Double_doubleToRawLongBits = CacheMethod(
      java_lang_Double.Get(), /*is_static=*/ true, "doubleToRawLongBits", "(D)J", pointer_size);
  java_lang_Float_floatToRawIntBits = CacheMethod(
      java_lang_Float.Get(), /*is_static=*/ true, "floatToRawIntBits", "(F)I", pointer_size);

  java_lang_Daemons_start = CacheMethod(
      j_l_Daemons.Get(), /*is_static=*/ true, "start", "()V", pointer_size);
  java_lang_Daemons_stop = CacheMethod(
      j_l_Daemons.Get(), /*is_static=*/ true, "stop", "()V", pointer_size);
  java_lang_Daemons_waitForDaemonStart = CacheMethod(
      j_l_Daemons.Get(), /*is_static=*/ true, "waitForDaemonStart", "()V", pointer_size);

  java_lang_Error_init = CacheConstructor(j_l_Error.Get(), "()V", pointer_size);
  java_lang_IllegalAccessError_init =
      CacheConstructor(j_l_IllegalAccessError.Get(), "()V", pointer_size);
  java_lang_NoClassDefFoundError_init =
      CacheConstructor(j_l_NoClassDefFoundError.Get(), "()V", pointer_size);
  java_lang_OutOfMemoryError_init =
      CacheConstructor(j_l_OutOfMemoryError.Get(), "()V", pointer_size);
  java_lang_Runnable_run =
      CacheMethod(j_l_Runnable.Get(), /*is_static=*/false, "run", "()V", pointer_size);
  java_lang_RuntimeException_init =
      CacheConstructor(j_l_RuntimeException.Get(), "()V", pointer_size);
  java_lang_StackOverflowError_init =
      CacheConstructor(j_l_StackOverflowError.Get(), "()V", pointer_size);

  ObjPtr<mirror::Class> j_l_String = GetClassRoot<mirror::String>(class_linker);
  java_lang_String_charAt = CacheMethod(
      j_l_String, /*is_static=*/ false, "charAt", "(I)C", pointer_size);

  java_lang_System_identityHashCode = CacheMethod(
      j_l_System.Get(),
      /*is_static=*/ true,
      "identityHashCode",
      "(Ljava/lang/Object;)I",
      pointer_size);

  java_lang_Thread_dispatchUncaughtException = CacheMethod(
      j_l_Thread.Get(),
      /*is_static=*/ false,
      "dispatchUncaughtException",
      "(Ljava/lang/Throwable;)V",
      pointer_size);
  java_lang_Thread_init = CacheConstructor(
      j_l_Thread.Get(), "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V", pointer_size);
  java_lang_Thread_parkVirtualInternal =
      CacheMethod(j_l_Thread.Get(),
                  /*is_static=*/true,
                  "parkVirtualInternal",
                  "(Ldalvik/system/VirtualThreadContext;Ldalvik/system/"
                  "VirtualThreadParkedStates;Ldalvik/system/VirtualThreadParkingError;)V",
                  pointer_size);
  java_lang_Thread_run = CacheMethod(
      j_l_Thread.Get(), /*is_static=*/ false, "run", "()V", pointer_size);
  java_lang_ThreadGroup_add = CacheMethod(
      j_l_tg.Get(), /*is_static=*/ false, "add", "(Ljava/lang/Thread;)V", pointer_size);
  java_lang_ThreadGroup_threadTerminated = CacheMethod(
      j_l_tg.Get(),
      /*is_static=*/ false,
      "threadTerminated",
      "(Ljava/lang/Thread;)V",
      pointer_size);

  java_lang_invoke_MethodHandle_asType = CacheMethod(
      j_l_i_MethodHandle.Get(),
      /*is_static=*/ false,
      "asType",
      "(Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;",
      pointer_size);
  java_lang_invoke_MethodHandle_invokeExact = CacheMethod(
      j_l_i_MethodHandle.Get(),
      /*is_static=*/ false,
      "invokeExact",
      "([Ljava/lang/Object;)Ljava/lang/Object;",
      pointer_size);
  java_lang_invoke_MethodHandleImpl_fieldInit = CacheConstructor(
    j_l_i_MethodHandleImpl.Get(),
    "(Ljava/lang/reflect/Field;ILjava/lang/invoke/MethodType;)V",
    pointer_size);
  java_lang_invoke_MethodHandleImpl_init = CacheConstructor(
      j_l_i_MethodHandleImpl.Get(), "(JILjava/lang/invoke/MethodType;)V", pointer_size);
  java_lang_invoke_MethodHandles_lookup = CacheMethod(
      j_l_i_MethodHandles.Get(),
      /*is_static=*/ true,
      "lookup",
      "()Ljava/lang/invoke/MethodHandles$Lookup;",
      pointer_size);
  java_lang_invoke_MethodHandles_makeIdentity = CacheMethod(
      j_l_i_MethodHandles.Get(),
      /*is_static=*/ true,
      "makeIdentity",
      "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandle;",
      pointer_size);
  java_lang_invoke_MethodHandles_Lookup_findConstructor = CacheMethod(
      j_l_i_MethodHandles_Lookup.Get(),
      /*is_static=*/ false,
      "findConstructor",
      "(Ljava/lang/Class;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;",
      pointer_size);
  java_lang_invoke_MethodType_makeImpl = CacheMethod(
      j_l_i_MethodType.Get(),
      /* is_static=*/ true,
      "makeImpl",
      "(Ljava/lang/Class;[Ljava/lang/Class;Z)Ljava/lang/invoke/MethodType;",
      pointer_size);

  java_lang_ref_FinalizerReference_add = CacheMethod(
      j_l_r_fr.Get(), /*is_static=*/ true, "add", "(Ljava/lang/Object;)V", pointer_size);
  java_lang_ref_ReferenceQueue_add = CacheMethod(
      j_l_r_rq.Get(), /*is_static=*/ true, "add", "(Ljava/lang/ref/Reference;)V", pointer_size);

  java_lang_reflect_InvocationTargetException_init =
      CacheConstructor(j_l_rl_ite.Get(), "(Ljava/lang/Throwable;)V", pointer_size);
  java_lang_reflect_Parameter_init = CacheConstructor(
      j_l_rl_Parameter.Get(),
      "(Ljava/lang/String;ILjava/lang/reflect/Executable;I)V",
      pointer_size);

  ObjPtr<mirror::Class> j_l_rl_Proxy = GetClassRoot<mirror::Proxy>(class_linker);
  java_lang_reflect_Proxy_init =
      CacheConstructor(j_l_rl_Proxy, "(Ljava/lang/reflect/InvocationHandler;)V", pointer_size);
  java_lang_reflect_Proxy_invoke = CacheMethod(
      j_l_rl_Proxy,
      /*is_static=*/ true,
      "invoke",
      "(Ljava/lang/reflect/Proxy;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;",
      pointer_size);

  java_nio_Buffer_isDirect =
      CacheMethod(j_n_b.Get(), /*is_static=*/ false, "isDirect", "()Z", pointer_size);
  java_nio_DirectByteBuffer_init = CacheConstructor(j_n_dbb.Get(), "(JI)V", pointer_size);

  java_util_Collections_emptyList = CacheMethod(
      j_u_c.Get(), /*is_static=*/ true, "emptyList", "()Ljava/util/List;", pointer_size);

  java_util_concurrent_ThreadLocalRandom_current = CacheMethod(
      j_u_c_tlr.Get(),
      /*is_static=*/ true,
      "current",
      "()Ljava/util/concurrent/ThreadLocalRandom;",
      pointer_size);

  java_util_function_Consumer_accept = CacheMethod(
      j_u_f_c.Get(), /*is_static=*/ false, "accept", "(Ljava/lang/Object;)V", pointer_size);

  jdk_internal_foreign_NativeMemorySegmentImpl_isNative = CacheMethod(
      j_i_f_nmsi.Get(),
      /*is_static=*/ false,
      "isNative",
      "()Z",
      pointer_size);

  jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_D = CacheMethod(
      j_i_m_fd.Get(),
      /*is_static=*/ true,
      "getBinaryToASCIIConverter",
      "(D)Ljdk/internal/math/FloatingDecimal$BinaryToASCIIConverter;",
      pointer_size);
  jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_F = CacheMethod(
      j_i_m_fd.Get(),
      /*is_static=*/ true,
      "getBinaryToASCIIConverter",
      "(F)Ljdk/internal/math/FloatingDecimal$BinaryToASCIIConverter;",
      pointer_size);
  jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_getChars =
      CacheMethod(j_i_m_fd_btab.Get(), /*is_static=*/ false, "getChars", "([C)I", pointer_size);
  jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_toJavaFormatString =
      CacheMethod(j_i_m_fd_ebtab.Get(),
                  /*is_static=*/ false,
                  "toJavaFormatString",
                  "()Ljava/lang/String;",
                  pointer_size);
  jdk_internal_vm_Continuation_doYieldNative =
      CacheMethod(j_i_v_cont.Get(),
                  /*is_static=*/true,
                  "doYieldNative",
                  "(Ldalvik/system/VirtualThreadContext;Ldalvik/system/"
                  "VirtualThreadParkedStates;Ldalvik/system/VirtualThreadParkingError;)I",
                  pointer_size);
  jdk_internal_vm_Continuation_enter = CacheMethod(j_i_v_cont.Get(),
                                                   /*is_static=*/true,
                                                   "enter",
                                                   "(Ljdk/internal/vm/Continuation;Z)V",
                                                   pointer_size);
  jdk_internal_vm_Continuation_enterSpecial = CacheMethod(j_i_v_cont.Get(),
                                                          /*is_static=*/true,
                                                          "enterSpecial",
                                                          "(Ljdk/internal/vm/Continuation;ZZ)V",
                                                          pointer_size);

  libcore_reflect_AnnotationFactory_createAnnotation = CacheMethod(
      l_r_af.Get(),
      /*is_static=*/ true,
      "createAnnotation",
      "(Ljava/lang/Class;[Llibcore/reflect/AnnotationMember;)Ljava/lang/annotation/Annotation;",
      pointer_size);
  libcore_reflect_AnnotationMember_init = CacheConstructor(
      l_r_am.Get(),
      "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/reflect/Method;)V",
      pointer_size);
  libcore_util_EmptyArray_init = CacheConstructor(l_u_ea.Get(), "()V", pointer_size);

  org_apache_harmony_dalvik_ddmc_DdmServer_broadcast =
      CacheMethod(o_a_h_d_d_ds.Get(), /*is_static=*/ true, "broadcast", "(I)V", pointer_size);
  org_apache_harmony_dalvik_ddmc_DdmServer_dispatch = CacheMethod(
      o_a_h_d_d_ds.Get(),
      /*is_static=*/ true,
      "dispatch",
      "(I[BII)Lorg/apache/harmony/dalvik/ddmc/Chunk;",
      pointer_size);

  java_lang_invoke_MethodHandle_type = CacheField(
      j_l_i_MethodHandle.Get(), /*is_static=*/ false, "type", "Ljava/lang/invoke/MethodType;");

  ObjPtr<mirror::Class> j_l_Object = GetClassRoot<mirror::Object>(class_linker);
  java_lang_Object_shadowKlass = CacheField(
      j_l_Object, /*is_static=*/ false, "shadow$_klass_", "Ljava/lang/Class;");

  ObjPtr<mirror::Class> j_l_r_Reference = GetClassRoot<mirror::Reference>(class_linker);
  java_lang_ref_Reference_disableIntrinsic = CacheField(
      j_l_r_Reference, /*is_static=*/ true, "disableIntrinsic", "Z");
  java_lang_ref_Reference_slowPathEnabled = CacheField(
      j_l_r_Reference, /*is_static=*/ true, "slowPathEnabled", "Z");

  dalvik_system_BaseDexClassLoader_pathList = CacheField(
      d_s_bdcl.Get(), /*is_static=*/ false, "pathList", "Ldalvik/system/DexPathList;");
  dalvik_system_BaseDexClassLoader_sharedLibraryLoaders = CacheField(
      d_s_bdcl.Get(), /*is_static=*/ false, "sharedLibraryLoaders", "[Ljava/lang/ClassLoader;");
  dalvik_system_BaseDexClassLoader_sharedLibraryLoadersAfter = CacheField(
      d_s_bdcl.Get(),
      /*is_static=*/ false,
      "sharedLibraryLoadersAfter",
      "[Ljava/lang/ClassLoader;");
  dalvik_system_DexFile_cookie = CacheField(
      d_s_df.Get(), /*is_static=*/ false, "mCookie", "Ljava/lang/Object;");
  dalvik_system_DexFile_fileName = CacheField(
      d_s_df.Get(), /*is_static=*/ false, "mFileName", "Ljava/lang/String;");
  dalvik_system_DexPathList_dexElements = CacheField(
      d_s_dpl.Get(), /*is_static=*/ false, "dexElements", "[Ldalvik/system/DexPathList$Element;");
  dalvik_system_DexPathList__Element_dexFile = CacheField(
      d_s_dpl_e.Get(), /*is_static=*/ false, "dexFile", "Ldalvik/system/DexFile;");

  dalvik_system_VMRuntime_nonSdkApiUsageConsumer = CacheField(d_s_vmr.Get(),
                                                              /*is_static=*/true,
                                                              "nonSdkApiUsageConsumer",
                                                              "Ljava/util/function/Consumer;");
  dalvik_system_VirtualThreadParkedStates_frames =
      CacheField(d_s_vtps.Get(),
                 /*is_static=*/false,
                 "frames",
                 "[Ldalvik/system/VirtualThreadFrame;");

  java_io_FileDescriptor_descriptor = CacheField(
      j_i_fd.Get(), /*is_static=*/ false, "descriptor", "I");

  java_lang_ClassLoader_parent = CacheField(
      j_l_cl.Get(), /*is_static=*/ false, "parent", "Ljava/lang/ClassLoader;");

  java_lang_String_EMPTY =
      CacheField(j_l_String, /*is_static=*/ true, "EMPTY", "Ljava/lang/String;");

  java_lang_System_in =
      CacheField(j_l_System.Get(), /*is_static=*/ true, "in", "Ljava/io/InputStream;");
  java_lang_System_out =
      CacheField(j_l_System.Get(), /*is_static=*/ true, "out", "Ljava/io/PrintStream;");
  java_lang_System_err =
      CacheField(j_l_System.Get(), /*is_static=*/ true, "err", "Ljava/io/PrintStream;");

  java_lang_Thread_cont =
      CacheField(j_l_Thread.Get(), /*is_static=*/false, "cont", "Ljdk/internal/vm/Continuation;");
  java_lang_Thread_parkBlocker =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "parkBlocker", "Ljava/lang/Object;");
  java_lang_Thread_daemon = CacheField(j_l_Thread.Get(), /*is_static=*/ false, "daemon", "Z");
  java_lang_Thread_group =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "group", "Ljava/lang/ThreadGroup;");
  java_lang_Thread_lock =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "lock", "Ljava/lang/Object;");
  java_lang_Thread_name =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "name", "Ljava/lang/String;");
  java_lang_Thread_niceness = CacheField(j_l_Thread.Get(), /*is_static=*/false, "niceness", "I");
  java_lang_Thread_nativePeer =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "nativePeer", "J");
  java_lang_Thread_priority = CacheField(j_l_Thread.Get(), /*is_static=*/false, "priority", "I");
  java_lang_Thread_systemDaemon =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "systemDaemon", "Z");
  java_lang_Thread_unparkedBeforeStart =
      CacheField(j_l_Thread.Get(), /*is_static=*/ false, "unparkedBeforeStart", "Z");
  java_lang_Thread_target =
      CacheField(j_l_Thread.Get(), /*is_static=*/false, "target", "Ljava/lang/Runnable;");

  java_lang_ThreadGroup_groups =
      CacheField(j_l_tg.Get(), /*is_static=*/ false, "groups", "[Ljava/lang/ThreadGroup;");
  java_lang_ThreadGroup_ngroups = CacheField(j_l_tg.Get(), /*is_static=*/ false, "ngroups", "I");
  java_lang_ThreadGroup_mainThreadGroup =
      CacheField(j_l_tg.Get(), /*is_static=*/ true, "mainThreadGroup", "Ljava/lang/ThreadGroup;");
  java_lang_ThreadGroup_name =
      CacheField(j_l_tg.Get(), /*is_static=*/ false, "name", "Ljava/lang/String;");
  java_lang_ThreadGroup_parent =
      CacheField(j_l_tg.Get(), /*is_static=*/ false, "parent", "Ljava/lang/ThreadGroup;");
  java_lang_ThreadGroup_systemThreadGroup =
      CacheField(j_l_tg.Get(), /*is_static=*/ true, "systemThreadGroup", "Ljava/lang/ThreadGroup;");

  ObjPtr<mirror::Class> j_l_Throwable = GetClassRoot<mirror::Throwable>(class_linker);
  java_lang_Throwable_cause = CacheField(
      j_l_Throwable, /*is_static=*/ false, "cause", "Ljava/lang/Throwable;");
  java_lang_Throwable_detailMessage = CacheField(
      j_l_Throwable, /*is_static=*/ false, "detailMessage", "Ljava/lang/String;");
  java_lang_Throwable_stackTrace = CacheField(
      j_l_Throwable, /*is_static=*/ false, "stackTrace", "[Ljava/lang/StackTraceElement;");
  java_lang_Throwable_stackState = CacheField(
      j_l_Throwable, /*is_static=*/ false, "backtrace", "Ljava/lang/Object;");
  java_lang_Throwable_suppressedExceptions = CacheField(
      j_l_Throwable, /*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");
  java_nio_Buffer_elementSizeShift =
      CacheField(j_n_b.Get(), /*is_static=*/ false, "_elementSizeShift", "I");
  java_nio_Buffer_limit = CacheField(j_n_b.Get(), /*is_static=*/ false, "limit", "I");
  java_nio_Buffer_position = CacheField(j_n_b.Get(), /*is_static=*/ false, "position", "I");
  jdk_internal_foreign_NativeMemorySegmentImpl_min =
      CacheField(j_i_f_nmsi.Get(), /*is_static=*/false, "min", "J");
  jdk_internal_foreign_AbstractMemorySegmentImpl_length =
      CacheField(j_i_f_amsi.Get(), /*is_static=*/false, "length", "J");
  jdk_internal_foreign_AbstractMemorySegmentImpl_readOnly =
      CacheField(j_i_f_amsi.Get(), /*is_static=*/false, "readOnly", "Z");
  java_nio_ByteBuffer_hb = CacheField(j_n_bb.Get(), /*is_static=*/ false, "hb", "[B");
  java_nio_ByteBuffer_isReadOnly =
      CacheField(j_n_bb.Get(), /*is_static=*/ false, "isReadOnly", "Z");
  java_nio_ByteBuffer_offset = CacheField(j_n_bb.Get(), /*is_static=*/ false, "offset", "I");

  java_util_Collections_EMPTY_LIST =
      CacheField(j_u_c.Get(), /*is_static=*/ true, "EMPTY_LIST", "Ljava/util/List;");

  java_util_concurrent_ThreadLocalRandom_seeder = CacheField(
      j_u_c_tlr.Get(), /*is_static=*/ true, "seeder", "Ljava/util/concurrent/atomic/AtomicLong;");

  jdk_internal_vm_Continuation_virtualThreadContext =
      CacheField(j_i_v_cont.Get(),
                 /*is_static=*/false,
                 "virtualThreadContext",
                 "Ldalvik/system/VirtualThreadContext;");
  jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_buffer =
      CacheField(j_i_m_fd_btab.Get(), /*is_static=*/ false, "buffer", "[C");
  jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_image = CacheField(
      j_i_m_fd_ebtab.Get(), /*is_static=*/ false, "image", "Ljava/lang/String;");

  libcore_util_EmptyArray_STACK_TRACE_ELEMENT = CacheField(
      l_u_ea.Get(), /*is_static=*/ true, "STACK_TRACE_ELEMENT", "[Ljava/lang/StackTraceElement;");

  org_apache_harmony_dalvik_ddmc_Chunk_data =
      CacheField(o_a_h_d_c.Get(), /*is_static=*/ false, "data", "[B");
  org_apache_harmony_dalvik_ddmc_Chunk_length =
      CacheField(o_a_h_d_c.Get(), /*is_static=*/ false, "length", "I");
  org_apache_harmony_dalvik_ddmc_Chunk_offset =
      CacheField(o_a_h_d_c.Get(), /*is_static=*/ false, "offset", "I");
  org_apache_harmony_dalvik_ddmc_Chunk_type =
      CacheField(o_a_h_d_c.Get(), /*is_static=*/ false, "type", "I");
}

void WellKnownClasses::LateInit(JNIEnv* env) {
  // Initialize the `Runtime` class that was previously initialized
  // by `CacheMethod()` calling `FindMethodJNI()`.
  // TODO: Move this initialization to `ClassLinker`.
  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
  Thread* self = Thread::ForEnv(env);
  ScopedObjectAccess soa(self);
  StackHandleScope<1u> hs(self);
  Handle<mirror::Class> j_l_Runtime =
      hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/lang/Runtime;"));
  bool success = class_linker->EnsureInitialized(
      self, j_l_Runtime, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
  CHECK(success) << "Failed to initialize " << j_l_Runtime->PrettyDescriptor();

  // The function `GetClassLoader()` in `jni_internal.cc` is checking if the caller
  // is `java_lang_Runtime_nativeLoad` and, if so, returns the class loader override.
  // However, this function is used several times between `WellKnownClasses::Init()`
  // and setting up the override by the `Runtime` and requires that we take the other
  // path, rather than returning the uninitialized override. Therefore we cannot
  // initialize this well-known method early and require the `LateInit()`.
  // TODO: Clean up the initialization steps.
  java_lang_Runtime_nativeLoad = CacheMethod(
      j_l_Runtime.Get(),
      /*is_static=*/ true,
      "nativeLoad",
      "(Ljava/lang/String;Ljava/lang/ClassLoader;Ljava/lang/Class;)Ljava/lang/String;",
      class_linker->GetImagePointerSize());
}

void WellKnownClasses::HandleJniIdTypeChange(JNIEnv* env) {
  WellKnownClasses::InitFieldsAndMethodsOnly(env);
  WellKnownClasses::LateInit(env);
}

void WellKnownClasses::Clear() {
  dalvik_annotation_optimization_CriticalNative = nullptr;
  dalvik_annotation_optimization_FastNative = nullptr;
  dalvik_annotation_optimization_NeverCompile = nullptr;
  dalvik_annotation_optimization_NeverInline = nullptr;
  dalvik_system_VirtualThreadFrame__array = nullptr;
  java_lang_annotation_Annotation__array = nullptr;
  java_lang_ClassValue = nullptr;
  java_lang_Record = nullptr;
  java_lang_reflect_Parameter__array = nullptr;
  java_lang_StringFactory = nullptr;
  java_lang_Void = nullptr;
  java_util_concurrent_atomic_AIFU = nullptr;
  java_util_concurrent_atomic_ALFU = nullptr;
  java_util_concurrent_atomic_ARFU = nullptr;
  jdk_internal_misc_Unsafe = nullptr;
  libcore_reflect_AnnotationMember__array = nullptr;
  sun_misc_Unsafe = nullptr;

  dalvik_system_BaseDexClassLoader_getLdLibraryPath = nullptr;
  WellKnownClasses::dalvik_system_DelegateLastClassLoader_init = nullptr;
  WellKnownClasses::dalvik_system_DexClassLoader_init = nullptr;
  WellKnownClasses::dalvik_system_DexFile_init = nullptr;
  WellKnownClasses::dalvik_system_DexPathList_init = nullptr;
  WellKnownClasses::dalvik_system_DexPathList__Element_init = nullptr;
  WellKnownClasses::dalvik_system_InMemoryDexClassLoader_init = nullptr;
  WellKnownClasses::dalvik_system_PathClassLoader_init = nullptr;
  dalvik_system_VMRuntime_hiddenApiUsed = nullptr;
  dalvik_system_VirtualThreadParkedStates_init = nullptr;
  java_io_FileDescriptor_descriptor = nullptr;
  java_lang_Boolean_valueOf = nullptr;
  java_lang_Byte_valueOf = nullptr;
  java_lang_Byte_ByteCache_init = nullptr;
  java_lang_Character_valueOf = nullptr;
  java_lang_Character_CharacterCache_init = nullptr;
  java_lang_BootClassLoader_init = nullptr;
  java_lang_ClassLoader_loadClass = nullptr;
  java_lang_ClassNotFoundException_init = nullptr;
  java_lang_Daemons_start = nullptr;
  java_lang_Daemons_stop = nullptr;
  java_lang_Daemons_waitForDaemonStart = nullptr;
  java_lang_Double_doubleToRawLongBits = nullptr;
  java_lang_Double_valueOf = nullptr;
  java_lang_Error_init = nullptr;
  java_lang_Float_floatToRawIntBits = nullptr;
  java_lang_Float_valueOf = nullptr;
  java_lang_IllegalAccessError_init = nullptr;
  java_lang_Integer_valueOf = nullptr;
  java_lang_Integer_IntegerCache_init = nullptr;
  java_lang_Long_valueOf = nullptr;
  java_lang_Long_LongCache_init = nullptr;
  java_lang_NoClassDefFoundError_init = nullptr;
  java_lang_OutOfMemoryError_init = nullptr;
  java_lang_Runnable_run = nullptr;
  java_lang_Runtime_nativeLoad = nullptr;
  java_lang_RuntimeException_init = nullptr;
  java_lang_Short_valueOf = nullptr;
  java_lang_Short_ShortCache_init = nullptr;
  java_lang_StackOverflowError_init = nullptr;
  java_lang_String_charAt = nullptr;
  java_lang_System_identityHashCode = nullptr;
  java_lang_Thread_dispatchUncaughtException = nullptr;
  java_lang_Thread_init = nullptr;
  java_lang_Thread_parkVirtualInternal = nullptr;
  java_lang_Thread_run = nullptr;
  java_lang_ThreadGroup_add = nullptr;
  java_lang_ThreadGroup_threadTerminated = nullptr;
  java_lang_invoke_MethodHandle_asType = nullptr;
  java_lang_invoke_MethodHandle_invokeExact = nullptr;
  java_lang_invoke_MethodHandleImpl_init = nullptr;
  java_lang_invoke_MethodHandleImpl_fieldInit = nullptr;
  java_lang_invoke_MethodHandles_lookup = nullptr;
  java_lang_invoke_MethodHandles_makeIdentity = nullptr;
  java_lang_invoke_MethodHandles_Lookup_findConstructor = nullptr;
  java_lang_invoke_MethodType_makeImpl = nullptr;
  java_lang_ref_FinalizerReference_add = nullptr;
  java_lang_ref_ReferenceQueue_add = nullptr;
  java_lang_reflect_InvocationTargetException_init = nullptr;
  java_lang_reflect_Parameter_init = nullptr;
  java_lang_reflect_Proxy_init = nullptr;
  java_lang_reflect_Proxy_invoke = nullptr;
  java_nio_Buffer_isDirect = nullptr;
  java_nio_DirectByteBuffer_init = nullptr;
  java_util_Collections_emptyList = nullptr;
  java_util_concurrent_ThreadLocalRandom_current = nullptr;
  jdk_internal_foreign_NativeMemorySegmentImpl_isNative = nullptr;
  jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_D = nullptr;
  jdk_internal_math_FloatingDecimal_getBinaryToASCIIConverter_F = nullptr;
  jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_getChars = nullptr;
  jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_toJavaFormatString = nullptr;
  jdk_internal_vm_Continuation_doYieldNative = nullptr;
  jdk_internal_vm_Continuation_enter = nullptr;
  jdk_internal_vm_Continuation_enterSpecial = nullptr;
  libcore_reflect_AnnotationFactory_createAnnotation = nullptr;
  libcore_reflect_AnnotationMember_init = nullptr;
  libcore_util_EmptyArray_init = nullptr;
  org_apache_harmony_dalvik_ddmc_DdmServer_broadcast = nullptr;
  org_apache_harmony_dalvik_ddmc_DdmServer_dispatch = nullptr;

  dalvik_system_BaseDexClassLoader_pathList = nullptr;
  dalvik_system_DexFile_cookie = nullptr;
  dalvik_system_DexFile_fileName = nullptr;
  dalvik_system_DexPathList_dexElements = nullptr;
  dalvik_system_DexPathList__Element_dexFile = nullptr;
  dalvik_system_VMRuntime_nonSdkApiUsageConsumer = nullptr;
  java_lang_invoke_MethodHandle_type = nullptr;
  java_lang_ref_Reference_disableIntrinsic = nullptr;
  java_lang_ref_Reference_slowPathEnabled = nullptr;
  java_lang_ClassLoader_parent = nullptr;
  java_lang_Object_shadowKlass = nullptr;
  java_lang_String_EMPTY = nullptr;
  java_lang_System_in = nullptr;
  java_lang_System_out = nullptr;
  java_lang_System_err = nullptr;
  java_lang_Thread_cont = nullptr;
  java_lang_Thread_parkBlocker = nullptr;
  java_lang_Thread_daemon = nullptr;
  java_lang_Thread_group = nullptr;
  java_lang_Thread_lock = nullptr;
  java_lang_Thread_name = nullptr;
  java_lang_Thread_niceness = nullptr;
  java_lang_Thread_nativePeer = nullptr;
  java_lang_Thread_priority = nullptr;
  java_lang_ThreadGroup_groups = nullptr;
  java_lang_ThreadGroup_ngroups = nullptr;
  java_lang_ThreadGroup_mainThreadGroup = nullptr;
  java_lang_ThreadGroup_name = nullptr;
  java_lang_ThreadGroup_parent = nullptr;
  java_lang_ThreadGroup_systemThreadGroup = nullptr;
  java_lang_Throwable_cause = nullptr;
  java_lang_Throwable_detailMessage = nullptr;
  java_lang_Throwable_stackTrace = nullptr;
  java_lang_Throwable_stackState = nullptr;
  java_lang_Throwable_suppressedExceptions = nullptr;
  java_nio_Buffer_address = nullptr;
  java_nio_Buffer_elementSizeShift = nullptr;
  java_nio_Buffer_limit = nullptr;
  java_nio_Buffer_position = nullptr;
  java_nio_ByteBuffer_hb = nullptr;
  java_nio_ByteBuffer_isReadOnly = nullptr;
  java_nio_ByteBuffer_offset = nullptr;
  jdk_internal_foreign_NativeMemorySegmentImpl_min = nullptr;
  jdk_internal_foreign_AbstractMemorySegmentImpl_length = nullptr;
  jdk_internal_foreign_AbstractMemorySegmentImpl_readOnly = nullptr;
  java_util_Collections_EMPTY_LIST = nullptr;
  java_util_concurrent_ThreadLocalRandom_seeder = nullptr;
  jdk_internal_vm_Continuation_virtualThreadContext = nullptr;
  jdk_internal_math_FloatingDecimal_BinaryToASCIIBuffer_buffer = nullptr;
  jdk_internal_math_FloatingDecimal_ExceptionalBinaryToASCIIBuffer_image = nullptr;
  libcore_util_EmptyArray_STACK_TRACE_ELEMENT = nullptr;
  org_apache_harmony_dalvik_ddmc_Chunk_data = nullptr;
  org_apache_harmony_dalvik_ddmc_Chunk_length = nullptr;
  org_apache_harmony_dalvik_ddmc_Chunk_offset = nullptr;
  org_apache_harmony_dalvik_ddmc_Chunk_type = nullptr;

  java_lang_Byte_ByteCache_cache = nullptr;
  java_lang_Character_CharacterCache_cache = nullptr;
  java_lang_Short_ShortCache_cache = nullptr;
  java_lang_Integer_IntegerCache_cache = nullptr;
  java_lang_Long_LongCache_cache = nullptr;

  java_lang_Byte_value = nullptr;
  java_lang_Character_value = nullptr;
  java_lang_Short_value = nullptr;
  java_lang_Integer_value = nullptr;
  java_lang_Long_value = nullptr;
}

ObjPtr<mirror::Class> WellKnownClasses::ToClass(jclass global_jclass) {
  JavaVMExt* vm = Runtime::Current()->GetJavaVM();
  auto ret = ObjPtr<mirror::Class>::DownCast(vm->DecodeGlobal(global_jclass));
  DCHECK(!ret.IsNull());
  return ret;
}

}  // namespace art