Clean up Field::CreateFromArtField().

Remove code dealing with the DexCache. This was obsolete
since switching to hash-based DexCache arrays. This makes
the last remaining template parameter unused, so remove it
and move the implementation to the .cc file.

Test: m test-art-host-gtest
Test: testrunner.py --host --optmizing
Test: aost_taimen-userdebug boots.
Change-Id: Ib2077028f45792e4357d9c57280ece70a22e47a2

9 files changed, 63 insertions, 95 deletions

diff --git a/runtime/dex/dex_file_annotations.cc b/runtime/dex/dex_file_annotations.cc
index 366d41c65b..6261a93a5d 100644
--- a/runtime/dex/dex_file_annotations.cc
+++ b/runtime/dex/dex_file_annotations.cc
@@ -553,10 +553,7 @@ bool ProcessAnnotationValue(const ClassData& klass,
           return false;
         }
         set_object = true;
-        PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
-        element_object = (pointer_size == PointerSize::k64)
-            ? mirror::Field::CreateFromArtField<PointerSize::k64>(self, field, true)
-            : mirror::Field::CreateFromArtField<PointerSize::k32>(self, field, true);
+        element_object = mirror::Field::CreateFromArtField(self, field, true);
         if (element_object == nullptr) {
           return false;
         }
diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc
index 6b10b7fb44..99cd5470c3 100644
--- a/runtime/interpreter/unstarted_runtime.cc
+++ b/runtime/interpreter/unstarted_runtime.cc
@@ -48,7 +48,7 @@
 #include "mirror/array-inl.h"
 #include "mirror/class-alloc-inl.h"
 #include "mirror/executable-inl.h"
-#include "mirror/field-inl.h"
+#include "mirror/field.h"
 #include "mirror/method.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-alloc-inl.h"
@@ -360,10 +360,7 @@ void UnstartedRuntime::UnstartedClassGetDeclaredField(
                            klass->PrettyDescriptor().c_str());
     return;
   }
-  PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
-  ObjPtr<mirror::Field> field = (pointer_size == PointerSize::k64)
-      ? mirror::Field::CreateFromArtField<PointerSize::k64>(self, found, true)
-      : mirror::Field::CreateFromArtField<PointerSize::k32>(self, found, true);
+  ObjPtr<mirror::Field> field = mirror::Field::CreateFromArtField(self, found, true);
   result->SetL(field);
 }
 
diff --git a/runtime/jni/jni_internal.cc b/runtime/jni/jni_internal.cc
index c3694dc85e..c178c38c89 100644
--- a/runtime/jni/jni_internal.cc
+++ b/runtime/jni/jni_internal.cc
@@ -47,7 +47,7 @@
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/field-inl.h"
+#include "mirror/field.h"
 #include "mirror/method.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-alloc-inl.h"
