Use ArtMethod* .bss entries for HInvokeStaticOrDirect.

Test: m test-art-host-gtest
Test: testrunner.py --host
Test: testrunner.py --target
Test: Nexus 6P boots.
Test: Build aosp_mips64-userdebug.
Bug: 30627598
Change-Id: I0e54fdd2e91e983d475b7a04d40815ba89ae3d4f

1 files changed, 15 insertions, 26 deletions

diff --git a/compiler/compiled_method.h b/compiler/compiled_method.h
index 0ca23a5c50..761e9e19a8 100644
--- a/compiler/compiled_method.h
+++ b/compiler/compiled_method.h
@@ -120,13 +120,13 @@ class LinkerPatch {
   // patch_type_ as an uintN_t and do explicit static_cast<>s.
   enum class Type : uint8_t {
     kMethodRelative,          // NOTE: Actual patching is instruction_set-dependent.
+    kMethodBssEntry,          // NOTE: Actual patching is instruction_set-dependent.
     kCall,
     kCallRelative,            // NOTE: Actual patching is instruction_set-dependent.
     kTypeRelative,            // NOTE: Actual patching is instruction_set-dependent.
     kTypeBssEntry,            // NOTE: Actual patching is instruction_set-dependent.
     kStringRelative,          // NOTE: Actual patching is instruction_set-dependent.
     kStringBssEntry,          // NOTE: Actual patching is instruction_set-dependent.
-    kDexCacheArray,           // NOTE: Actual patching is instruction_set-dependent.
     kBakerReadBarrierBranch,  // NOTE: Actual patching is instruction_set-dependent.
   };
 
@@ -140,6 +140,16 @@ class LinkerPatch {
     return patch;
   }
 
+  static LinkerPatch MethodBssEntryPatch(size_t literal_offset,
+                                         const DexFile* target_dex_file,
+                                         uint32_t pc_insn_offset,
+                                         uint32_t target_method_idx) {
+    LinkerPatch patch(literal_offset, Type::kMethodBssEntry, target_dex_file);
+    patch.method_idx_ = target_method_idx;
+    patch.pc_insn_offset_ = pc_insn_offset;
+    return patch;
+  }
+
   static LinkerPatch CodePatch(size_t literal_offset,
                                const DexFile* target_dex_file,
                                uint32_t target_method_idx) {
@@ -196,16 +206,6 @@ class LinkerPatch {
     return patch;
   }
 
-  static LinkerPatch DexCacheArrayPatch(size_t literal_offset,
-                                        const DexFile* target_dex_file,
-                                        uint32_t pc_insn_offset,
-                                        uint32_t element_offset) {
-    LinkerPatch patch(literal_offset, Type::kDexCacheArray, target_dex_file);
-    patch.pc_insn_offset_ = pc_insn_offset;
-    patch.element_offset_ = element_offset;
-    return patch;
-  }
-
   static LinkerPatch BakerReadBarrierBranchPatch(size_t literal_offset,
                                                  uint32_t custom_value1 = 0u,
                                                  uint32_t custom_value2 = 0u) {
@@ -229,12 +229,12 @@ class LinkerPatch {
   bool IsPcRelative() const {
     switch (GetType()) {
       case Type::kMethodRelative:
+      case Type::kMethodBssEntry:
       case Type::kCallRelative:
       case Type::kTypeRelative:
       case Type::kTypeBssEntry:
       case Type::kStringRelative:
       case Type::kStringBssEntry:
-      case Type::kDexCacheArray:
       case Type::kBakerReadBarrierBranch:
         return true;
       default:
@@ -244,6 +244,7 @@ class LinkerPatch {
 
   MethodReference TargetMethod() const {
     DCHECK(patch_type_ == Type::kMethodRelative ||
+           patch_type_ == Type::kMethodBssEntry ||
            patch_type_ == Type::kCall ||
            patch_type_ == Type::kCallRelative);
     return MethodReference(target_dex_file_, method_idx_);
@@ -273,23 +274,13 @@ class LinkerPatch {
     return dex::StringIndex(string_idx_);
   }
 
-  const DexFile* TargetDexCacheDexFile() const {
-    DCHECK(patch_type_ == Type::kDexCacheArray);
-    return target_dex_file_;
-  }
-
-  size_t TargetDexCacheElementOffset() const {
-    DCHECK(patch_type_ == Type::kDexCacheArray);
-    return element_offset_;
-  }
-
   uint32_t PcInsnOffset() const {
     DCHECK(patch_type_ == Type::kMethodRelative ||
+           patch_type_ == Type::kMethodBssEntry ||
            patch_type_ == Type::kTypeRelative ||
            patch_type_ == Type::kTypeBssEntry ||
            patch_type_ == Type::kStringRelative ||
-           patch_type_ == Type::kStringBssEntry ||
-           patch_type_ == Type::kDexCacheArray);
+           patch_type_ == Type::kStringBssEntry);
     return pc_insn_offset_;
   }
 
@@ -324,12 +315,10 @@ class LinkerPatch {
     uint32_t method_idx_;       // Method index for Call/Method patches.
     uint32_t type_idx_;         // Type index for Type patches.
     uint32_t string_idx_;       // String index for String patches.
-    uint32_t element_offset_;   // Element offset in the dex cache arrays.
     uint32_t baker_custom_value1_;
     static_assert(sizeof(method_idx_) == sizeof(cmp1_), "needed by relational operators");
     static_assert(sizeof(type_idx_) == sizeof(cmp1_), "needed by relational operators");
     static_assert(sizeof(string_idx_) == sizeof(cmp1_), "needed by relational operators");
-    static_assert(sizeof(element_offset_) == sizeof(cmp1_), "needed by relational operators");
     static_assert(sizeof(baker_custom_value1_) == sizeof(cmp1_), "needed by relational operators");
   };
   union {