diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index 4694777..c1c9e19 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -1144,10 +1144,10 @@
                                    Instruction const* insn,
                                    JType jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, jty, kReg);
-  EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, jty, kReg);
+  EmitStoreDalvikReg(dec_insn.vA, jty, kReg, src_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1157,10 +1157,10 @@
                                          Instruction const* insn,
                                          JType jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* src_value = EmitLoadDalvikRetValReg(jty, kReg);
-  EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
+  EmitStoreDalvikReg(dec_insn.vA, jty, kReg, src_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1169,7 +1169,7 @@
 void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
                                             Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   // Get thread-local exception field address
   llvm::Constant* exception_field_offset =
@@ -1189,7 +1189,7 @@
   irb_.CreateStore(irb_.getJNull(), exception_field_addr);
 
   // Keep the exception object in the Dalvik register
-  EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, exception_object_addr);
+  EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, exception_object_addr);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1198,10 +1198,10 @@
 void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
                                              Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* exception_addr =
-    EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+    EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
 
   EmitUpdateLineNumFromDexPC(dex_pc);
 
@@ -1227,7 +1227,7 @@
 void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
                                      Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   // Garbage collection safe-point
   EmitGuard_GarbageCollectionSuspend(dex_pc);
@@ -1239,7 +1239,7 @@
 
   // Return!
   char ret_shorty = method_helper_.GetShorty()[0];
-  llvm::Value* retval = EmitLoadDalvikReg(dec_insn.vA_, ret_shorty, kAccurate);
+  llvm::Value* retval = EmitLoadDalvikReg(dec_insn.vA, ret_shorty, kAccurate);
 
   irb_.CreateRet(retval);
 }
@@ -1249,7 +1249,7 @@
                                            Instruction const* insn,
                                            JType imm_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(imm_jty == kInt || imm_jty == kLong) << imm_jty;
 
@@ -1262,22 +1262,22 @@
   case Instruction::CONST:
   case Instruction::CONST_WIDE_16:
   case Instruction::CONST_WIDE_32:
-    imm = static_cast<int64_t>(static_cast<int32_t>(dec_insn.vB_));
+    imm = static_cast<int64_t>(static_cast<int32_t>(dec_insn.vB));
     break;
 
   case Instruction::CONST_HIGH16:
     imm = static_cast<int64_t>(static_cast<int32_t>(
-          static_cast<uint32_t>(static_cast<uint16_t>(dec_insn.vB_)) << 16));
+          static_cast<uint32_t>(static_cast<uint16_t>(dec_insn.vB)) << 16));
     break;
 
   // 64-bit Immediate
   case Instruction::CONST_WIDE:
-    imm = static_cast<int64_t>(dec_insn.vB_wide_);
+    imm = static_cast<int64_t>(dec_insn.vB_wide);
     break;
 
   case Instruction::CONST_WIDE_HIGH16:
     imm = static_cast<int64_t>(
-          static_cast<uint64_t>(static_cast<uint16_t>(dec_insn.vB_)) << 48);
+          static_cast<uint64_t>(static_cast<uint16_t>(dec_insn.vB)) << 48);
     break;
 
   // Unknown opcode for load constant (unreachable)
@@ -1289,11 +1289,11 @@
   // Store the non-object register
   llvm::Type* imm_type = irb_.getJType(imm_jty, kAccurate);
   llvm::Constant* imm_value = llvm::ConstantInt::getSigned(imm_type, imm);
-  EmitStoreDalvikReg(dec_insn.vA_, imm_jty, kAccurate, imm_value);
+  EmitStoreDalvikReg(dec_insn.vA, imm_jty, kAccurate, imm_value);
 
   // Store the object register if it is possible to be null.
   if (imm_jty == kInt && imm == 0) {
-    EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, irb_.getJNull());
+    EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, irb_.getJNull());
   }
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
@@ -1303,9 +1303,9 @@
 void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
                                                  Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t string_idx = dec_insn.vB_;
+  uint32_t string_idx = dec_insn.vB;
 
   llvm::Value* string_field_addr = EmitLoadDexCacheStringFieldAddr(string_idx);
 
@@ -1325,7 +1325,7 @@
 
     // String is resolved, go to next basic block.
     irb_.SetInsertPoint(block_str_exist);
