Change well known boxing methods to `ArtMethod*`.

And make `ClassLinker::RunRootClinits()` responsible for
the initialization of primitive boxing classes.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Test: testrunner.py --host --interpreter --no-image
Bug: 253570082
Change-Id: Ia000113d53eb60518a137547684df28a0c788997

10 files changed, 142 insertions, 83 deletions

diff --git a/compiler/optimizing/critical_native_abi_fixup_arm.cc b/compiler/optimizing/critical_native_abi_fixup_arm.cc
index 3c4db4bca7..1bf35427be 100644
--- a/compiler/optimizing/critical_native_abi_fixup_arm.cc
+++ b/compiler/optimizing/critical_native_abi_fixup_arm.cc
@@ -45,9 +45,8 @@ static void FixUpArguments(HInvokeStaticOrDirect* invoke) {
     if (DataType::IsFloatingPointType(input_type)) {
       bool is_double = (input_type == DataType::Type::kFloat64);
       DataType::Type converted_type = is_double ? DataType::Type::kInt64 : DataType::Type::kInt32;
-      jmethodID known_method = is_double ? WellKnownClasses::java_lang_Double_doubleToRawLongBits
-                                         : WellKnownClasses::java_lang_Float_floatToRawIntBits;
-      ArtMethod* resolved_method = jni::DecodeArtMethod(known_method);
+      ArtMethod* resolved_method = is_double ? WellKnownClasses::java_lang_Double_doubleToRawLongBits
+                                             : WellKnownClasses::java_lang_Float_floatToRawIntBits;
       DCHECK(resolved_method != nullptr);
       DCHECK(resolved_method->IsIntrinsic());
       MethodReference target_method(nullptr, 0);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 57a5acf671..d0e22a535c 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -65,6 +65,7 @@
 #include "base/zip_archive.h"
 #include "class_linker.h"
 #include "class_loader_context.h"
+#include "class_root-inl.h"
 #include "cmdline_parser.h"
 #include "compiler.h"
 #include "compiler_callbacks.h"
@@ -2737,6 +2738,8 @@ class Dex2Oat final {
     interpreter::UnstartedRuntime::Initialize();
 
     Thread* self = Thread::Current();
+    runtime_->GetClassLinker()->RunEarlyRootClinits(self);
+    WellKnownClasses::Init(self->GetJniEnv());
     runtime_->RunRootClinits(self);
 
     // Runtime::Create acquired the mutator_lock_ that is normally given away when we
@@ -2745,7 +2748,6 @@ class Dex2Oat final {
 
     // Now that we are in native state, initialize well known classes and
     // intrinsics if we don't have a boot image.
-    WellKnownClasses::Init(self->GetJniEnv());
     if (IsBootImage() || runtime_->GetHeap()->GetBootImageSpaces().empty()) {
       InitializeIntrinsics();
     }
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index f9c1596ae2..ecea6921df 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1086,19 +1086,56 @@ void ClassLinker::FinishInit(Thread* self) {
   VLOG(startup) << "ClassLinker::FinishInit exiting";
 }
 
+static void EnsureRootInitialized(ClassLinker* class_linker,
+                                  Thread* self,
+                                  ObjPtr<mirror::Class> klass)
+    REQUIRES_SHARED(Locks::mutator_lock_) {
+  if (!klass->IsVisiblyInitialized()) {
+    DCHECK(!klass->IsArrayClass());
+    DCHECK(!klass->IsPrimitive());
+    StackHandleScope<1> hs(self);
+    Handle<mirror::Class> h_class(hs.NewHandle(klass));
+    if (!class_linker->EnsureInitialized(
+             self, h_class, /*can_init_fields=*/ true, /*can_init_parents=*/ true)) {
+      LOG(FATAL) << "Exception when initializing " << h_class->PrettyClass()
+          << ": " << self->GetException()->Dump();
+    }
+  }
+}
+
+void ClassLinker::RunEarlyRootClinits(Thread* self) {
+  StackHandleScope<1u> hs(self);
+  Handle<mirror::ObjectArray<mirror::Class>> class_roots = hs.NewHandle(GetClassRoots());
+  EnsureRootInitialized(this, self, GetClassRoot<mirror::Class>(class_roots.Get()));
+  EnsureRootInitialized(this, self, GetClassRoot<mirror::String>(class_roots.Get()));
+  // Field class is needed for register_java_net_InetAddress in libcore, b/28153851.
+  EnsureRootInitialized(this, self, GetClassRoot<mirror::Field>(class_roots.Get()));
+}
+
 void ClassLinker::RunRootClinits(Thread* self) {
+  StackHandleScope<1u> hs(self);
+  Handle<mirror::ObjectArray<mirror::Class>> class_roots = hs.NewHandle(GetClassRoots());
   for (size_t i = 0; i < static_cast<size_t>(ClassRoot::kMax); ++i) {
-    ObjPtr<mirror::Class> c = GetClassRoot(ClassRoot(i), this);
-    if (!c->IsArrayClass() && !c->IsPrimitive()) {
-      StackHandleScope<1> hs(self);
-      Handle<mirror::Class> h_class(hs.NewHandle(c));
-      if (!EnsureInitialized(self, h_class, true, true)) {
-        LOG(FATAL) << "Exception when initializing " << h_class->PrettyClass()
-            << ": " << self->GetException()->Dump();
-      }
-    } else {
-      DCHECK(c->IsInitialized());
-    }
+    EnsureRootInitialized(this, self, GetClassRoot(ClassRoot(i), class_roots.Get()));
+  }
+
+  // Make sure certain well-known classes are initialized. Note that well-known
+  // classes are always in the boot image, so this code is primarily intended
+  // for running without boot image but may be needed for boot image if the
+  // AOT-initialization fails due to introduction of new code to `<clinit>`.
+  ArtMethod* static_methods_of_classes_to_initialize[] = {
+      // Initialize primitive boxing classes (avoid check at runtime).
+      WellKnownClasses::java_lang_Boolean_valueOf,
+      WellKnownClasses::java_lang_Byte_valueOf,
+      WellKnownClasses::java_lang_Character_valueOf,
+      WellKnownClasses::java_lang_Double_valueOf,
+      WellKnownClasses::java_lang_Float_valueOf,
+      WellKnownClasses::java_lang_Integer_valueOf,
+      WellKnownClasses::java_lang_Long_valueOf,
+      WellKnownClasses::java_lang_Short_valueOf,
+  };
+  for (ArtMethod* method : static_methods_of_classes_to_initialize) {
+    EnsureRootInitialized(this, self, method->GetDeclaringClass());
   }
 }
 
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 9098c71ebf..5d9c486fa3 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -461,6 +461,12 @@ class ClassLinker {
       REQUIRES_SHARED(Locks::mutator_lock_)
       REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
 
+  // Initializes a few essential classes, namely `java.lang.Class`,
+  // `java.lang.Object` and `java.lang.reflect.Field`.
+  void RunEarlyRootClinits(Thread* self)
+      REQUIRES_SHARED(Locks::mutator_lock_)
+      REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
+
   // Initializes classes that have instances in the image but that have
   // <clinit> methods so they could not be initialized by the compiler.
   void RunRootClinits(Thread* self)
diff --git a/runtime/common_runtime_test.cc b/runtime/common_runtime_test.cc
index cd3968610b..3589769624 100644
--- a/runtime/common_runtime_test.cc
+++ b/runtime/common_runtime_test.cc
@@ -158,12 +158,13 @@ void CommonRuntimeTestImpl::FinalizeSetup() {
 
   {
     ScopedObjectAccess soa(Thread::Current());
+    runtime_->GetClassLinker()->RunEarlyRootClinits(soa.Self());
+    WellKnownClasses::Init(Thread::Current()->GetJniEnv());
     runtime_->RunRootClinits(soa.Self());
   }
 
   // We're back in native, take the opportunity to initialize well known classes and ensure
   // intrinsics are initialized.
-  WellKnownClasses::Init(Thread::Current()->GetJniEnv());
   InitializeIntrinsics();
 
   runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
diff --git a/runtime/method_handles.cc b/runtime/method_handles.cc
index 6fcf8837cc..6dad810b18 100644
--- a/runtime/method_handles.cc
+++ b/runtime/method_handles.cc
@@ -81,7 +81,7 @@ bool GetUnboxedPrimitiveType(ObjPtr<mirror::Class> klass, Primitive::Type* type)
 ObjPtr<mirror::Class> GetBoxedPrimitiveClass(Primitive::Type type)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   ScopedAssertNoThreadSuspension ants(__FUNCTION__);
-  jmethodID m = nullptr;
+  ArtMethod* m = nullptr;
   switch (type) {
 #define CASE_PRIMITIVE(primitive, _, java_name, __)              \
     case primitive:                                              \
@@ -93,7 +93,7 @@ ObjPtr<mirror::Class> GetBoxedPrimitiveClass(Primitive::Type type)
     case Primitive::Type::kPrimVoid:
       return nullptr;
   }
-  return jni::DecodeArtMethod(m)->GetDeclaringClass();
+  return m->GetDeclaringClass();
 }
 
 bool GetUnboxedTypeAndValue(ObjPtr<mirror::Object> o, Primitive::Type* type, JValue* value)
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index afa49d0ab5..66cda453de 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -840,7 +840,7 @@ ObjPtr<mirror::Object> BoxPrimitive(Primitive::Type src_class, const JValue& val
     return nullptr;
   }
 
-  jmethodID m = nullptr;
+  ArtMethod* m = nullptr;
   const char* shorty;
   switch (src_class) {
   case Primitive::kPrimBoolean:
@@ -891,11 +891,8 @@ ObjPtr<mirror::Object> BoxPrimitive(Primitive::Type src_class, const JValue& val
     arg_array.Append(value.GetI());
   }
 
-  jni::DecodeArtMethod(m)->Invoke(soa.Self(),
-                                  arg_array.GetArray(),
-                                  arg_array.GetNumBytes(),
-                                  &result,
-                                  shorty);
+  DCHECK(m->GetDeclaringClass()->IsInitialized());  // By `ClassLinker::RunRootClinits()`.
+  m->Invoke(soa.Self(), arg_array.GetArray(), arg_array.GetNumBytes(), &result, shorty);
   return result.GetL();
 }
 
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 04a21be64c..8752125e54 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -957,26 +957,11 @@ bool Runtime::Start() {
   // Restore main thread state to kNative as expected by native code.
   Thread* self = Thread::Current();
 
-  self->TransitionFromRunnableToSuspended(ThreadState::kNative);
-
   started_ = true;
 
-  if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {
-    ScopedObjectAccess soa(self);
-    StackHandleScope<3> hs(soa.Self());
-
-    ObjPtr<mirror::ObjectArray<mirror::Class>> class_roots = GetClassLinker()->GetClassRoots();
-    auto class_class(hs.NewHandle<mirror::Class>(GetClassRoot<mirror::Class>(class_roots)));
-    auto string_class(hs.NewHandle<mirror::Class>(GetClassRoot<mirror::String>(class_roots)));
-    auto field_class(hs.NewHandle<mirror::Class>(GetClassRoot<mirror::Field>(class_roots)));
+  class_linker_->RunEarlyRootClinits(self);
 
-    class_linker_->EnsureInitialized(soa.Self(), class_class, true, true);
-    class_linker_->EnsureInitialized(soa.Self(), string_class, true, true);
-    self->AssertNoPendingException();
-    // Field class is needed for register_java_net_InetAddress in libcore, b/28153851.
-    class_linker_->EnsureInitialized(soa.Self(), field_class, true, true);
-    self->AssertNoPendingException();
-  }
+  self->TransitionFromRunnableToSuspended(ThreadState::kNative);
 
   // InitNativeMethods needs to be after started_ so that the classes
   // it touches will have methods linked to the oat file if necessary.
diff --git a/runtime/well_known_classes.cc b/runtime/well_known_classes.cc
index dbaa02baaf..26f1802daa 100644
--- a/runtime/well_known_classes.cc
+++ b/runtime/well_known_classes.cc
@@ -23,6 +23,7 @@
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 
+#include "art_method-inl.h"
 #include "base/enums.h"
 #include "class_linker.h"
 #include "entrypoints/quick/quick_entrypoints_enum.h"
@@ -93,24 +94,24 @@ jclass WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer;
 jmethodID WellKnownClasses::dalvik_system_BaseDexClassLoader_getLdLibraryPath;
 jmethodID WellKnownClasses::dalvik_system_VMRuntime_runFinalization;
 jmethodID WellKnownClasses::dalvik_system_VMRuntime_hiddenApiUsed;
-jmethodID WellKnownClasses::java_lang_Boolean_valueOf;
-jmethodID WellKnownClasses::java_lang_Byte_valueOf;
-jmethodID WellKnownClasses::java_lang_Character_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Boolean_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Byte_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Character_valueOf;
 jmethodID WellKnownClasses::java_lang_ClassLoader_loadClass;
 jmethodID WellKnownClasses::java_lang_ClassNotFoundException_init;
 jmethodID WellKnownClasses::java_lang_Daemons_start;
 jmethodID WellKnownClasses::java_lang_Daemons_stop;
 jmethodID WellKnownClasses::java_lang_Daemons_waitForDaemonStart;
-jmethodID WellKnownClasses::java_lang_Double_doubleToRawLongBits;
-jmethodID WellKnownClasses::java_lang_Double_valueOf;
-jmethodID WellKnownClasses::java_lang_Float_floatToRawIntBits;
-jmethodID WellKnownClasses::java_lang_Float_valueOf;
-jmethodID WellKnownClasses::java_lang_Integer_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Double_doubleToRawLongBits;
+ArtMethod* WellKnownClasses::java_lang_Double_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Float_floatToRawIntBits;
+ArtMethod* WellKnownClasses::java_lang_Float_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Integer_valueOf;
 jmethodID WellKnownClasses::java_lang_invoke_MethodHandle_asType;
 jmethodID WellKnownClasses::java_lang_invoke_MethodHandle_invokeExact;
 jmethodID WellKnownClasses::java_lang_invoke_MethodHandles_lookup;
 jmethodID WellKnownClasses::java_lang_invoke_MethodHandles_Lookup_findConstructor;
-jmethodID WellKnownClasses::java_lang_Long_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Long_valueOf;
 jmethodID WellKnownClasses::java_lang_ref_FinalizerReference_add;
 jmethodID WellKnownClasses::java_lang_ref_ReferenceQueue_add;
 jmethodID WellKnownClasses::java_lang_reflect_InvocationTargetException_init;
@@ -118,7 +119,7 @@ jmethodID WellKnownClasses::java_lang_reflect_Parameter_init;
 jmethodID WellKnownClasses::java_lang_reflect_Proxy_init;
 jmethodID WellKnownClasses::java_lang_reflect_Proxy_invoke;
 jmethodID WellKnownClasses::java_lang_Runtime_nativeLoad;
-jmethodID WellKnownClasses::java_lang_Short_valueOf;
+ArtMethod* WellKnownClasses::java_lang_Short_valueOf;
 jmethodID WellKnownClasses::java_lang_String_charAt;
 jmethodID WellKnownClasses::java_lang_Thread_dispatchUncaughtException;
 jmethodID WellKnownClasses::java_lang_Thread_init;
@@ -244,10 +245,32 @@ static jmethodID CacheMethod(JNIEnv* env, const char* klass, bool is_static,
   return CacheMethod(env, java_class.get(), is_static, name, signature);
 }
 
-static jmethodID CachePrimitiveBoxingMethod(JNIEnv* env, char prim_name, const char* boxed_name) {
-  ScopedLocalRef<jclass> boxed_class(env, env->FindClass(boxed_name));
-  return CacheMethod(env, boxed_class.get(), true, "valueOf",
-                     android::base::StringPrintf("(%c)L%s;", prim_name, boxed_name).c_str());
+static ArtMethod* CacheMethod(ObjPtr<mirror::Class> klass,
+                              bool is_static,
+                              const char* name,
+                              const char* signature,
+                              PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_) {
+  // There are no well known interface methods.
+  DCHECK(!klass->IsInterface());
+  ArtMethod* method = 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();
+  }
+  return method;
+}
+
+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);
 }
 
 #define STRING_INIT_LIST(V) \
@@ -402,6 +425,24 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
 
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+
+  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;");
 
   dalvik_system_BaseDexClassLoader_getLdLibraryPath = CacheMethod(env, dalvik_system_BaseDexClassLoader, false, "getLdLibraryPath", "()Ljava/lang/String;");
   dalvik_system_VMRuntime_runFinalization = CacheMethod(env, dalvik_system_VMRuntime, true, "runFinalization", "(J)V");
@@ -437,14 +478,19 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
   org_apache_harmony_dalvik_ddmc_DdmServer_broadcast = CacheMethod(env, org_apache_harmony_dalvik_ddmc_DdmServer, true, "broadcast", "(I)V");
   org_apache_harmony_dalvik_ddmc_DdmServer_dispatch = CacheMethod(env, org_apache_harmony_dalvik_ddmc_DdmServer, true, "dispatch", "(I[BII)Lorg/apache/harmony/dalvik/ddmc/Chunk;");
 
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   StackHandleScope<1u> hs(self);
   Handle<mirror::Class> j_i_fd =
       hs.NewHandle(FindSystemClass(class_linker, self, "Ljava/io/FileDescriptor;"));
 
-  // TODO: There should be no thread suspension when searching for fields and methods. Enable this
-  // assertion when all well known fields and methods are converted to `ArtField*` and `ArtMethod*`.
-  // ScopedAssertNoThreadSuspension sants(__FUNCTION__);
+  ScopedAssertNoThreadSuspension sants(__FUNCTION__);
+  PointerSize pointer_size = class_linker->GetImagePointerSize();
+
+  ObjPtr<mirror::Class> j_l_Double = java_lang_Double_valueOf->GetDeclaringClass();
+  java_lang_Double_doubleToRawLongBits =
+      CacheMethod(j_l_Double, /*is_static=*/ true, "doubleToRawLongBits", "(D)J", pointer_size);
+  ObjPtr<mirror::Class> j_l_Float = java_lang_Float_valueOf->GetDeclaringClass();
+  java_lang_Float_floatToRawIntBits =
+      CacheMethod(j_l_Float, /*is_static=*/ true, "floatToRawIntBits", "(F)I", pointer_size);
 
   ObjPtr<mirror::Class> d_s_bdcl = soa.Decode<mirror::Class>(dalvik_system_BaseDexClassLoader);
   dalvik_system_BaseDexClassLoader_pathList = CacheField(
@@ -548,20 +594,6 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
       CacheField(o_a_h_d_c, /*is_static=*/ false, "offset", "I");
   org_apache_harmony_dalvik_ddmc_Chunk_type =
       CacheField(o_a_h_d_c, /*is_static=*/ false, "type", "I");
-
-  java_lang_Boolean_valueOf = CachePrimitiveBoxingMethod(env, 'Z', "java/lang/Boolean");
-  java_lang_Byte_valueOf = CachePrimitiveBoxingMethod(env, 'B', "java/lang/Byte");
-  java_lang_Character_valueOf = CachePrimitiveBoxingMethod(env, 'C', "java/lang/Character");
-  java_lang_Double_valueOf = CachePrimitiveBoxingMethod(env, 'D', "java/lang/Double");
-  java_lang_Float_valueOf = CachePrimitiveBoxingMethod(env, 'F', "java/lang/Float");
-  java_lang_Integer_valueOf = CachePrimitiveBoxingMethod(env, 'I', "java/lang/Integer");
-  java_lang_Long_valueOf = CachePrimitiveBoxingMethod(env, 'J', "java/lang/Long");
-  java_lang_Short_valueOf = CachePrimitiveBoxingMethod(env, 'S', "java/lang/Short");
-
-  java_lang_Double_doubleToRawLongBits =
-      CacheMethod(env, "java/lang/Double", /*is_static=*/ true, "doubleToRawLongBits", "(D)J");
-  java_lang_Float_floatToRawIntBits =
-      CacheMethod(env, "java/lang/Float", /*is_static=*/ true, "floatToRawIntBits", "(F)I");
 }
 
 void WellKnownClasses::LateInit(JNIEnv* env) {
diff --git a/runtime/well_known_classes.h b/runtime/well_known_classes.h
index b12b9c8bf9..2373e560d9 100644
--- a/runtime/well_known_classes.h
+++ b/runtime/well_known_classes.h
@@ -106,24 +106,24 @@ struct WellKnownClasses {
   static jmethodID dalvik_system_BaseDexClassLoader_getLdLibraryPath;
   static jmethodID dalvik_system_VMRuntime_runFinalization;
   static jmethodID dalvik_system_VMRuntime_hiddenApiUsed;
-  static jmethodID java_lang_Boolean_valueOf;
-  static jmethodID java_lang_Byte_valueOf;
-  static jmethodID java_lang_Character_valueOf;
+  static ArtMethod* java_lang_Boolean_valueOf;
+  static ArtMethod* java_lang_Byte_valueOf;
+  static ArtMethod* java_lang_Character_valueOf;
   static jmethodID java_lang_ClassLoader_loadClass;
   static jmethodID java_lang_ClassNotFoundException_init;
   static jmethodID java_lang_Daemons_start;
   static jmethodID java_lang_Daemons_stop;
   static jmethodID java_lang_Daemons_waitForDaemonStart;
-  static jmethodID java_lang_Double_doubleToRawLongBits;
-  static jmethodID java_lang_Double_valueOf;
-  static jmethodID java_lang_Float_floatToRawIntBits;
-  static jmethodID java_lang_Float_valueOf;
-  static jmethodID java_lang_Integer_valueOf;
+  static ArtMethod* java_lang_Double_doubleToRawLongBits;
+  static ArtMethod* java_lang_Double_valueOf;
+  static ArtMethod* java_lang_Float_floatToRawIntBits;
+  static ArtMethod* java_lang_Float_valueOf;
+  static ArtMethod* java_lang_Integer_valueOf;
   static jmethodID java_lang_invoke_MethodHandle_asType;
   static jmethodID java_lang_invoke_MethodHandle_invokeExact;
   static jmethodID java_lang_invoke_MethodHandles_lookup;
   static jmethodID java_lang_invoke_MethodHandles_Lookup_findConstructor;
-  static jmethodID java_lang_Long_valueOf;
+  static ArtMethod* java_lang_Long_valueOf;
   static jmethodID java_lang_ref_FinalizerReference_add;
   static jmethodID java_lang_ref_ReferenceQueue_add;
   static jmethodID java_lang_reflect_InvocationTargetException_init;
@@ -131,7 +131,7 @@ struct WellKnownClasses {
   static jmethodID java_lang_reflect_Proxy_init;
   static jmethodID java_lang_reflect_Proxy_invoke;
   static jmethodID java_lang_Runtime_nativeLoad;
-  static jmethodID java_lang_Short_valueOf;
+  static ArtMethod* java_lang_Short_valueOf;
   static jmethodID java_lang_String_charAt;
   static jmethodID java_lang_Thread_dispatchUncaughtException;
   static jmethodID java_lang_Thread_init;