Add support for compact dex files in nterp.

Test: test.py
Bug: 112676029
Change-Id: I604af166dab0647037bf675cabc6ce433053a83c
diff --git a/libdexfile/dex/compact_dex_file.h b/libdexfile/dex/compact_dex_file.h
index 47edd51..f5cd924 100644
--- a/libdexfile/dex/compact_dex_file.h
+++ b/libdexfile/dex/compact_dex_file.h
@@ -89,24 +89,41 @@
     // Max preheader size in uint16_ts.
     static constexpr size_t kMaxPreHeaderSize = 6;
 
-   private:
-    CodeItem() = default;
+    static constexpr size_t FieldsOffset() {
+      return OFFSETOF_MEMBER(CodeItem, fields_);
+    }
+
+    static constexpr size_t InsnsCountAndFlagsOffset() {
+      return OFFSETOF_MEMBER(CodeItem, insns_count_and_flags_);
+    }
+
+    static constexpr size_t InsnsOffset() {
+      return OFFSETOF_MEMBER(CodeItem, insns_);
+    }
 
     static constexpr size_t kRegistersSizeShift = 12;
     static constexpr size_t kInsSizeShift = 8;
     static constexpr size_t kOutsSizeShift = 4;
     static constexpr size_t kTriesSizeSizeShift = 0;
-    static constexpr uint16_t kFlagPreHeaderRegisterSize = 0x1 << 0;
-    static constexpr uint16_t kFlagPreHeaderInsSize = 0x1 << 1;
-    static constexpr uint16_t kFlagPreHeaderOutsSize = 0x1 << 2;
-    static constexpr uint16_t kFlagPreHeaderTriesSize = 0x1 << 3;
-    static constexpr uint16_t kFlagPreHeaderInsnsSize = 0x1 << 4;
+    static constexpr uint16_t kBitPreHeaderRegistersSize = 0;
+    static constexpr uint16_t kBitPreHeaderInsSize = 1;
+    static constexpr uint16_t kBitPreHeaderOutsSize = 2;
+    static constexpr uint16_t kBitPreHeaderTriesSize = 3;
+    static constexpr uint16_t kBitPreHeaderInsnsSize = 4;
+    static constexpr uint16_t kFlagPreHeaderRegistersSize = 0x1 << kBitPreHeaderRegistersSize;
+    static constexpr uint16_t kFlagPreHeaderInsSize = 0x1 << kBitPreHeaderInsSize;
+    static constexpr uint16_t kFlagPreHeaderOutsSize = 0x1 << kBitPreHeaderOutsSize;
+    static constexpr uint16_t kFlagPreHeaderTriesSize = 0x1 << kBitPreHeaderTriesSize;
+    static constexpr uint16_t kFlagPreHeaderInsnsSize = 0x1 << kBitPreHeaderInsnsSize;
     static constexpr size_t kInsnsSizeShift = 5;
     static constexpr size_t kInsnsSizeBits = sizeof(uint16_t) * kBitsPerByte -  kInsnsSizeShift;
 
+   private:
+    CodeItem() = default;
+
     // Combined preheader flags for fast testing if we need to go slow path.
     static constexpr uint16_t kFlagPreHeaderCombined =
-        kFlagPreHeaderRegisterSize |
+        kFlagPreHeaderRegistersSize |
         kFlagPreHeaderInsSize |
         kFlagPreHeaderOutsSize |
         kFlagPreHeaderTriesSize |
@@ -154,7 +171,7 @@
           *out_preheader = size;
         }
       };
-      preheader_encode(registers_size, kFlagPreHeaderRegisterSize);
+      preheader_encode(registers_size, kFlagPreHeaderRegistersSize);
       preheader_encode(ins_size, kFlagPreHeaderInsSize);
       preheader_encode(outs_size, kFlagPreHeaderOutsSize);
       preheader_encode(tries_size, kFlagPreHeaderTriesSize);
