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
diff --git a/compiler/optimizing/critical_native_abi_fixup_arm.cc b/compiler/optimizing/critical_native_abi_fixup_arm.cc
index 3c4db4b..1bf3542 100644
--- a/compiler/optimizing/critical_native_abi_fixup_arm.cc
+++ b/compiler/optimizing/critical_native_abi_fixup_arm.cc
@@ -45,9 +45,8 @@
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 57a5acf..d0e22a5 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 @@
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 @@
// 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 f9c1596..ecea692 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1086,22 +1086,59 @@
VLOG(startup) << "ClassLinker::FinishInit exiting";
}
-void ClassLinker::RunRootClinits(Thread* self) {
- 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());
+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) {
+ 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());
+ }
+}
+
ALWAYS_INLINE
static uint32_t ComputeMethodHash(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) {
DCHECK(!method->IsRuntimeMethod());
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 9098c71..5d9c486 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -461,6 +461,12 @@
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 cd39686..3589769 100644
--- a/runtime/common_runtime_test.cc
+++ b/runtime/common_runtime_test.cc
@@ -158,12 +158,13 @@
{
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 6fcf883..6dad810 100644
--- a/runtime/method_handles.cc
+++ b/runtime/method_handles.cc
@@ -81,7 +81,7 @@
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 @@
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 afa49d0..66cda45 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -840,7 +840,7 @@
return nullptr;
}
- jmethodID m = nullptr;
+ ArtMethod* m = nullptr;
const char* shorty;
switch (src_class) {
case Primitive::kPrimBoolean:
@@ -891,11 +891,8 @@
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 04a21be..8752125 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -957,26 +957,11 @@
// 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());
+ class_linker_->RunEarlyRootClinits(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_->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 dbaa02b..26f1802 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 @@
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_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 @@
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 @@
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 @@
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 @@
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 b12b9c8..2373e56 100644
--- a/runtime/well_known_classes.h
+++ b/runtime/well_known_classes.h
@@ -106,24 +106,24 @@
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 @@
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;