-    EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
+    EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, string_addr);
     irb_.CreateBr(GetNextBasicBlock(dex_pc));
 
     // String is not resolved yet, resolve it now.
@@ -1346,7 +1346,7 @@
   }
 
   // Store the string object to the Dalvik register
-  EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
+  EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, string_addr);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1433,10 +1433,10 @@
 void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
                                                 Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
-  EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, type_object_addr);
+  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB);
+  EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, type_object_addr);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1445,10 +1445,10 @@
 void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
                                            Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* object_addr =
-    EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+    EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
 
   // TODO: Slow path always. May not need NullPointerException check.
   EmitGuard_NullPointerException(dex_pc, object_addr);
@@ -1465,10 +1465,10 @@
 void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
                                           Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* object_addr =
-    EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+    EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
 
   EmitGuard_NullPointerException(dex_pc, object_addr);
 
@@ -1484,7 +1484,7 @@
 void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
                                         Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::BasicBlock* block_test_class =
     CreateBasicBlockWithDexPC(dex_pc, "test_class");
@@ -1493,7 +1493,7 @@
     CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
 
   llvm::Value* object_addr =
-    EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+    EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
 
   // Test: Is the reference equal to null?  Act as no-op when it is null.
   llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
@@ -1504,7 +1504,7 @@
 
   // Test: Is the object instantiated from the given class?
   irb_.SetInsertPoint(block_test_class);
-  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
+  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB);
   DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
 
   llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
@@ -1539,7 +1539,7 @@
 void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
                                          Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Constant* zero = irb_.getJInt(0);
   llvm::Constant* one = irb_.getJInt(1);
@@ -1556,7 +1556,7 @@
     CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
 
   llvm::Value* object_addr =
-    EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
+    EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
 
   // Overview of the following code :
   // We check for null, if so, then false, otherwise check for class == . If so
@@ -1568,12 +1568,12 @@
   irb_.CreateCondBr(equal_null, block_nullp, block_test_class);
 
   irb_.SetInsertPoint(block_nullp);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, zero);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, zero);
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 
   // Test: Is the object instantiated from the given class?
   irb_.SetInsertPoint(block_test_class);
-  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vC_);
+  llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vC);
   DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
 
   llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
@@ -1590,7 +1590,7 @@
   irb_.CreateCondBr(equal_class, block_class_equals, block_test_sub_class);
 
   irb_.SetInsertPoint(block_class_equals);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, one);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, one);
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 
   // Test: Is the object instantiated from the subclass of the given class?
@@ -1600,7 +1600,7 @@
     irb_.CreateCall2(irb_.GetRuntime(IsAssignable),
                      type_object_addr, object_type_object_addr);
 
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1623,15 +1623,15 @@
 void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
                                           Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   // Get the array object address
-  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
+  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
   EmitGuard_NullPointerException(dex_pc, array_addr);
 
   // Get the array length and store it to the register
   llvm::Value* array_len = EmitLoadArrayLength(array_addr);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, array_len);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, array_len);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1640,17 +1640,17 @@
 void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
                                           Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Function* runtime_func;
   if (compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
-                                            *dex_file_, dec_insn.vB_)) {
+                                            *dex_file_, dec_insn.vB)) {
     runtime_func = irb_.GetRuntime(AllocObject);
   } else {
     runtime_func = irb_.GetRuntime(AllocObjectWithAccessCheck);
   }
 
-  llvm::Constant* type_index_value = irb_.getInt32(dec_insn.vB_);
+  llvm::Constant* type_index_value = irb_.getInt32(dec_insn.vB);
 
   llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
 
@@ -1661,7 +1661,7 @@
 
   EmitGuard_ExceptionLandingPad(dex_pc);
 
-  EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
+  EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, object_addr);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1708,12 +1708,12 @@
 void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
                                        Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* object_addr =
-    EmitAllocNewArray(dex_pc, dec_insn.vB_, dec_insn.vC_, false);
+    EmitAllocNewArray(dex_pc, dec_insn.vB, dec_insn.vC, false);
 
-  EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
+  EmitStoreDalvikReg(dec_insn.vA, kObject, kAccurate, object_addr);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1723,12 +1723,12 @@
                                              Instruction const* insn,
                                              bool is_range) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   llvm::Value* object_addr =