@@ -544,7 +544,7 @@ class JNI {
     ScopedObjectAccess soa(env);
     ArtField* f = jni::DecodeArtField(fid);
     return soa.AddLocalReference<jobject>(
-        mirror::Field::CreateFromArtField<kRuntimePointerSize>(soa.Self(), f, true));
+        mirror::Field::CreateFromArtField(soa.Self(), f, true));
   }
 
   static jclass GetObjectClass(JNIEnv* env, jobject java_object) {
diff --git a/runtime/mirror/field-inl.h b/runtime/mirror/field-inl.h
index 9fe5eac630..f1f8b259f1 100644
--- a/runtime/mirror/field-inl.h
+++ b/runtime/mirror/field-inl.h
@@ -22,7 +22,6 @@
 #include "art_field-inl.h"
 #include "class-alloc-inl.h"
 #include "class_root-inl.h"
-#include "dex_cache-inl.h"
 #include "object-inl.h"
 
 namespace art {
@@ -41,70 +40,6 @@ inline ObjPtr<mirror::Class> Field::GetType() {
   return GetFieldObject<mirror::Class>(OFFSET_OF_OBJECT_MEMBER(Field, type_));
 }
 
-template <PointerSize kPointerSize>
-inline ObjPtr<mirror::Field> Field::CreateFromArtField(Thread* self,
-                                                       ArtField* field,
-                                                       bool force_resolve) {
-  StackHandleScope<2> hs(self);
-  // Try to resolve type before allocating since this is a thread suspension point.
-  Handle<mirror::Class> type = hs.NewHandle(field->ResolveType());
-
-  if (type == nullptr) {
-    if (force_resolve) {
-      if (kIsDebugBuild) {
-        self->AssertPendingException();
-      }
-      return nullptr;
-    } else {
-      // Can't resolve, clear the exception if it isn't OOME and continue with a null type.
-      mirror::Throwable* exception = self->GetException();
-      if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
-        return nullptr;
-      }
-      self->ClearException();
-    }
-  }
-  auto ret = hs.NewHandle(ObjPtr<Field>::DownCast(GetClassRoot<Field>()->AllocObject(self)));
-  if (UNLIKELY(ret == nullptr)) {
-    self->AssertPendingOOMException();
-    return nullptr;
-  }
-  auto dex_field_index = field->GetDexFieldIndex();
-  auto* resolved_field = field->GetDexCache()->GetResolvedField(dex_field_index, kPointerSize);
-  if (field->GetDeclaringClass()->IsProxyClass()) {
-    DCHECK(field->IsStatic());
-    DCHECK_LT(dex_field_index, 2U);
-    // The two static fields (interfaces, throws) of all proxy classes
-    // share the same dex file indices 0 and 1. So, we can't resolve
-    // them in the dex cache.
-  } else {
-    if (resolved_field != nullptr) {
-      DCHECK_EQ(resolved_field, field);
-    } else {
-      // We rely on the field being resolved so that we can back to the ArtField
-      // (i.e. FromReflectedMethod).
-      field->GetDexCache()->SetResolvedField(dex_field_index, field, kPointerSize);
-    }
-  }
-  // We're initializing a newly allocated object, so we do not need to record that under
-  // a transaction. If the transaction is aborted, the whole object shall be unreachable.
-  ret->SetType</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(type.Get());
-  ret->SetDeclaringClass</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
-      field->GetDeclaringClass());
-  ret->SetAccessFlags</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
-      field->GetAccessFlags());
-  auto iter_range = field->IsStatic() ? field->GetDeclaringClass()->GetSFields()
-                                      : field->GetDeclaringClass()->GetIFields();
-  auto position = std::find_if(
-      iter_range.begin(), iter_range.end(), [&](const auto& f) { return &f == field; });
-  DCHECK(position != iter_range.end());
-  ret->SetArtFieldIndex</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
-      std::distance(iter_range.begin(), position));
-  ret->SetOffset</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
-      field->GetOffset().Int32Value());
-  return ret.Get();
-}
-
 template<bool kTransactionActive, bool kCheckTransaction>
 inline void Field::SetDeclaringClass(ObjPtr<Class> c) {
   SetFieldObject<kTransactionActive, kCheckTransaction>(DeclaringClassOffset(), c);
diff --git a/runtime/mirror/field.cc b/runtime/mirror/field.cc
index e9669b8202..7faa55c469 100644
--- a/runtime/mirror/field.cc
+++ b/runtime/mirror/field.cc
@@ -45,14 +45,58 @@ void Field::VisitTarget(ReflectiveValueVisitor* v) {
 
 ArtField* Field::GetArtField() {
   ObjPtr<mirror::Class> declaring_class = GetDeclaringClass();
-  DCHECK_LT(GetArtFieldIndex(),
-            IsStatic() ? declaring_class->NumStaticFields() : declaring_class->NumInstanceFields());
   if (IsStatic()) {
+    DCHECK_LT(GetArtFieldIndex(), declaring_class->NumStaticFields());
     return declaring_class->GetStaticField(GetArtFieldIndex());
   } else {
+    DCHECK_LT(GetArtFieldIndex(), declaring_class->NumInstanceFields());
     return declaring_class->GetInstanceField(GetArtFieldIndex());
   }
 }
 
+ObjPtr<mirror::Field> Field::CreateFromArtField(Thread* self,
+                                                ArtField* field,
+                                                bool force_resolve) {
+  StackHandleScope<2> hs(self);
+  // Try to resolve type before allocating since this is a thread suspension point.
+  Handle<mirror::Class> type = hs.NewHandle(field->ResolveType());
+
+  if (type == nullptr) {
+    DCHECK(self->IsExceptionPending());
+    if (force_resolve) {
+      return nullptr;
+    } else {
+      // Can't resolve, clear the exception if it isn't OOME and continue with a null type.
+      mirror::Throwable* exception = self->GetException();
+      if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
+        return nullptr;
+      }
+      self->ClearException();
+    }
+  }
+  auto ret = hs.NewHandle(ObjPtr<Field>::DownCast(GetClassRoot<Field>()->AllocObject(self)));
+  if (UNLIKELY(ret == nullptr)) {
+    self->AssertPendingOOMException();
+    return nullptr;
+  }
+  // We're initializing a newly allocated object, so we do not need to record that under
+  // a transaction. If the transaction is aborted, the whole object shall be unreachable.
+  ret->SetType</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(type.Get());
+  ret->SetDeclaringClass</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+      field->GetDeclaringClass());
+  ret->SetAccessFlags</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+      field->GetAccessFlags());
+  auto iter_range = field->IsStatic() ? field->GetDeclaringClass()->GetSFields()
+                                      : field->GetDeclaringClass()->GetIFields();
+  auto position = std::find_if(
+      iter_range.begin(), iter_range.end(), [&](const auto& f) { return &f == field; });
+  DCHECK(position != iter_range.end());
+  ret->SetArtFieldIndex</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+      std::distance(iter_range.begin(), position));
+  ret->SetOffset</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+      field->GetOffset().Int32Value());
+  return ret.Get();
+}
+
 }  // namespace mirror
 }  // namespace art