@@ -203,7 +220,7 @@
           *insns_count += static_cast<uint32_t>(*preheader) << 16;
         }
         if (!kDecodeOnlyInstructionCount) {
-          if (HasPreHeader(kFlagPreHeaderRegisterSize)) {
+          if (HasPreHeader(kFlagPreHeaderRegistersSize)) {
             --preheader;
             *registers_size += preheader[0];
           }
diff --git a/runtime/art_method-inl.h b/runtime/art_method-inl.h
index 01fa33f..2914382 100644
--- a/runtime/art_method-inl.h
+++ b/runtime/art_method-inl.h
@@ -230,7 +230,8 @@
   PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
   return runtime->IsAotCompiler()
       ? GetDexFile()->GetCodeItem(reinterpret_cast32<uint32_t>(GetDataPtrSize(pointer_size)))
-      : reinterpret_cast<const dex::CodeItem*>(GetDataPtrSize(pointer_size));
+      : reinterpret_cast<const dex::CodeItem*>(
+          reinterpret_cast<uintptr_t>(GetDataPtrSize(pointer_size)) & ~1);
 }
 
 inline bool ArtMethod::IsResolvedTypeIdx(dex::TypeIndex type_idx) {
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index 0a824e3..09ad5fb 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -866,6 +866,15 @@
   }
 }
 
+void ArtMethod::SetCodeItem(const dex::CodeItem* code_item) {
+  DCHECK(HasCodeItem());
+  // We mark the lowest bit for the interpreter to know whether it's executing a
+  // method in a compact or standard dex file.
+  uintptr_t data =
+      reinterpret_cast<uintptr_t>(code_item) | (GetDexFile()->IsCompactDexFile() ? 1 : 0);
+  SetDataPtrSize(reinterpret_cast<void*>(data), kRuntimePointerSize);
+}
+
 // AssertSharedHeld doesn't work in GetAccessFlags, so use a NO_THREAD_SAFETY_ANALYSIS helper.
 // TODO: Figure out why ASSERT_SHARED_CAPABILITY doesn't work.
 template <ReadBarrierOption kReadBarrierOption>
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 30357f7..b21a18d 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -582,10 +582,7 @@
     return !IsRuntimeMethod() && !IsNative() && !IsProxyMethod() && !IsAbstract();
   }
 
-  void SetCodeItem(const dex::CodeItem* code_item) REQUIRES_SHARED(Locks::mutator_lock_) {
-    DCHECK(HasCodeItem());
-    SetDataPtrSize(code_item, kRuntimePointerSize);
-  }
+  void SetCodeItem(const dex::CodeItem* code_item) REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Is this a hand crafted method used for something like describing callee saves?
   bool IsCalleeSaveMethod() REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 3467a57..b03755c 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2207,7 +2207,7 @@
       if (method.HasCodeItem()) {
         const dex::CodeItem* code_item = method.GetDexFile()->GetCodeItem(
             reinterpret_cast32<uint32_t>(method.GetDataPtrSize(image_pointer_size_)));
-        method.SetDataPtrSize(code_item, image_pointer_size_);
+        method.SetCodeItem(code_item);
       }
       // Set image methods' entry point that point to the interpreter bridge to the
       // nterp entry point.