-    EmitAllocNewArray(dex_pc, dec_insn.vA_, dec_insn.vB_, true);
+    EmitAllocNewArray(dex_pc, dec_insn.vA, dec_insn.vB, true);
 
-  if (dec_insn.vA_ > 0) {
+  if (dec_insn.vA > 0) {
     llvm::Value* object_addr_int =
       irb_.CreatePtrToInt(object_addr, irb_.getPtrEquivIntTy());
 
@@ -1741,7 +1741,7 @@
     llvm::Value* data_field_addr_int =
       irb_.CreateAdd(object_addr_int, data_field_offset);
 
-    Class* klass = method_->GetDexCacheResolvedTypes()->Get(dec_insn.vB_);
+    Class* klass = method_->GetDexCacheResolvedTypes()->Get(dec_insn.vB);
     CHECK_NE(klass, static_cast<Class*>(NULL));
     // Moved this below already: CHECK(!klass->IsPrimitive() || klass->IsPrimitiveInt());
 
@@ -1759,15 +1759,15 @@
     // one element which may be very space consuming.  Maybe changing to use
     // memcpy may help; however, since we can't guarantee that the alloca of
     // dalvik register are continuous, we can't perform such optimization yet.
-    for (uint32_t i = 0; i < dec_insn.vA_; ++i) {
+    for (uint32_t i = 0; i < dec_insn.vA; ++i) {
       llvm::Value* data_field_addr =
         irb_.CreateIntToPtr(data_field_addr_int, field_type);
 
       int reg_index;
       if (is_range) {
-        reg_index = dec_insn.vC_ + i;
+        reg_index = dec_insn.vC + i;
       } else {
-        reg_index = dec_insn.arg_[i];
+        reg_index = dec_insn.arg[i];
       }
 
       llvm::Value* reg_value;
@@ -1792,7 +1792,7 @@
 void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
                                             Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   // Read the payload
   struct PACKED Payload {
@@ -1803,7 +1803,7 @@
   };
 
   int32_t payload_offset = static_cast<int32_t>(dex_pc) +
-                           static_cast<int32_t>(dec_insn.vB_);
+                           static_cast<int32_t>(dec_insn.vB);
 
   Payload const* payload =
     reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
@@ -1811,7 +1811,7 @@
   uint32_t size_in_bytes = payload->elem_width_ * payload->num_elems_;
 
   // Load and check the array
-  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
 
   EmitGuard_NullPointerException(dex_pc, array_addr);
 
@@ -1879,9 +1879,9 @@
 void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
                                                   Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  int32_t branch_offset = dec_insn.vA_;
+  int32_t branch_offset = dec_insn.vA;
 
   if (branch_offset <= 0) {
     // Garbage collection safe-point on backward branch
@@ -1895,7 +1895,7 @@
 void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
                                            Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   struct PACKED Payload {
     uint16_t ident_;
@@ -1905,12 +1905,12 @@
   };
 
   int32_t payload_offset = static_cast<int32_t>(dex_pc) +
-                           static_cast<int32_t>(dec_insn.vB_);
+                           static_cast<int32_t>(dec_insn.vB);
 
   Payload const* payload =
     reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
 
-  llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
+  llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
 
   llvm::SwitchInst* sw =
     irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
@@ -1925,7 +1925,7 @@
 void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
                                            Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   struct PACKED Payload {
     uint16_t ident_;
@@ -1934,7 +1934,7 @@
   };
 
   int32_t payload_offset = static_cast<int32_t>(dex_pc) +
-                           static_cast<int32_t>(dec_insn.vB_);
+                           static_cast<int32_t>(dec_insn.vB);
 
   Payload const* payload =
     reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
@@ -1942,7 +1942,7 @@
   int32_t const* keys = payload->keys_and_targets_;
   int32_t const* targets = payload->keys_and_targets_ + payload->num_cases_;
 
-  llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
+  llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
 
   llvm::SwitchInst* sw =
     irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
@@ -1958,12 +1958,12 @@
                                         JType fp_jty,
                                         bool gt_bias) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(fp_jty == kFloat || fp_jty == kDouble) << "JType: " << fp_jty;
 
-  llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, fp_jty, kAccurate);
-  llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, fp_jty, kAccurate);
+  llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB, fp_jty, kAccurate);
+  llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC, fp_jty, kAccurate);
 
   llvm::Value* cmp_eq = irb_.CreateFCmpOEQ(src1_value, src2_value);
   llvm::Value* cmp_lt;