diff --git a/runtime/mirror/field.h b/runtime/mirror/field.h
index f8419086ab..63aac15d14 100644
--- a/runtime/mirror/field.h
+++ b/runtime/mirror/field.h
@@ -71,7 +71,6 @@ class MANAGED Field : public AccessibleObject {
 
   ArtField* GetArtField() REQUIRES_SHARED(Locks::mutator_lock_);
 
-  template <PointerSize kPointerSize>
   static ObjPtr<mirror::Field> CreateFromArtField(Thread* self,
                                                   ArtField* field,
                                                   bool force_resolve)
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index c47d5e4fe9..7ea07464db 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -33,7 +33,7 @@
 #include "mirror/class-alloc-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field-inl.h"
+#include "mirror/field.h"
 #include "mirror/method.h"
 #include "mirror/method_handles_lookup.h"
 #include "mirror/object-inl.h"
@@ -312,7 +312,7 @@ static ObjPtr<mirror::ObjectArray<mirror::Field>> GetDeclaredFields(
   for (ArtField& field : ifields) {
     if (IsDiscoverable(public_only, hiddenapi_context, &field)) {
       ObjPtr<mirror::Field> reflect_field =
-          mirror::Field::CreateFromArtField<kRuntimePointerSize>(self, &field, force_resolve);
+          mirror::Field::CreateFromArtField(self, &field, force_resolve);
       if (reflect_field == nullptr) {
         if (kIsDebugBuild) {
           self->AssertPendingException();
@@ -326,7 +326,7 @@ static ObjPtr<mirror::ObjectArray<mirror::Field>> GetDeclaredFields(
   for (ArtField& field : sfields) {
     if (IsDiscoverable(public_only, hiddenapi_context, &field)) {
       ObjPtr<mirror::Field> reflect_field =
-          mirror::Field::CreateFromArtField<kRuntimePointerSize>(self, &field, force_resolve);
+          mirror::Field::CreateFromArtField(self, &field, force_resolve);
       if (reflect_field == nullptr) {
         if (kIsDebugBuild) {
           self->AssertPendingException();
@@ -417,11 +417,11 @@ ALWAYS_INLINE static inline ObjPtr<mirror::Field> GetDeclaredField(Thread* self,
   }
   ArtField* art_field = FindFieldByName(name, c->GetIFieldsPtr());
   if (art_field != nullptr) {
-    return mirror::Field::CreateFromArtField<kRuntimePointerSize>(self, art_field, true);
+    return mirror::Field::CreateFromArtField(self, art_field, true);
   }
   art_field = FindFieldByName(name, c->GetSFieldsPtr());
   if (art_field != nullptr) {
-    return mirror::Field::CreateFromArtField<kRuntimePointerSize>(self, art_field, true);
+    return mirror::Field::CreateFromArtField(self, art_field, true);
   }
   return nullptr;
 }
diff --git a/runtime/native/java_lang_invoke_MethodHandleImpl.cc b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
index c1060fe73a..45d9a8abef 100644
--- a/runtime/native/java_lang_invoke_MethodHandleImpl.cc
+++ b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
@@ -43,8 +43,8 @@ static jobject MethodHandleImpl_getMemberInternal(JNIEnv* env, jobject thiz) {
   MutableHandle<mirror::Object> h_object(hs.NewHandle<mirror::Object>(nullptr));
   if (handle_kind >= mirror::MethodHandle::kFirstAccessorKind) {
     ArtField* const field = handle->GetTargetField();
-    h_object.Assign(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
-        soa.Self(), field, /* force_resolve= */ false));
+    h_object.Assign(
+        mirror::Field::CreateFromArtField(soa.Self(), field, /* force_resolve= */ false));
   } else {
     ArtMethod* const method = handle->GetTargetMethod();
     if (method->IsConstructor()) {
diff --git a/runtime/proxy_test.cc b/runtime/proxy_test.cc
index 76e036ac45..d8e170b32e 100644
--- a/runtime/proxy_test.cc
+++ b/runtime/proxy_test.cc
@@ -20,7 +20,7 @@
 #include "art_field-inl.h"
 #include "base/enums.h"
 #include "common_runtime_test.h"
-#include "mirror/field-inl.h"
+#include "mirror/field.h"
 #include "proxy_test.h"
 #include "scoped_thread_state_change-inl.h"
 #include "well_known_classes.h"
@@ -173,17 +173,13 @@ TEST_F(ProxyTest, CheckArtMirrorFieldsOfProxyStaticFields) {
   ASSERT_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
   ASSERT_FALSE(Runtime::Current()->IsActiveTransaction());
   Handle<mirror::Field> field00 =
-      hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
-          soa.Self(), &static_fields0->At(0), true));
+      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(0), true));
   Handle<mirror::Field> field01 =
-      hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
-          soa.Self(), &static_fields0->At(1), true));
+      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(1), true));
   Handle<mirror::Field> field10 =
-      hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
-          soa.Self(), &static_fields1->At(0), true));
+      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(0), true));
   Handle<mirror::Field> field11 =
-      hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
-          soa.Self(), &static_fields1->At(1), true));
+      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(1), true));
   EXPECT_EQ(field00->GetArtField(), &static_fields0->At(0));
   EXPECT_EQ(field01->GetArtField(), &static_fields0->At(1));
   EXPECT_EQ(field10->GetArtField(), &static_fields1->At(0));