@@ -4041,8 +4041,7 @@
     if (Runtime::Current()->IsAotCompiler()) {
       dst->SetDataPtrSize(reinterpret_cast32<void*>(method.GetCodeItemOffset()), image_pointer_size_);
     } else {
-      dst->SetDataPtrSize(dst->GetDexFile()->GetCodeItem(method.GetCodeItemOffset()),
-                          image_pointer_size_);
+      dst->SetCodeItem(dst->GetDexFile()->GetCodeItem(method.GetCodeItemOffset()));
     }
   } else {
     dst->SetDataPtrSize(nullptr, image_pointer_size_);
diff --git a/runtime/interpreter/mterp/arm64ng/main.S b/runtime/interpreter/mterp/arm64ng/main.S
index 51ebea1..4949441 100644
--- a/runtime/interpreter/mterp/arm64ng/main.S
+++ b/runtime/interpreter/mterp/arm64ng/main.S
@@ -325,19 +325,71 @@
     b 1b
 .endm
 
+// Uses x12, x13, and x14 as temporaries.
+.macro FETCH_CODE_ITEM_INFO code_item, registers, outs, ins, load_ins
+    tbz \code_item, #0, 4f
+    and \code_item, \code_item, #-2 // Remove the extra bit that marks it's a compact dex file
+    ldrh w13, [\code_item, #COMPACT_CODE_ITEM_FIELDS_OFFSET]
+    ubfx \registers, w13, #COMPACT_CODE_ITEM_REGISTERS_SIZE_SHIFT, #4
+    ubfx \outs, w13, #COMPACT_CODE_ITEM_OUTS_SIZE_SHIFT, #4
+    .if \load_ins
+    ubfx \ins, w13, #COMPACT_CODE_ITEM_INS_SIZE_SHIFT, #4
+    .else
+    ubfx w14, w13, #COMPACT_CODE_ITEM_INS_SIZE_SHIFT, #4
+    add \registers, \registers, w14
+    .endif
+    ldrh w13, [\code_item, #COMPACT_CODE_ITEM_FLAGS_OFFSET]
+    tst w13, #COMPACT_CODE_ITEM_REGISTERS_INS_OUTS_FLAGS
+    b.eq 3f
+    sub x14, \code_item, #4
+    tst w13, #COMPACT_CODE_ITEM_INSNS_FLAG
+    csel x14, x14, \code_item, ne
+
+    tbz w13, #COMPACT_CODE_ITEM_REGISTERS_BIT, 1f
+    ldrh w12, [x14, #-2]!
+    add \registers, \registers, w12
+1:
+    tbz w13, #COMPACT_CODE_ITEM_INS_BIT, 2f
+    ldrh w12, [x14, #-2]!
+    .if \load_ins
+    add \ins, \ins, w12
+    .else
+    add \registers, \registers, w12
+    .endif
+2:
+    tbz w13, #COMPACT_CODE_ITEM_OUTS_BIT, 3f
+    ldrh w12, [x14, #-2]!
+    add \outs, \outs, w12
+3:
+    .if \load_ins
+    add \registers, \registers, \ins
+    .endif
+    add \code_item, \code_item, #COMPACT_CODE_ITEM_INSNS_OFFSET
+    b 5f
+4:
+    // Fetch dex register size.
+    ldrh \registers, [\code_item, #CODE_ITEM_REGISTERS_SIZE_OFFSET]
+    // Fetch outs size.
+    ldrh \outs, [\code_item, #CODE_ITEM_OUTS_SIZE_OFFSET]
+    .if \load_ins
+    ldrh \ins, [\code_item, #CODE_ITEM_INS_SIZE_OFFSET]
+    .endif
+    add \code_item, \code_item, #CODE_ITEM_INSNS_OFFSET
+5:
+.endm
+
 // Setup the stack to start executing the method. Expects:
 // - x0 to contain the ArtMethod
 //
 // Outputs
 // - ip contains the dex registers size
 // - x13 contains the old stack pointer.
+// - \code_item is replaced with a pointer to the instructions
+// - if load_ins is 1, w15 contains the ins
 //
-// Uses ip, ip2, x13, x14 as temporaries.
-.macro SETUP_STACK_FRAME code_item, refs, fp, cfi_refs
-    // Fetch dex register size.
-    ldrh wip, [\code_item, #CODE_ITEM_REGISTERS_SIZE_OFFSET]
-    // Fetch outs size.
-    ldrh wip2, [\code_item, #CODE_ITEM_OUTS_SIZE_OFFSET]
+// Uses ip, ip2, x12, x13, x14 as temporaries.
+.macro SETUP_STACK_FRAME code_item, refs, fp, cfi_refs, load_ins
+    FETCH_CODE_ITEM_INFO \code_item, wip, wip2, w15, \load_ins
 
     // Compute required frame size: ((2 * ip) + ip1) * 4 + 24
     // 24 is for saving the previous frame, pc, and method being executed.
@@ -482,7 +534,7 @@
    SPILL_ALL_CALLEE_SAVES
 
    // Setup the frame.
-   SETUP_STACK_FRAME x8, xNEW_REFS, xNEW_FP, CFI_NEW_REFS
+   SETUP_STACK_FRAME x8, xNEW_REFS, xNEW_FP, CFI_NEW_REFS, load_ins=0
    // Make x4 point to the top of the dex register array.
    add x4, xNEW_FP, ip, uxtx #2
 
@@ -493,7 +545,7 @@
    FETCH w3, 2
 
    // Set the dex pc pointer.
-   add xPC, x8, #CODE_ITEM_INSNS_OFFSET
+   mov xPC, x8
    CFI_DEFINE_DEX_PC_WITH_OFFSET(CFI_TMP, CFI_DEX, 0)
 .endm
 
@@ -1500,13 +1552,12 @@
     ldr xPC, [xINST, #ART_METHOD_DATA_OFFSET_64]
 
     // Setup the stack for executing the method.
-    SETUP_STACK_FRAME xPC, xREFS, xFP, CFI_REFS
+    SETUP_STACK_FRAME xPC, xREFS, xFP, CFI_REFS, load_ins=1
 
     // Setup the parameters
-    ldrh wip2, [xPC, #CODE_ITEM_INS_SIZE_OFFSET]
-    cbz wip2, .Lxmm_setup_finished
+    cbz w15, .Lxmm_setup_finished
 
-    sub ip2, ip, ip2
+    sub ip2, ip, x15
     lsl x8, ip2, #2 // x8 is now the offset for inputs into the registers array.
 
     // Setup shorty, pointer to inputs in FP and pointer to inputs in REFS
@@ -1547,8 +1598,6 @@
     LOOP_OVER_SHORTY_STORING_FPS d7, s7, x9, x12, x10, .Lxmm_setup_finished
     LOOP_OVER_FPs x9, x12, x10, x13, .Lxmm_setup_finished
 .Lxmm_setup_finished:
-    // Set the dex pc pointer.
-    add xPC, xPC, #CODE_ITEM_INSNS_OFFSET
     CFI_DEFINE_DEX_PC_WITH_OFFSET(CFI_TMP, CFI_DEX, 0)
 
     // Set rIBASE
diff --git a/runtime/interpreter/mterp/nterp.cc b/runtime/interpreter/mterp/nterp.cc
index b63f892..84d3de7 100644
--- a/runtime/interpreter/mterp/nterp.cc
+++ b/runtime/interpreter/mterp/nterp.cc
@@ -51,7 +51,6 @@
       method->SkipAccessChecks() &&
       method->IsInvokable() &&
       !method->MustCountLocks() &&
-      method->GetDexFile()->IsStandardDexFile() &&
       // Proxy methods do not go through the JIT like other methods, so we don't
       // run them with nterp.
       !method->IsProxyMethod() &&
diff --git a/runtime/interpreter/mterp/x86_64ng/main.S b/runtime/interpreter/mterp/x86_64ng/main.S
index cce7282..3ed5fff 100644
--- a/runtime/interpreter/mterp/x86_64ng/main.S
+++ b/runtime/interpreter/mterp/x86_64ng/main.S
@@ -73,11 +73,13 @@
 #define rINSTbl  %bl
 #define rIBASE   %r14
 #define rREFS    %r15
+#define rREFS32  %r15d
 #define CFI_REFS 15 // DWARF register number of the reference array (r15).
 
 // Temporary registers while setting up a frame.
 #define rNEW_FP   %r8
 #define rNEW_REFS %r9
+#define rNEW_REFS32 %r9d
 #define CFI_NEW_REFS 9
 
 /*
@@ -266,6 +268,80 @@
     jmp 2b
 .endm
 
+// Expects:
+// - r10, and r11 to be available.
+// Outputs:
+// - \registers contains the dex registers size
+// - \outs contains the outs size
+// - if load_ins is 1, \ins contains the ins
+// - \code_item is replace with a pointer to the instructions
+.macro FETCH_CODE_ITEM_INFO code_item, registers, outs, ins, load_ins
+    testq MACRO_LITERAL(1), \code_item
+    je 5f
+    andq $$-2, \code_item  // Remove the extra bit that marks it's a compact dex file.
+    movzwl COMPACT_CODE_ITEM_FIELDS_OFFSET(\code_item), %r10d
+    movl %r10d, \registers
+    sarl $$COMPACT_CODE_ITEM_REGISTERS_SIZE_SHIFT, \registers
+    andl $$0xf, \registers
+    movl %r10d, \outs
+    sarl $$COMPACT_CODE_ITEM_OUTS_SIZE_SHIFT, \outs
+    andl $$0xf, \outs
+    .if \load_ins
+    movl %r10d, \ins
+    sarl $$COMPACT_CODE_ITEM_INS_SIZE_SHIFT, \ins
+    andl $$0xf, \ins
+    .else
+    movl %r10d, %r11d
+    sarl $$COMPACT_CODE_ITEM_INS_SIZE_SHIFT, %r11d
+    andl $$0xf, %r11d
+    addl %r11d, \registers
+    .endif
+    testw $$COMPACT_CODE_ITEM_REGISTERS_INS_OUTS_FLAGS, COMPACT_CODE_ITEM_FLAGS_OFFSET(\code_item)
+    je 4f
+    movq \code_item, %r11
+    testw $$COMPACT_CODE_ITEM_INSNS_FLAG, COMPACT_CODE_ITEM_FLAGS_OFFSET(\code_item)
+    je 1f
+    subq $$4, %r11
+1:
+    testw $$COMPACT_CODE_ITEM_REGISTERS_FLAG, COMPACT_CODE_ITEM_FLAGS_OFFSET(\code_item)
+    je 2f
+    subq $$2, %r11
+    movzwl (%r11), %r10d
+    addl %r10d, \registers
+2:
+    testw $$COMPACT_CODE_ITEM_INS_FLAG, COMPACT_CODE_ITEM_FLAGS_OFFSET(\code_item)
+    je 3f
+    subq $$2, %r11
+    movzwl (%r11), %r10d
+    .if \load_ins
+    addl %r10d, \ins
+    .else
+    addl %r10d, \registers
+    .endif
+3:
+    testw $$COMPACT_CODE_ITEM_OUTS_FLAG, COMPACT_CODE_ITEM_FLAGS_OFFSET(\code_item)
+    je 4f
+    subq $$2, %r11
+    movzwl (%r11), %r10d
+    addl %r10d, \outs
+4:
+    .if \load_ins
+    addl \ins, \registers
+    .endif
+    addq $$COMPACT_CODE_ITEM_INSNS_OFFSET, \code_item
+    jmp 6f
+5:
+    // Fetch dex register size.
+    movzwl CODE_ITEM_REGISTERS_SIZE_OFFSET(\code_item), \registers
+    // Fetch outs size.
+    movzwl CODE_ITEM_OUTS_SIZE_OFFSET(\code_item), \outs
+    .if \load_ins
+    movzwl CODE_ITEM_INS_SIZE_OFFSET(\code_item), \ins
+    .endif
+    addq $$CODE_ITEM_INSNS_OFFSET, \code_item
+6:
+.endm
+
 // Setup the stack to start executing the method. Expects:
 // - rdi to contain the ArtMethod
 // - rbx, r10, r11 to be available.
@@ -273,11 +349,10 @@
 // Outputs
 // - rbx contains the dex registers size
 // - r11 contains the old stack pointer.
-.macro SETUP_STACK_FRAME code_item, refs, fp, cfi_refs
-    // Fetch dex register size.
-    movzwl CODE_ITEM_REGISTERS_SIZE_OFFSET(\code_item), %ebx
-    // Fetch outs size.
-    movzwq CODE_ITEM_OUTS_SIZE_OFFSET(\code_item), \refs
+// - \code_item is replace with a pointer to the instructions
+// - if load_ins is 1, r14 contains the ins
+.macro SETUP_STACK_FRAME code_item, refs, refs32, fp, cfi_refs, load_ins
+    FETCH_CODE_ITEM_INFO \code_item, %ebx, \refs32, %r14d, \load_ins
 
     // Compute required frame size for dex registers: ((2 * ebx) + refs)
     leaq (\refs, %rbx, 2), %r11
@@ -797,7 +872,7 @@
    SPILL_ALL_CALLEE_SAVES
 
    // Setup the frame.
-   SETUP_STACK_FRAME %rax, rNEW_REFS, rNEW_FP, CFI_NEW_REFS
+   SETUP_STACK_FRAME %rax, rNEW_REFS, rNEW_REFS32, rNEW_FP, CFI_NEW_REFS, load_ins=0
    // Make r11 point to the top of the dex register array.
    leaq (rNEW_FP, %rbx, 4), %r11
 
@@ -806,7 +881,7 @@
    movzwl 4(rPC), %ecx
 
    // Set the dex pc pointer.
-   leaq CODE_ITEM_INSNS_OFFSET(%rax), rPC
+   movq %rax, rPC
    CFI_DEFINE_DEX_PC_WITH_OFFSET(CFI_TMP, CFI_DEX, 0)
 .endm
 
@@ -1410,10 +1485,9 @@
     movq ART_METHOD_DATA_OFFSET_64(%rdi), rPC
 
     // Setup the stack for executing the method.
-    SETUP_STACK_FRAME rPC, rREFS, rFP, CFI_REFS
+    SETUP_STACK_FRAME rPC, rREFS, rREFS32, rFP, CFI_REFS, load_ins=1
 
     // Setup the parameters
-    movzwl CODE_ITEM_INS_SIZE_OFFSET(rPC), %r14d
     testl %r14d, %r14d
     je .Lxmm_setup_finished
 
@@ -1457,8 +1531,6 @@
     LOOP_OVER_SHORTY_STORING_XMMS xmm7, r10, r14, rdi, .Lxmm_setup_finished
     LOOP_OVER_FPs r10, r14, rdi, r11, .Lxmm_setup_finished
 .Lxmm_setup_finished:
-    // Set the dex pc pointer.
-    addq $$CODE_ITEM_INSNS_OFFSET, rPC
     CFI_DEFINE_DEX_PC_WITH_OFFSET(CFI_TMP, CFI_DEX, 0)
 
     // Set rIBASE
diff --git a/tools/cpp-define-generator/code_item.def b/tools/cpp-define-generator/code_item.def
index 01b0e85..24d62a8 100644
--- a/tools/cpp-define-generator/code_item.def
+++ b/tools/cpp-define-generator/code_item.def
@@ -16,6 +16,7 @@
 
 #if ASM_DEFINE_INCLUDE_DEPENDENCIES
 #include "dex/standard_dex_file.h"
+#include "dex/compact_dex_file.h"
 #endif
 
 ASM_DEFINE(CODE_ITEM_REGISTERS_SIZE_OFFSET,
@@ -26,3 +27,37 @@
            art::StandardDexFile::CodeItem::OutsSizeOffset())
 ASM_DEFINE(CODE_ITEM_INSNS_OFFSET,
            art::StandardDexFile::CodeItem::InsnsOffset())
+
+ASM_DEFINE(COMPACT_CODE_ITEM_FIELDS_OFFSET,
+           art::CompactDexFile::CodeItem::FieldsOffset())
+ASM_DEFINE(COMPACT_CODE_ITEM_FLAGS_OFFSET,
+           art::CompactDexFile::CodeItem::InsnsCountAndFlagsOffset())
+ASM_DEFINE(COMPACT_CODE_ITEM_INSNS_OFFSET,
+           art::CompactDexFile::CodeItem::InsnsOffset())
+
+ASM_DEFINE(COMPACT_CODE_ITEM_REGISTERS_INS_OUTS_FLAGS,
+           art::CompactDexFile::CodeItem::kFlagPreHeaderRegistersSize |
+           art::CompactDexFile::CodeItem::kFlagPreHeaderInsSize |
+           art::CompactDexFile::CodeItem::kFlagPreHeaderOutsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_REGISTERS_FLAG,
+           art::CompactDexFile::CodeItem::kFlagPreHeaderRegistersSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_INS_FLAG,
+           art::CompactDexFile::CodeItem::kFlagPreHeaderInsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_OUTS_FLAG,
+           art::CompactDexFile::CodeItem::kFlagPreHeaderOutsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_INSNS_FLAG,
+           art::CompactDexFile::CodeItem::kFlagPreHeaderInsnsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_REGISTERS_BIT,
+           art::CompactDexFile::CodeItem::kBitPreHeaderRegistersSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_INS_BIT,
+           art::CompactDexFile::CodeItem::kBitPreHeaderInsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_OUTS_BIT,
+           art::CompactDexFile::CodeItem::kBitPreHeaderOutsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_INSNS_BIT,
+           art::CompactDexFile::CodeItem::kBitPreHeaderInsnsSize)
+ASM_DEFINE(COMPACT_CODE_ITEM_REGISTERS_SIZE_SHIFT,
+           art::CompactDexFile::CodeItem::kRegistersSizeShift)
+ASM_DEFINE(COMPACT_CODE_ITEM_INS_SIZE_SHIFT,
+           art::CompactDexFile::CodeItem::kInsSizeShift)
+ASM_DEFINE(COMPACT_CODE_ITEM_OUTS_SIZE_SHIFT,
+           art::CompactDexFile::CodeItem::kOutsSizeShift)