@@ -1975,7 +1975,7 @@
   }
 
   llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -1984,16 +1984,16 @@
 void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
                                           Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
-  llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, kLong, kAccurate);
+  llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB, kLong, kAccurate);
+  llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC, kLong, kAccurate);
 
   llvm::Value* cmp_eq = irb_.CreateICmpEQ(src1_value, src2_value);
   llvm::Value* cmp_lt = irb_.CreateICmpSLT(src1_value, src2_value);
 
   llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -2017,17 +2017,17 @@
                                                       Instruction const* insn,
                                                       CondBranchKind cond) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
-  int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB_);
+  int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
+  int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB);
 
   DCHECK_NE(kRegUnknown, src1_reg_cat);
   DCHECK_NE(kRegUnknown, src2_reg_cat);
   DCHECK_NE(kRegCat2, src1_reg_cat);
   DCHECK_NE(kRegCat2, src2_reg_cat);
 
-  int32_t branch_offset = dec_insn.vC_;
+  int32_t branch_offset = dec_insn.vC;
 
   if (branch_offset <= 0) {
     // Garbage collection safe-point on backward branch
@@ -2046,11 +2046,11 @@
     CHECK_EQ(src1_reg_cat, src2_reg_cat);
 
     if (src1_reg_cat == kRegCat1nr) {
-      src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
-      src2_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
+      src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
+      src2_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
     } else {
-      src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
-      src2_value = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
+      src1_value = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
+      src2_value = EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
     }
   } else {
     DCHECK(src1_reg_cat == kRegZero ||
@@ -2059,17 +2059,17 @@
     if (src1_reg_cat == kRegZero) {
       if (src2_reg_cat == kRegCat1nr) {
         src1_value = irb_.getJInt(0);
-        src2_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
+        src2_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
       } else {
         src1_value = irb_.getJNull();
-        src2_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+        src2_value = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
       }
     } else { // src2_reg_cat == kRegZero
       if (src2_reg_cat == kRegCat1nr) {
-        src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
+        src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
         src2_value = irb_.getJInt(0);
       } else {
-        src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+        src1_value = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
         src2_value = irb_.getJNull();
       }
     }
@@ -2088,14 +2088,14 @@
                                                      Instruction const* insn,
                                                      CondBranchKind cond) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
+  int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA);
 
   DCHECK_NE(kRegUnknown, src_reg_cat);
   DCHECK_NE(kRegCat2, src_reg_cat);
 
-  int32_t branch_offset = dec_insn.vB_;
+  int32_t branch_offset = dec_insn.vB;
 
   if (branch_offset <= 0) {
     // Garbage collection safe-point on backward branch
@@ -2111,10 +2111,10 @@
   llvm::Value* src2_value;
 
   if (src_reg_cat == kRegCat1nr) {
-    src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vA, kInt, kAccurate);
     src2_value = irb_.getInt32(0);
   } else {
-    src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vA, kObject, kAccurate);
     src2_value = irb_.getJNull();
   }
 
@@ -2228,10 +2228,10 @@
                                    Instruction const* insn,
                                    JType elem_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
-  llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
+  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
+  llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC, kInt, kAccurate);
 
   EmitGuard_ArrayException(dex_pc, array_addr, index_value);
 
@@ -2242,7 +2242,7 @@
 
   llvm::Value* array_elem_value = irb_.CreateLoad(array_elem_addr);
 
-  EmitStoreDalvikReg(dec_insn.vA_, elem_jty, kArray, array_elem_value);
+  EmitStoreDalvikReg(dec_insn.vA, elem_jty, kArray, array_elem_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -2252,10 +2252,10 @@
                                    Instruction const* insn,
                                    JType elem_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
-  llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
+  llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB, kObject, kAccurate);
+  llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC, kInt, kAccurate);
 
   EmitGuard_ArrayException(dex_pc, array_addr, index_value);
 
@@ -2264,7 +2264,7 @@
   llvm::Value* array_elem_addr =
     EmitArrayGEP(array_addr, index_value, elem_type, elem_jty);
 
