Add new WellKnownClasses fields to avoid harcoded constants.

Test: test.py
Change-Id: I3a065dd5582269792032df0c6446c3c4b6cd72be

9 files changed, 37 insertions, 58 deletions

diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 201841a5b4..be8bc69de0 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -801,11 +801,9 @@ HInliner::InlineCacheType HInliner::GetInlineCacheAOT(
   return GetInlineCacheType(*classes);
 }
 
-HInstanceFieldGet* HInliner::BuildGetReceiverClass(ClassLinker* class_linker,
-                                                   HInstruction* receiver,
+HInstanceFieldGet* HInliner::BuildGetReceiverClass(HInstruction* receiver,
                                                    uint32_t dex_pc) const {
-  ArtField* field = GetClassRoot<mirror::Object>(class_linker)->GetField(0);
-  DCHECK_EQ(std::string(field->GetName()), "shadow$_klass_");
+  ArtField* field = WellKnownClasses::java_lang_Object_shadowKlass;
   HInstanceFieldGet* result = new (graph_->GetAllocator()) HInstanceFieldGet(
       receiver,
       field,
@@ -955,7 +953,7 @@ HInstruction* HInliner::AddTypeGuard(HInstruction* receiver,
                                      bool with_deoptimization) {
   ClassLinker* class_linker = caller_compilation_unit_.GetClassLinker();
   HInstanceFieldGet* receiver_class = BuildGetReceiverClass(
-      class_linker, receiver, invoke_instruction->GetDexPc());
+      receiver, invoke_instruction->GetDexPc());
   if (cursor != nullptr) {
     bb_cursor->InsertInstructionAfter(receiver_class, cursor);
   } else {
@@ -1270,7 +1268,7 @@ bool HInliner::TryInlinePolymorphicCallToSameTarget(
 
   // We successfully inlined, now add a guard.
   HInstanceFieldGet* receiver_class = BuildGetReceiverClass(
-      class_linker, receiver, invoke_instruction->GetDexPc());
+      receiver, invoke_instruction->GetDexPc());
 
   DataType::Type type = Is64BitInstructionSet(graph_->GetInstructionSet())
       ? DataType::Type::kInt64
@@ -2452,7 +2450,8 @@ bool HInliner::ReturnTypeMoreSpecific(HInstruction* return_replacement,
         return true;
       } else if (return_replacement->IsInstanceFieldGet()) {
         HInstanceFieldGet* field_get = return_replacement->AsInstanceFieldGet();
-        if (field_get->GetFieldInfo().GetField() == GetClassRoot<mirror::Object>()->GetField(0)) {
+        ArtField* cls_field = WellKnownClasses::java_lang_Object_shadowKlass;
+        if (field_get->GetFieldInfo().GetField() == cls_field) {
           return true;
         }
       }
diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h
index 57d3364051..4afb78a0e2 100644
--- a/compiler/optimizing/inliner.h
+++ b/compiler/optimizing/inliner.h
@@ -246,8 +246,7 @@ class HInliner : public HOptimization {
                    HInstruction* cursor,
                    HBasicBlock* bb_cursor);
 
-  HInstanceFieldGet* BuildGetReceiverClass(ClassLinker* class_linker,
-                                           HInstruction* receiver,
+  HInstanceFieldGet* BuildGetReceiverClass(HInstruction* receiver,
                                            uint32_t dex_pc) const
     REQUIRES_SHARED(Locks::mutator_lock_);
 
diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 101808a193..26efefa2d8 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -1800,8 +1800,7 @@ static bool RecognizeAndSimplifyClassCheck(HCondition* condition) {
 
   {
     ScopedObjectAccess soa(Thread::Current());
-    ArtField* field = GetClassRoot<mirror::Object>()->GetField(0);
-    DCHECK_EQ(std::string(field->GetName()), "shadow$_klass_");
+    ArtField* field = WellKnownClasses::java_lang_Object_shadowKlass;
     if (field_get->GetFieldInfo().GetField() != field) {
       return false;
     }
diff --git a/compiler/optimizing/intrinsics.cc b/compiler/optimizing/intrinsics.cc
index 6b91cf515e..713806e217 100644
--- a/compiler/optimizing/intrinsics.cc
+++ b/compiler/optimizing/intrinsics.cc
@@ -173,17 +173,13 @@ IntrinsicVisitor::ValueOfInfo IntrinsicVisitor::ComputeValueOfInfo(
 
 MemberOffset IntrinsicVisitor::GetReferenceDisableIntrinsicOffset() {
   ScopedObjectAccess soa(Thread::Current());
-  // The "disableIntrinsic" is the first field.
-  ArtField* field = GetClassRoot<mirror::Reference>()->GetField(0);
-  DCHECK_STREQ(field->GetName(), "disableIntrinsic");
+  ArtField* field = WellKnownClasses::java_lang_ref_Reference_disableIntrinsic;
   return field->GetOffset();
 }
 
 MemberOffset IntrinsicVisitor::GetReferenceSlowPathEnabledOffset() {
   ScopedObjectAccess soa(Thread::Current());
-  // The "slowPathEnabled" is the sixth field.
-  ArtField* field = GetClassRoot<mirror::Reference>()->GetField(5);
-  DCHECK_STREQ(field->GetName(), "slowPathEnabled");
+  ArtField* field = WellKnownClasses::java_lang_ref_Reference_slowPathEnabled;
   return field->GetOffset();
 }
 
diff --git a/compiler/optimizing/reference_type_propagation.cc b/compiler/optimizing/reference_type_propagation.cc
index 8ff1b89f9e..3e90a0881f 100644
--- a/compiler/optimizing/reference_type_propagation.cc
+++ b/compiler/optimizing/reference_type_propagation.cc
@@ -278,8 +278,7 @@ static void BoundTypeForClassCheck(HInstruction* check) {
 
   {
     ScopedObjectAccess soa(Thread::Current());
-    ArtField* field = GetClassRoot<mirror::Object>()->GetField(0);
-    DCHECK_EQ(std::string(field->GetName()), "shadow$_klass_");
+    ArtField* field = WellKnownClasses::java_lang_Object_shadowKlass;
     if (field_get->GetFieldInfo().GetField() != field) {
       return;
     }
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 31d3acbbcd..0ca970aa2d 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1092,42 +1092,6 @@ void ClassLinker::FinishInit(Thread* self) {
 
   CreateStringInitBindings(self, this);
 
-  // Let the heap know some key offsets into java.lang.ref instances
-  // Note: we hard code the field indexes here rather than using FindInstanceField
-  // as the types of the field can't be resolved prior to the runtime being
-  // fully initialized
-  StackHandleScope<3> hs(self);
-  Handle<mirror::Class> java_lang_ref_Reference =
-      hs.NewHandle(GetClassRoot<mirror::Reference>(this));
-  Handle<mirror::Class> java_lang_ref_FinalizerReference =
-      hs.NewHandle(FindSystemClass(self, "Ljava/lang/ref/FinalizerReference;"));
-
-  ArtField* pendingNext = java_lang_ref_Reference->GetField(1);
-  CHECK(!pendingNext->IsStatic());
-  CHECK_STREQ(pendingNext->GetName(), "pendingNext");
-  CHECK_STREQ(pendingNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
-
-  ArtField* queue = java_lang_ref_Reference->GetField(2);
-  CHECK(!queue->IsStatic());
-  CHECK_STREQ(queue->GetName(), "queue");
-  CHECK_STREQ(queue->GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
-
-  ArtField* queueNext = java_lang_ref_Reference->GetField(3);
-  CHECK(!queueNext->IsStatic());
-  CHECK_STREQ(queueNext->GetName(), "queueNext");
-  CHECK_STREQ(queueNext->GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
-
-  ArtField* referent = java_lang_ref_Reference->GetField(4);
-  CHECK(!referent->IsStatic());
-  CHECK_STREQ(referent->GetName(), "referent");
-  CHECK_STREQ(referent->GetTypeDescriptor(), "Ljava/lang/Object;");
-
-  ArtField* zombie = java_lang_ref_FinalizerReference->GetField(
-      java_lang_ref_FinalizerReference->NumFields() - 1);
-  CHECK(!zombie->IsStatic());
-  CHECK_STREQ(zombie->GetName(), "zombie");
-  CHECK_STREQ(zombie->GetTypeDescriptor(), "Ljava/lang/Object;");
-
   // ensure all class_roots_ are initialized
   for (size_t i = 0; i < static_cast<size_t>(ClassRoot::kMax); i++) {
     ClassRoot class_root = static_cast<ClassRoot>(i);
@@ -1149,6 +1113,7 @@ void ClassLinker::FinishInit(Thread* self) {
   // ensure that the class will be initialized.
   if (kMemoryToolIsAvailable && !Runtime::Current()->IsAotCompiler()) {
     ObjPtr<mirror::Class> soe_klass = FindSystemClass(self, "Ljava/lang/StackOverflowError;");
+    StackHandleScope<1> hs(self);
     if (soe_klass == nullptr || !EnsureInitialized(self, hs.NewHandle(soe_klass), true, true)) {
       // Strange, but don't crash.
       LOG(WARNING) << "Could not prepare StackOverflowError.";
@@ -9491,10 +9456,14 @@ bool ClassLinker::LinkFieldsHelper::LinkFields(ClassLinker* class_linker,
       UNLIKELY(!class_linker->init_done_) &&
       klass->DescriptorEquals("Ljava/lang/ref/Reference;")) {
     // We know there are no non-reference fields in the Reference classes, and we know
-    // that 'referent' is alphabetically last, so this is easy...
+    // that 'referent' is alphabetically the last instance field, so this is easy...
+    // Note that we cannot use WellKnownClasses fields yet, as this is not
+    // initialized.
     CHECK_EQ(num_reference_fields, num_fields) << klass->PrettyClass();
     CHECK_STREQ(fields->At(klass->NumFields() - 2).GetName(), "referent");
+    CHECK(!fields->At(klass->NumFields() - 2).IsStatic());
     CHECK_STREQ(fields->At(klass->NumFields() - 1).GetName(), "slowPathEnabled");
+    CHECK(fields->At(klass->NumFields() - 1).IsStatic());
     --num_reference_fields;
   }
 
diff --git a/runtime/gc/reference_processor.cc b/runtime/gc/reference_processor.cc
index c799f5443b..2621629bb8 100644
--- a/runtime/gc/reference_processor.cc
+++ b/runtime/gc/reference_processor.cc
@@ -54,9 +54,8 @@ ReferenceProcessor::ReferenceProcessor()
 static inline MemberOffset GetSlowPathFlagOffset(ObjPtr<mirror::Class> reference_class)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   DCHECK(reference_class == GetClassRoot<mirror::Reference>());
-  ArtField* field = reference_class->GetField(reference_class->NumFields() - 1);
+  ArtField* field = WellKnownClasses::java_lang_ref_Reference_slowPathEnabled;
   DCHECK(field->IsStatic());
-  DCHECK_STREQ(field->GetName(), "slowPathEnabled");
   return field->GetOffset();
 }
 
diff --git a/runtime/well_known_classes.cc b/runtime/well_known_classes.cc
index 8fff1ba33c..5a1e7f4264 100644
--- a/runtime/well_known_classes.cc
+++ b/runtime/well_known_classes.cc
@@ -126,7 +126,10 @@ ArtField* WellKnownClasses::dalvik_system_DexPathList_dexElements;
 ArtField* WellKnownClasses::dalvik_system_DexPathList__Element_dexFile;
 ArtField* WellKnownClasses::dalvik_system_VMRuntime_nonSdkApiUsageConsumer;
 ArtField* WellKnownClasses::java_io_FileDescriptor_descriptor;
+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_String_EMPTY;
 ArtField* WellKnownClasses::java_lang_Thread_parkBlocker;
 ArtField* WellKnownClasses::java_lang_Thread_daemon;
@@ -746,6 +749,16 @@ void WellKnownClasses::InitFieldsAndMethodsOnly(JNIEnv* env) {
       "(I[BII)Lorg/apache/harmony/dalvik/ddmc/Chunk;",
       pointer_size);
 
+  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(
@@ -968,7 +981,10 @@ void WellKnownClasses::Clear() {
   dalvik_system_DexPathList_dexElements = nullptr;
   dalvik_system_DexPathList__Element_dexFile = nullptr;
   dalvik_system_VMRuntime_nonSdkApiUsageConsumer = 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_Thread_parkBlocker = nullptr;
   java_lang_Thread_daemon = nullptr;
diff --git a/runtime/well_known_classes.h b/runtime/well_known_classes.h
index 6f5473e89e..5a70b80839 100644
--- a/runtime/well_known_classes.h
+++ b/runtime/well_known_classes.h
@@ -172,7 +172,10 @@ struct EXPORT WellKnownClasses {
   static ArtField* dalvik_system_DexPathList__Element_dexFile;
   static ArtField* dalvik_system_VMRuntime_nonSdkApiUsageConsumer;
   static ArtField* java_io_FileDescriptor_descriptor;
+  static ArtField* java_lang_ref_Reference_disableIntrinsic;
+  static ArtField* java_lang_ref_Reference_slowPathEnabled;
   static ArtField* java_lang_ClassLoader_parent;
+  static ArtField* java_lang_Object_shadowKlass;
   static ArtField* java_lang_String_EMPTY;
   static ArtField* java_lang_Thread_parkBlocker;
   static ArtField* java_lang_Thread_daemon;