-  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, elem_jty, kArray);
+  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA, elem_jty, kArray);
 
   irb_.CreateStore(new_value, array_elem_addr);
 
@@ -2286,10 +2286,10 @@
                                    Instruction const* insn,
                                    JType field_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t reg_idx = dec_insn.vB_;
-  uint32_t field_idx = dec_insn.vC_;
+  uint32_t reg_idx = dec_insn.vB;
+  uint32_t field_idx = dec_insn.vC;
 
   Field* field = dex_cache_->GetResolvedField(field_idx);
 
@@ -2336,7 +2336,7 @@
     field_value = irb_.CreateLoad(field_addr);
   }
 
-  EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, field_value);
+  EmitStoreDalvikReg(dec_insn.vA, field_jty, kField, field_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -2346,10 +2346,10 @@
                                    Instruction const* insn,
                                    JType field_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t reg_idx = dec_insn.vB_;
-  uint32_t field_idx = dec_insn.vC_;
+  uint32_t reg_idx = dec_insn.vB;
+  uint32_t field_idx = dec_insn.vC;
 
   Field* field = dex_cache_->GetResolvedField(field_idx);
 
@@ -2357,7 +2357,7 @@
 
   EmitGuard_NullPointerException(dex_pc, object_addr);
 
-  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
+  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA, field_jty, kField);
 
   if (field == NULL) {
     PrintUnresolvedFieldWarning(field_idx);
@@ -2563,11 +2563,11 @@
                                    Instruction const* insn,
                                    JType field_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   uint32_t declaring_type_idx = DexFile::kDexNoIndex;
 
-  Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
+  Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB, declaring_type_idx);
 
   llvm::Value* static_field_value;
 
@@ -2582,7 +2582,7 @@
       runtime_func = irb_.GetRuntime(Get32Static);
     }
 
-    llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
+    llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB);
 
     llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
 
@@ -2607,7 +2607,7 @@
     static_field_value = irb_.CreateLoad(static_field_addr);
   }
 
-  EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, static_field_value);
+  EmitStoreDalvikReg(dec_insn.vA, field_jty, kField, static_field_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -2617,13 +2617,13 @@
                                    Instruction const* insn,
                                    JType field_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   uint32_t declaring_type_idx = DexFile::kDexNoIndex;
 
-  Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
+  Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB, declaring_type_idx);
 
-  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
+  llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA, field_jty, kField);
 
   if (field == NULL) {
     llvm::Function* runtime_func;
@@ -2636,7 +2636,7 @@
       runtime_func = irb_.GetRuntime(Set32Static);
     }
 
-    llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
+    llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB);
 
     llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
 
@@ -2665,13 +2665,11 @@
 }
 
 
-llvm::Value* MethodCompiler::
-EmitLoadCalleeThis(Instruction::DecodedInstruction const& dec_insn,
-                   bool is_range) {
+llvm::Value* MethodCompiler::EmitLoadCalleeThis(DecodedInstruction const& dec_insn, bool is_range) {
   if (is_range) {
-    return EmitLoadDalvikReg(dec_insn.vC_, kObject, kAccurate);
+    return EmitLoadDalvikReg(dec_insn.vC, kObject, kAccurate);
   } else {
-    return EmitLoadDalvikReg(dec_insn.arg_[0], kObject, kAccurate);
+    return EmitLoadDalvikReg(dec_insn.arg[0], kObject, kAccurate);
   }
 }
 
@@ -2679,7 +2677,7 @@
 void MethodCompiler::
 EmitLoadActualParameters(std::vector<llvm::Value*>& args,
                          uint32_t callee_method_idx,
-                         Instruction::DecodedInstruction const& dec_insn,
+                         DecodedInstruction const& dec_insn,
                          bool is_range,
                          bool is_static) {
 
@@ -2699,8 +2697,8 @@
   }
 
   for (uint32_t i = 1; i < shorty_size; ++i) {
-    uint32_t reg_idx = (is_range) ? (dec_insn.vC_ + reg_count)
-                                  : (dec_insn.arg_[reg_count]);
+    uint32_t reg_idx = (is_range) ? (dec_insn.vC + reg_count)
+                                  : (dec_insn.arg[reg_count]);
 
     args.push_back(EmitLoadDalvikReg(reg_idx, shorty[i], kAccurate));
 
@@ -2712,7 +2710,7 @@
     }
   }
 
-  DCHECK_EQ(reg_count, dec_insn.vA_)
+  DCHECK_EQ(reg_count, dec_insn.vA)
     << "Actual argument mismatch for callee: "
     << PrettyMethod(callee_method_idx, *dex_file_);
 }
@@ -2723,9 +2721,9 @@
                                             Instruction const* insn,
                                             bool is_range) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t callee_method_idx = dec_insn.vB_;
+  uint32_t callee_method_idx = dec_insn.vB;
 
   // Find the method object at compile time
   Method* callee_method = ResolveMethod(callee_method_idx);
@@ -2782,9 +2780,9 @@
                                           Instruction const* insn,
                                           bool is_range) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t callee_method_idx = dec_insn.vB_;
+  uint32_t callee_method_idx = dec_insn.vB;
 
   // Find the method object at compile time
   Method* callee_overiding_method = ResolveMethod(callee_method_idx);
@@ -2877,9 +2875,9 @@
                                                  InvokeType invoke_type,
                                                  bool is_range) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t callee_method_idx = dec_insn.vB_;
+  uint32_t callee_method_idx = dec_insn.vB;
 
   bool is_static = (invoke_type == kStatic);
 
@@ -2941,9 +2939,9 @@
                                               Instruction const* insn,
                                               bool is_range) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  uint32_t callee_method_idx = dec_insn.vB_;
+  uint32_t callee_method_idx = dec_insn.vB;
 
   // Resolve callee method
   Method* callee_method = ResolveMethod(callee_method_idx);
@@ -2994,13 +2992,13 @@
                                   Instruction const* insn,
                                   JType op_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
   llvm::Value* result_value = irb_.CreateNeg(src_value);
-  EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, op_jty, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3010,15 +3008,15 @@
                                   Instruction const* insn,
                                   JType op_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
   llvm::Value* result_value =
     irb_.CreateXor(src_value, static_cast<uint64_t>(-1));
 
-  EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, op_jty, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3027,11 +3025,11 @@
 void MethodCompiler::EmitInsn_SExt(uint32_t dex_pc,
                                    Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
   llvm::Value* result_value = irb_.CreateSExt(src_value, irb_.getJLongTy());
-  EmitStoreDalvikReg(dec_insn.vA_, kLong, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kLong, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3040,11 +3038,11 @@
 void MethodCompiler::EmitInsn_Trunc(uint32_t dex_pc,
                                     Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kLong, kAccurate);
   llvm::Value* result_value = irb_.CreateTrunc(src_value, irb_.getJIntTy());
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3054,16 +3052,16 @@
                                            Instruction const* insn,
                                            unsigned N) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
 
   llvm::Value* trunc_value =
     irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
 
   llvm::Value* result_value = irb_.CreateSExt(trunc_value, irb_.getJIntTy());
 
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3073,16 +3071,16 @@
                                            Instruction const* insn,
                                            unsigned N) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
 
   llvm::Value* trunc_value =
     irb_.CreateTrunc(src_value, llvm::Type::getIntNTy(*context_, N));
 
   llvm::Value* result_value = irb_.CreateZExt(trunc_value, irb_.getJIntTy());
 
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3092,13 +3090,13 @@
                                    Instruction const* insn,
                                    JType op_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
   llvm::Value* result_value = irb_.CreateFNeg(src_value);
-  EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, op_jty, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3109,15 +3107,15 @@
                                       JType src_jty,
                                       JType dest_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(src_jty == kInt || src_jty == kLong) << src_jty;
   DCHECK(dest_jty == kFloat || dest_jty == kDouble) << dest_jty;
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, src_jty, kAccurate);
   llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
   llvm::Value* dest_value = irb_.CreateSIToFP(src_value, dest_type);
-  EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
+  EmitStoreDalvikReg(dec_insn.vA, dest_jty, kAccurate, dest_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3128,15 +3126,15 @@
                                       JType src_jty,
                                       JType dest_jty) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(src_jty == kFloat || src_jty == kDouble) << src_jty;
   DCHECK(dest_jty == kInt || dest_jty == kLong) << dest_jty;
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, src_jty, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, src_jty, kAccurate);
   llvm::Type* dest_type = irb_.getJType(dest_jty, kAccurate);
   llvm::Value* dest_value = irb_.CreateFPToSI(src_value, dest_type);
-  EmitStoreDalvikReg(dec_insn.vA_, dest_jty, kAccurate, dest_value);
+  EmitStoreDalvikReg(dec_insn.vA, dest_jty, kAccurate, dest_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3145,11 +3143,11 @@
 void MethodCompiler::EmitInsn_FExt(uint32_t dex_pc,
                                    Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kFloat, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kFloat, kAccurate);
   llvm::Value* result_value = irb_.CreateFPExt(src_value, irb_.getJDoubleTy());
-  EmitStoreDalvikReg(dec_insn.vA_, kDouble, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kDouble, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3158,11 +3156,11 @@
 void MethodCompiler::EmitInsn_FTrunc(uint32_t dex_pc,
                                      Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kDouble, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kDouble, kAccurate);
   llvm::Value* result_value = irb_.CreateFPTrunc(src_value, irb_.getJFloatTy());
-  EmitStoreDalvikReg(dec_insn.vA_, kFloat, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kFloat, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3174,7 +3172,7 @@
                                         JType op_jty,
                                         bool is_2addr) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(op_jty == kInt || op_jty == kLong) << op_jty;
 
@@ -3182,18 +3180,18 @@
   llvm::Value* src2_value;
 
   if (is_2addr) {
-    src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
-    src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vA, op_jty, kAccurate);
+    src2_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
   } else {
-    src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
-    src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
+    src2_value = EmitLoadDalvikReg(dec_insn.vC, op_jty, kAccurate);
   }
 
   llvm::Value* result_value =
     EmitIntArithmResultComputation(dex_pc, src1_value, src2_value,
                                    arithm, op_jty);
 
-  EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, op_jty, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3203,16 +3201,16 @@
                                                  Instruction const* insn,
                                                  IntArithmKind arithm) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
 
-  llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
+  llvm::Value* imm_value = irb_.getInt32(dec_insn.vC);
 
   llvm::Value* result_value =
     EmitIntArithmResultComputation(dex_pc, src_value, imm_value, arithm, kInt);
 
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3284,12 +3282,12 @@
 void MethodCompiler::EmitInsn_RSubImmediate(uint32_t dex_pc,
                                             Instruction const* insn) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
-  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
-  llvm::Value* imm_value = irb_.getInt32(dec_insn.vC_);
+  llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB, kInt, kAccurate);
+  llvm::Value* imm_value = irb_.getInt32(dec_insn.vC);
   llvm::Value* result_value = irb_.CreateSub(imm_value, src_value);
-  EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, kInt, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }
@@ -3301,7 +3299,7 @@
                                        JType op_jty,
                                        bool is_2addr) {
 
-  Instruction::DecodedInstruction dec_insn(insn);
+  DecodedInstruction dec_insn(insn);
 
   DCHECK(op_jty == kFloat || op_jty == kDouble) << op_jty;
 
@@ -3309,17 +3307,17 @@
   llvm::Value* src2_value;
 
   if (is_2addr) {
-    src1_value = EmitLoadDalvikReg(dec_insn.vA_, op_jty, kAccurate);
-    src2_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vA, op_jty, kAccurate);
+    src2_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
   } else {
-    src1_value = EmitLoadDalvikReg(dec_insn.vB_, op_jty, kAccurate);
-    src2_value = EmitLoadDalvikReg(dec_insn.vC_, op_jty, kAccurate);
+    src1_value = EmitLoadDalvikReg(dec_insn.vB, op_jty, kAccurate);
+    src2_value = EmitLoadDalvikReg(dec_insn.vC, op_jty, kAccurate);
   }
 
   llvm::Value* result_value =
     EmitFPArithmResultComputation(dex_pc, src1_value, src2_value, arithm);
 
-  EmitStoreDalvikReg(dec_insn.vA_, op_jty, kAccurate, result_value);
+  EmitStoreDalvikReg(dec_insn.vA, op_jty, kAccurate, result_value);
 
   irb_.CreateBr(GetNextBasicBlock(dex_pc));
 }