diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index dd47359..8d6bf54 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -19,7 +19,7 @@
 namespace art {
 
 #define DISPLAY_MISSING_TARGETS (cUnit->enableDebug & \
-    (1 << kDebugDisplayMissingTargets))
+                                 (1 << kDebugDisplayMissingTargets))
 
 const RegLocation badLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0,
                             INVALID_REG, INVALID_REG, INVALID_SREG};
@@ -27,15 +27,15 @@
 /* Mark register usage state and return long retloc */
 RegLocation oatGetReturnWide(CompilationUnit* cUnit, bool isDouble)
 {
-    RegLocation gpr_res = LOC_C_RETURN_WIDE;
-    RegLocation fpr_res = LOC_C_RETURN_WIDE_DOUBLE;
-    RegLocation res = isDouble ? fpr_res : gpr_res;
-    oatClobber(cUnit, res.lowReg);
-    oatClobber(cUnit, res.highReg);
-    oatLockTemp(cUnit, res.lowReg);
-    oatLockTemp(cUnit, res.highReg);
-    oatMarkPair(cUnit, res.lowReg, res.highReg);
-    return res;
+  RegLocation gpr_res = LOC_C_RETURN_WIDE;
+  RegLocation fpr_res = LOC_C_RETURN_WIDE_DOUBLE;
+  RegLocation res = isDouble ? fpr_res : gpr_res;
+  oatClobber(cUnit, res.lowReg);
+  oatClobber(cUnit, res.highReg);
+  oatLockTemp(cUnit, res.lowReg);
+  oatLockTemp(cUnit, res.highReg);
+  oatMarkPair(cUnit, res.lowReg, res.highReg);
+  return res;
 }
 
 RegLocation oatGetReturn(CompilationUnit* cUnit, bool isFloat)
@@ -43,120 +43,120 @@
   RegLocation gpr_res = LOC_C_RETURN;
   RegLocation fpr_res = LOC_C_RETURN_FLOAT;
   RegLocation res = isFloat ? fpr_res : gpr_res;
-    oatClobber(cUnit, res.lowReg);
-    if (cUnit->instructionSet == kMips) {
-        oatMarkInUse(cUnit, res.lowReg);
-    } else {
-        oatLockTemp(cUnit, res.lowReg);
-    }
-    return res;
+  oatClobber(cUnit, res.lowReg);
+  if (cUnit->instructionSet == kMips) {
+    oatMarkInUse(cUnit, res.lowReg);
+  } else {
+    oatLockTemp(cUnit, res.lowReg);
+  }
+  return res;
 }
 
 void genInvoke(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
                InvokeType type, bool isRange)
 {
-    if (genIntrinsic(cUnit, bb, mir, type, isRange)) {
-        return;
-    }
-    DecodedInstruction* dInsn = &mir->dalvikInsn;
-    InvokeType originalType = type;  // avoiding mutation by ComputeInvokeInfo
-    int callState = 0;
-    LIR* nullCk;
-    LIR** pNullCk = NULL;
-    NextCallInsn nextCallInsn;
-    oatFlushAllRegs(cUnit);    /* Everything to home location */
-    // Explicit register usage
-    oatLockCallTemps(cUnit);
+  if (genIntrinsic(cUnit, bb, mir, type, isRange)) {
+    return;
+  }
+  DecodedInstruction* dInsn = &mir->dalvikInsn;
+  InvokeType originalType = type;  // avoiding mutation by ComputeInvokeInfo
+  int callState = 0;
+  LIR* nullCk;
+  LIR** pNullCk = NULL;
+  NextCallInsn nextCallInsn;
+  oatFlushAllRegs(cUnit);  /* Everything to home location */
+  // Explicit register usage
+  oatLockCallTemps(cUnit);
 
-    OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                             *cUnit->dex_file, *cUnit->dex_cache,
-                             cUnit->code_item, cUnit->method_idx,
-                             cUnit->access_flags);
+  OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
+                           *cUnit->dex_file, *cUnit->dex_cache,
+                           cUnit->code_item, cUnit->method_idx,
+                           cUnit->access_flags);
 
-    uint32_t dexMethodIdx = dInsn->vB;
-    int vtableIdx;
-    uintptr_t directCode;
-    uintptr_t directMethod;
-    bool skipThis;
-    bool fastPath =
-        cUnit->compiler->ComputeInvokeInfo(dexMethodIdx, &mUnit, type,
-                                           vtableIdx, directCode,
-                                           directMethod)
-        && !SLOW_INVOKE_PATH;
-    if (type == kInterface) {
-      nextCallInsn = fastPath ? nextInterfaceCallInsn
-                              : nextInterfaceCallInsnWithAccessCheck;
-      skipThis = false;
-    } else if (type == kDirect) {
-      if (fastPath) {
-        pNullCk = &nullCk;
-      }
-      nextCallInsn = fastPath ? nextSDCallInsn : nextDirectCallInsnSP;
-      skipThis = false;
-    } else if (type == kStatic) {
-      nextCallInsn = fastPath ? nextSDCallInsn : nextStaticCallInsnSP;
-      skipThis = false;
-    } else if (type == kSuper) {
-      DCHECK(!fastPath);  // Fast path is a direct call.
-      nextCallInsn = nextSuperCallInsnSP;
-      skipThis = false;
-    } else {
-      DCHECK_EQ(type, kVirtual);
-      nextCallInsn = fastPath ? nextVCallInsn : nextVCallInsnSP;
-      skipThis = fastPath;
+  uint32_t dexMethodIdx = dInsn->vB;
+  int vtableIdx;
+  uintptr_t directCode;
+  uintptr_t directMethod;
+  bool skipThis;
+  bool fastPath =
+    cUnit->compiler->ComputeInvokeInfo(dexMethodIdx, &mUnit, type,
+                                       vtableIdx, directCode,
+                                       directMethod)
+    && !SLOW_INVOKE_PATH;
+  if (type == kInterface) {
+    nextCallInsn = fastPath ? nextInterfaceCallInsn
+        : nextInterfaceCallInsnWithAccessCheck;
+    skipThis = false;
+  } else if (type == kDirect) {
+    if (fastPath) {
+      pNullCk = &nullCk;
     }
-    if (!isRange) {
-        callState = genDalvikArgsNoRange(cUnit, mir, dInsn, callState, pNullCk,
-                                         nextCallInsn, dexMethodIdx,
-                                         vtableIdx, directCode, directMethod,
-                                         originalType, skipThis);
-    } else {
-        callState = genDalvikArgsRange(cUnit, mir, dInsn, callState, pNullCk,
-                                       nextCallInsn, dexMethodIdx, vtableIdx,
-                                       directCode, directMethod, originalType,
-                                       skipThis);
-    }
-    // Finish up any of the call sequence not interleaved in arg loading
-    while (callState >= 0) {
-        callState = nextCallInsn(cUnit, mir, callState, dexMethodIdx,
-                                 vtableIdx, directCode, directMethod,
-                                 originalType);
-    }
-    if (DISPLAY_MISSING_TARGETS) {
-        genShowTarget(cUnit);
-    }
+    nextCallInsn = fastPath ? nextSDCallInsn : nextDirectCallInsnSP;
+    skipThis = false;
+  } else if (type == kStatic) {
+    nextCallInsn = fastPath ? nextSDCallInsn : nextStaticCallInsnSP;
+    skipThis = false;
+  } else if (type == kSuper) {
+    DCHECK(!fastPath);  // Fast path is a direct call.
+    nextCallInsn = nextSuperCallInsnSP;
+    skipThis = false;
+  } else {
+    DCHECK_EQ(type, kVirtual);
+    nextCallInsn = fastPath ? nextVCallInsn : nextVCallInsnSP;
+    skipThis = fastPath;
+  }
+  if (!isRange) {
+    callState = genDalvikArgsNoRange(cUnit, mir, dInsn, callState, pNullCk,
+                                     nextCallInsn, dexMethodIdx,
+                                     vtableIdx, directCode, directMethod,
+                                     originalType, skipThis);
+  } else {
+    callState = genDalvikArgsRange(cUnit, mir, dInsn, callState, pNullCk,
+                                   nextCallInsn, dexMethodIdx, vtableIdx,
+                                   directCode, directMethod, originalType,
+                                   skipThis);
+  }
+  // Finish up any of the call sequence not interleaved in arg loading
+  while (callState >= 0) {
+    callState = nextCallInsn(cUnit, mir, callState, dexMethodIdx,
+                             vtableIdx, directCode, directMethod,
+                             originalType);
+  }
+  if (DISPLAY_MISSING_TARGETS) {
+    genShowTarget(cUnit);
+  }
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rINVOKE_TGT);
+  opReg(cUnit, kOpBlx, rINVOKE_TGT);
 #else
-    if (fastPath && type != kInterface) {
-      opMem(cUnit, kOpBlx, rARG0, Method::GetCodeOffset().Int32Value());
-    } else {
-      int trampoline = 0;
-      switch (type) {
-        case kInterface:
-          trampoline = fastPath ? ENTRYPOINT_OFFSET(pInvokeInterfaceTrampoline)
-                                : ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
-          break;
-        case kDirect:
-          trampoline = ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
-          break;
-        case kStatic:
-          trampoline = ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
-          break;
-        case kSuper:
-          trampoline = ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
-          break;
-        case kVirtual:
-          trampoline = ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
-          break;
-        default:
-          LOG(FATAL) << "Unexpected invoke type";
-      }
-      opThreadMem(cUnit, kOpBlx, trampoline);
+  if (fastPath && type != kInterface) {
+    opMem(cUnit, kOpBlx, rARG0, Method::GetCodeOffset().Int32Value());
+  } else {
+    int trampoline = 0;
+    switch (type) {
+    case kInterface:
+      trampoline = fastPath ? ENTRYPOINT_OFFSET(pInvokeInterfaceTrampoline)
+          : ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
+      break;
+    case kDirect:
+      trampoline = ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
+      break;
+    case kStatic:
+      trampoline = ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
+      break;
+    case kSuper:
+      trampoline = ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
+      break;
+    case kVirtual:
+      trampoline = ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
+      break;
+    default:
+      LOG(FATAL) << "Unexpected invoke type";
     }
+    opThreadMem(cUnit, kOpBlx, trampoline);
+  }
 #endif
 
-    oatClobberCalleeSave(cUnit);
+  oatClobberCalleeSave(cUnit);
 }
 
 /*
@@ -167,867 +167,856 @@
 bool compileDalvikInstruction(CompilationUnit* cUnit, MIR* mir,
                               BasicBlock* bb, LIR* labelList)
 {
-    bool res = false;   // Assume success
-    RegLocation rlSrc[3];
-    RegLocation rlDest = badLoc;
-    RegLocation rlResult = badLoc;
-    Instruction::Code opcode = mir->dalvikInsn.opcode;
+  bool res = false;   // Assume success
+  RegLocation rlSrc[3];
+  RegLocation rlDest = badLoc;
+  RegLocation rlResult = badLoc;
+  Instruction::Code opcode = mir->dalvikInsn.opcode;
 
-    /* Prep Src and Dest locations */
-    int nextSreg = 0;
-    int nextLoc = 0;
-    int attrs = oatDataFlowAttributes[opcode];
-    rlSrc[0] = rlSrc[1] = rlSrc[2] = badLoc;
-    if (attrs & DF_UA) {
-        rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
-        nextSreg++;
-    } else if (attrs & DF_UA_WIDE) {
-        rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg,
-                                                 nextSreg + 1);
-        nextSreg+= 2;
-    }
-    if (attrs & DF_UB) {
-        rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
-        nextSreg++;
-    } else if (attrs & DF_UB_WIDE) {
-        rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg,
-                                                 nextSreg + 1);
-        nextSreg+= 2;
-    }
-    if (attrs & DF_UC) {
-        rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
-    } else if (attrs & DF_UC_WIDE) {
-        rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg,
-                                                 nextSreg + 1);
-    }
-    if (attrs & DF_DA) {
-        rlDest = oatGetDest(cUnit, mir, 0);
-    } else if (attrs & DF_DA_WIDE) {
-        rlDest = oatGetDestWide(cUnit, mir, 0, 1);
-    }
+  /* Prep Src and Dest locations */
+  int nextSreg = 0;
+  int nextLoc = 0;
+  int attrs = oatDataFlowAttributes[opcode];
+  rlSrc[0] = rlSrc[1] = rlSrc[2] = badLoc;
+  if (attrs & DF_UA) {
+    rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+    nextSreg++;
+  } else if (attrs & DF_UA_WIDE) {
+    rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg, nextSreg + 1);
+    nextSreg+= 2;
+  }
+  if (attrs & DF_UB) {
+    rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+    nextSreg++;
+  } else if (attrs & DF_UB_WIDE) {
+    rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg, nextSreg + 1);
+    nextSreg+= 2;
+  }
+  if (attrs & DF_UC) {
+    rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+  } else if (attrs & DF_UC_WIDE) {
+    rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg, nextSreg + 1);
+  }
+  if (attrs & DF_DA) {
+    rlDest = oatGetDest(cUnit, mir, 0);
+  } else if (attrs & DF_DA_WIDE) {
+    rlDest = oatGetDestWide(cUnit, mir, 0, 1);
+  }
 
-    switch (opcode) {
-        case Instruction::NOP:
-            break;
+  switch (opcode) {
+    case Instruction::NOP:
+      break;
 
-        case Instruction::MOVE_EXCEPTION: {
-            int exOffset = Thread::ExceptionOffset().Int32Value();
-            rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+    case Instruction::MOVE_EXCEPTION: {
+      int exOffset = Thread::ExceptionOffset().Int32Value();
+      rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
 #if defined(TARGET_X86)
-            newLIR2(cUnit, kX86Mov32RT, rlResult.lowReg, exOffset);
-            newLIR2(cUnit, kX86Mov32TI, exOffset, 0);
+      newLIR2(cUnit, kX86Mov32RT, rlResult.lowReg, exOffset);
+      newLIR2(cUnit, kX86Mov32TI, exOffset, 0);
 #else
-            int resetReg = oatAllocTemp(cUnit);
-            loadWordDisp(cUnit, rSELF, exOffset, rlResult.lowReg);
-            loadConstant(cUnit, resetReg, 0);
-            storeWordDisp(cUnit, rSELF, exOffset, resetReg);
-            storeValue(cUnit, rlDest, rlResult);
-            oatFreeTemp(cUnit, resetReg);
+      int resetReg = oatAllocTemp(cUnit);
+      loadWordDisp(cUnit, rSELF, exOffset, rlResult.lowReg);
+      loadConstant(cUnit, resetReg, 0);
+      storeWordDisp(cUnit, rSELF, exOffset, resetReg);
+      storeValue(cUnit, rlDest, rlResult);
+      oatFreeTemp(cUnit, resetReg);
 #endif
-            break;
-        }
-        case Instruction::RETURN_VOID:
-            if (!cUnit->attrs & METHOD_IS_LEAF) {
-                genSuspendTest(cUnit, mir);
-            }
-            break;
-
-        case Instruction::RETURN:
-        case Instruction::RETURN_OBJECT:
-            if (!cUnit->attrs & METHOD_IS_LEAF) {
-                genSuspendTest(cUnit, mir);
-            }
-            storeValue(cUnit, oatGetReturn(cUnit, cUnit->shorty[0] == 'F'),
-                       rlSrc[0]);
-            break;
-
-        case Instruction::RETURN_WIDE:
-            if (!cUnit->attrs & METHOD_IS_LEAF) {
-                genSuspendTest(cUnit, mir);
-            }
-            storeValueWide(cUnit, oatGetReturnWide(cUnit,
-                                           cUnit->shorty[0] == 'D'), rlSrc[0]);
-            break;
-
-        case Instruction::MOVE_RESULT_WIDE:
-            if (mir->optimizationFlags & MIR_INLINED)
-                break;  // Nop - combined w/ previous invoke
-            storeValueWide(cUnit, rlDest, oatGetReturnWide(cUnit, rlDest.fp));
-            break;
-
-        case Instruction::MOVE_RESULT:
-        case Instruction::MOVE_RESULT_OBJECT:
-            if (mir->optimizationFlags & MIR_INLINED)
-                break;  // Nop - combined w/ previous invoke
-            storeValue(cUnit, rlDest, oatGetReturn(cUnit, rlDest.fp));
-            break;
-
-        case Instruction::MOVE:
-        case Instruction::MOVE_OBJECT:
-        case Instruction::MOVE_16:
-        case Instruction::MOVE_OBJECT_16:
-        case Instruction::MOVE_FROM16:
-        case Instruction::MOVE_OBJECT_FROM16:
-            storeValue(cUnit, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::MOVE_WIDE:
-        case Instruction::MOVE_WIDE_16:
-        case Instruction::MOVE_WIDE_FROM16:
-            storeValueWide(cUnit, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::CONST:
-        case Instruction::CONST_4:
-        case Instruction::CONST_16:
-            rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-            loadConstantNoClobber(cUnit, rlResult.lowReg, mir->dalvikInsn.vB);
-            storeValue(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::CONST_HIGH16:
-            rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-            loadConstantNoClobber(cUnit, rlResult.lowReg,
-                                  mir->dalvikInsn.vB << 16);
-            storeValue(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::CONST_WIDE_16:
-        case Instruction::CONST_WIDE_32:
-            rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-            loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
-                                  mir->dalvikInsn.vB,
-                                  (mir->dalvikInsn.vB & 0x80000000) ? -1 : 0);
-            storeValueWide(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::CONST_WIDE:
-            rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-            loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
-                          mir->dalvikInsn.vB_wide & 0xffffffff,
-                          (mir->dalvikInsn.vB_wide >> 32) & 0xffffffff);
-            storeValueWide(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::CONST_WIDE_HIGH16:
-            rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-            loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
-                                  0, mir->dalvikInsn.vB << 16);
-            storeValueWide(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::MONITOR_ENTER:
-            genMonitorEnter(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::MONITOR_EXIT:
-            genMonitorExit(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::CHECK_CAST:
-            genCheckCast(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::INSTANCE_OF:
-            genInstanceof(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::NEW_INSTANCE:
-            genNewInstance(cUnit, mir, rlDest);
-            break;
-
-        case Instruction::THROW:
-            genThrow(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::THROW_VERIFICATION_ERROR:
-            genThrowVerificationError(cUnit, mir);
-            break;
-
-        case Instruction::ARRAY_LENGTH:
-            int lenOffset;
-            lenOffset = Array::LengthOffset().Int32Value();
-            rlSrc[0] = loadValue(cUnit, rlSrc[0], kCoreReg);
-            genNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg, mir);
-            rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
-            loadWordDisp(cUnit, rlSrc[0].lowReg, lenOffset,
-                         rlResult.lowReg);
-            storeValue(cUnit, rlDest, rlResult);
-            break;
-
-        case Instruction::CONST_STRING:
-        case Instruction::CONST_STRING_JUMBO:
-            genConstString(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::CONST_CLASS:
-            genConstClass(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::FILL_ARRAY_DATA:
-            genFillArrayData(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::FILLED_NEW_ARRAY:
-            genFilledNewArray(cUnit, mir, false /* not range */);
-            break;
-
-        case Instruction::FILLED_NEW_ARRAY_RANGE:
-            genFilledNewArray(cUnit, mir, true /* range */);
-            break;
-
-        case Instruction::NEW_ARRAY:
-            genNewArray(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::GOTO:
-        case Instruction::GOTO_16:
-        case Instruction::GOTO_32:
-            if (bb->taken->startOffset <= mir->offset) {
-                genSuspendTestAndBranch(cUnit, mir, &labelList[bb->taken->id]);
-            } else {
-                opUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
-            }
-            break;
-
-        case Instruction::PACKED_SWITCH:
-            genPackedSwitch(cUnit, mir, rlSrc[0]);
-            break;
-
-        case Instruction::SPARSE_SWITCH:
-            genSparseSwitch(cUnit, mir, rlSrc[0], labelList);
-            break;
-
-        case Instruction::CMPL_FLOAT:
-        case Instruction::CMPG_FLOAT:
-        case Instruction::CMPL_DOUBLE:
-        case Instruction::CMPG_DOUBLE:
-            res = genCmpFP(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::CMP_LONG:
-            genCmpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::IF_EQ:
-        case Instruction::IF_NE:
-        case Instruction::IF_LT:
-        case Instruction::IF_GE:
-        case Instruction::IF_GT:
-        case Instruction::IF_LE: {
-            bool backwardBranch;
-            backwardBranch = (bb->taken->startOffset <= mir->offset);
-            if (backwardBranch) {
-                genSuspendTest(cUnit, mir);
-            }
-            genCompareAndBranch(cUnit, bb, mir, rlSrc[0], rlSrc[1], labelList);
-            break;
-            }
-
-        case Instruction::IF_EQZ:
-        case Instruction::IF_NEZ:
-        case Instruction::IF_LTZ:
-        case Instruction::IF_GEZ:
-        case Instruction::IF_GTZ:
-        case Instruction::IF_LEZ: {
-            bool backwardBranch;
-            backwardBranch = (bb->taken->startOffset <= mir->offset);
-            if (backwardBranch) {
-                genSuspendTest(cUnit, mir);
-            }
-            genCompareZeroAndBranch(cUnit, bb, mir, rlSrc[0], labelList);
-            break;
-            }
-
-      case Instruction::AGET_WIDE:
-            genArrayGet(cUnit, mir, kLong, rlSrc[0], rlSrc[1], rlDest, 3);
-            break;
-        case Instruction::AGET:
-        case Instruction::AGET_OBJECT:
-            genArrayGet(cUnit, mir, kWord, rlSrc[0], rlSrc[1], rlDest, 2);
-            break;
-        case Instruction::AGET_BOOLEAN:
-            genArrayGet(cUnit, mir, kUnsignedByte, rlSrc[0], rlSrc[1],
-                        rlDest, 0);
-            break;
-        case Instruction::AGET_BYTE:
-            genArrayGet(cUnit, mir, kSignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
-            break;
-        case Instruction::AGET_CHAR:
-            genArrayGet(cUnit, mir, kUnsignedHalf, rlSrc[0], rlSrc[1],
-                        rlDest, 1);
-            break;
-        case Instruction::AGET_SHORT:
-            genArrayGet(cUnit, mir, kSignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
-            break;
-        case Instruction::APUT_WIDE:
-            genArrayPut(cUnit, mir, kLong, rlSrc[1], rlSrc[2], rlSrc[0], 3);
-            break;
-        case Instruction::APUT:
-            genArrayPut(cUnit, mir, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
-            break;
-        case Instruction::APUT_OBJECT:
-            genArrayObjPut(cUnit, mir, rlSrc[1], rlSrc[2], rlSrc[0], 2);
-            break;
-        case Instruction::APUT_SHORT:
-        case Instruction::APUT_CHAR:
-            genArrayPut(cUnit, mir, kUnsignedHalf, rlSrc[1], rlSrc[2],
-                        rlSrc[0], 1);
-            break;
-        case Instruction::APUT_BYTE:
-        case Instruction::APUT_BOOLEAN:
-            genArrayPut(cUnit, mir, kUnsignedByte, rlSrc[1], rlSrc[2],
-                        rlSrc[0], 0);
-            break;
-
-        case Instruction::IGET_OBJECT:
-        //case Instruction::IGET_OBJECT_VOLATILE:
-            genIGet(cUnit, mir, kWord, rlDest, rlSrc[0], false, true);
-            break;
-
-        case Instruction::IGET_WIDE:
-        //case Instruction::IGET_WIDE_VOLATILE:
-            genIGet(cUnit, mir, kLong, rlDest, rlSrc[0], true, false);
-            break;
-
-        case Instruction::IGET:
-        //case Instruction::IGET_VOLATILE:
-            genIGet(cUnit, mir, kWord, rlDest, rlSrc[0], false, false);
-            break;
-
-        case Instruction::IGET_CHAR:
-            genIGet(cUnit, mir, kUnsignedHalf, rlDest, rlSrc[0], false, false);
-            break;
-
-        case Instruction::IGET_SHORT:
-            genIGet(cUnit, mir, kSignedHalf, rlDest, rlSrc[0], false, false);
-            break;
-
-        case Instruction::IGET_BOOLEAN:
-        case Instruction::IGET_BYTE:
-            genIGet(cUnit, mir, kUnsignedByte, rlDest, rlSrc[0], false, false);
-            break;
-
-        case Instruction::IPUT_WIDE:
-        //case Instruction::IPUT_WIDE_VOLATILE:
-            genIPut(cUnit, mir, kLong, rlSrc[0], rlSrc[1], true, false);
-            break;
-
-        case Instruction::IPUT_OBJECT:
-        //case Instruction::IPUT_OBJECT_VOLATILE:
-            genIPut(cUnit, mir, kWord, rlSrc[0], rlSrc[1], false, true);
-            break;
-
-        case Instruction::IPUT:
-        //case Instruction::IPUT_VOLATILE:
-            genIPut(cUnit, mir, kWord, rlSrc[0], rlSrc[1], false, false);
-            break;
-
-        case Instruction::IPUT_BOOLEAN:
-        case Instruction::IPUT_BYTE:
-            genIPut(cUnit, mir, kUnsignedByte, rlSrc[0], rlSrc[1], false, false);
-            break;
-
-        case Instruction::IPUT_CHAR:
-            genIPut(cUnit, mir, kUnsignedHalf, rlSrc[0], rlSrc[1], false, false);
-            break;
-
-        case Instruction::IPUT_SHORT:
-            genIPut(cUnit, mir, kSignedHalf, rlSrc[0], rlSrc[1], false, false);
-            break;
-
-        case Instruction::SGET_OBJECT:
-            genSget(cUnit, mir, rlDest, false, true);
-            break;
-        case Instruction::SGET:
-        case Instruction::SGET_BOOLEAN:
-        case Instruction::SGET_BYTE:
-        case Instruction::SGET_CHAR:
-        case Instruction::SGET_SHORT:
-            genSget(cUnit, mir, rlDest, false, false);
-            break;
-
-        case Instruction::SGET_WIDE:
-            genSget(cUnit, mir, rlDest, true, false);
-            break;
-
-        case Instruction::SPUT_OBJECT:
-            genSput(cUnit, mir, rlSrc[0], false, true);
-            break;
-
-        case Instruction::SPUT:
-        case Instruction::SPUT_BOOLEAN:
-        case Instruction::SPUT_BYTE:
-        case Instruction::SPUT_CHAR:
-        case Instruction::SPUT_SHORT:
-            genSput(cUnit, mir, rlSrc[0], false, false);
-            break;
-
-        case Instruction::SPUT_WIDE:
-            genSput(cUnit, mir, rlSrc[0], true, false);
-            break;
-
-        case Instruction::INVOKE_STATIC_RANGE:
-            genInvoke(cUnit, bb, mir, kStatic, true /*range*/);
-            break;
-        case Instruction::INVOKE_STATIC:
-            genInvoke(cUnit, bb, mir, kStatic, false /*range*/);
-            break;
-
-        case Instruction::INVOKE_DIRECT:
-            genInvoke(cUnit, bb,  mir, kDirect, false /*range*/);
-            break;
-        case Instruction::INVOKE_DIRECT_RANGE:
-            genInvoke(cUnit, bb, mir, kDirect, true /*range*/);
-            break;
-
-        case Instruction::INVOKE_VIRTUAL:
-            genInvoke(cUnit, bb, mir, kVirtual, false /*range*/);
-            break;
-        case Instruction::INVOKE_VIRTUAL_RANGE:
-            genInvoke(cUnit, bb, mir, kVirtual, true /*range*/);
-            break;
-
-        case Instruction::INVOKE_SUPER:
-            genInvoke(cUnit, bb, mir, kSuper, false /*range*/);
-            break;
-        case Instruction::INVOKE_SUPER_RANGE:
-            genInvoke(cUnit, bb, mir, kSuper, true /*range*/);
-            break;
-
-        case Instruction::INVOKE_INTERFACE:
-            genInvoke(cUnit, bb, mir, kInterface, false /*range*/);
-            break;
-        case Instruction::INVOKE_INTERFACE_RANGE:
-            genInvoke(cUnit, bb, mir, kInterface, true /*range*/);
-            break;
-
-        case Instruction::NEG_INT:
-        case Instruction::NOT_INT:
-            res = genArithOpInt(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
-            break;
-
-        case Instruction::NEG_LONG:
-        case Instruction::NOT_LONG:
-            res = genArithOpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
-            break;
-
-        case Instruction::NEG_FLOAT:
-            res = genArithOpFloat(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
-            break;
-
-        case Instruction::NEG_DOUBLE:
-            res = genArithOpDouble(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
-            break;
-
-        case Instruction::INT_TO_LONG:
-            genIntToLong(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::LONG_TO_INT:
-            rlSrc[0] = oatUpdateLocWide(cUnit, rlSrc[0]);
-            rlSrc[0] = oatWideToNarrow(cUnit, rlSrc[0]);
-            storeValue(cUnit, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::INT_TO_BYTE:
-        case Instruction::INT_TO_SHORT:
-        case Instruction::INT_TO_CHAR:
-            genIntNarrowing(cUnit, mir, rlDest, rlSrc[0]);
-            break;
-
-        case Instruction::INT_TO_FLOAT:
-        case Instruction::INT_TO_DOUBLE:
-        case Instruction::LONG_TO_FLOAT:
-        case Instruction::LONG_TO_DOUBLE:
-        case Instruction::FLOAT_TO_INT:
-        case Instruction::FLOAT_TO_LONG:
-        case Instruction::FLOAT_TO_DOUBLE:
-        case Instruction::DOUBLE_TO_INT:
-        case Instruction::DOUBLE_TO_LONG:
-        case Instruction::DOUBLE_TO_FLOAT:
-            genConversion(cUnit, mir);
-            break;
-
-        case Instruction::ADD_INT:
-        case Instruction::SUB_INT:
-        case Instruction::MUL_INT:
-        case Instruction::DIV_INT:
-        case Instruction::REM_INT:
-        case Instruction::AND_INT:
-        case Instruction::OR_INT:
-        case Instruction::XOR_INT:
-        case Instruction::SHL_INT:
-        case Instruction::SHR_INT:
-        case Instruction::USHR_INT:
-        case Instruction::ADD_INT_2ADDR:
-        case Instruction::SUB_INT_2ADDR:
-        case Instruction::MUL_INT_2ADDR:
-        case Instruction::DIV_INT_2ADDR:
-        case Instruction::REM_INT_2ADDR:
-        case Instruction::AND_INT_2ADDR:
-        case Instruction::OR_INT_2ADDR:
-        case Instruction::XOR_INT_2ADDR:
-        case Instruction::SHL_INT_2ADDR:
-        case Instruction::SHR_INT_2ADDR:
-        case Instruction::USHR_INT_2ADDR:
-            genArithOpInt(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::ADD_LONG:
-        case Instruction::SUB_LONG:
-        case Instruction::MUL_LONG:
-        case Instruction::DIV_LONG:
-        case Instruction::REM_LONG:
-        case Instruction::AND_LONG:
-        case Instruction::OR_LONG:
-        case Instruction::XOR_LONG:
-        case Instruction::ADD_LONG_2ADDR:
-        case Instruction::SUB_LONG_2ADDR:
-        case Instruction::MUL_LONG_2ADDR:
-        case Instruction::DIV_LONG_2ADDR:
-        case Instruction::REM_LONG_2ADDR:
-        case Instruction::AND_LONG_2ADDR:
-        case Instruction::OR_LONG_2ADDR:
-        case Instruction::XOR_LONG_2ADDR:
-            genArithOpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::SHL_LONG:
-        case Instruction::SHR_LONG:
-        case Instruction::USHR_LONG:
-        case Instruction::SHL_LONG_2ADDR:
-        case Instruction::SHR_LONG_2ADDR:
-        case Instruction::USHR_LONG_2ADDR:
-            genShiftOpLong(cUnit,mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::ADD_FLOAT:
-        case Instruction::SUB_FLOAT:
-        case Instruction::MUL_FLOAT:
-        case Instruction::DIV_FLOAT:
-        case Instruction::REM_FLOAT:
-        case Instruction::ADD_FLOAT_2ADDR:
-        case Instruction::SUB_FLOAT_2ADDR:
-        case Instruction::MUL_FLOAT_2ADDR:
-        case Instruction::DIV_FLOAT_2ADDR:
-        case Instruction::REM_FLOAT_2ADDR:
-            genArithOpFloat(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::ADD_DOUBLE:
-        case Instruction::SUB_DOUBLE:
-        case Instruction::MUL_DOUBLE:
-        case Instruction::DIV_DOUBLE:
-        case Instruction::REM_DOUBLE:
-        case Instruction::ADD_DOUBLE_2ADDR:
-        case Instruction::SUB_DOUBLE_2ADDR:
-        case Instruction::MUL_DOUBLE_2ADDR:
-        case Instruction::DIV_DOUBLE_2ADDR:
-        case Instruction::REM_DOUBLE_2ADDR:
-            genArithOpDouble(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
-            break;
-
-        case Instruction::RSUB_INT:
-        case Instruction::ADD_INT_LIT16:
-        case Instruction::MUL_INT_LIT16:
-        case Instruction::DIV_INT_LIT16:
-        case Instruction::REM_INT_LIT16:
-        case Instruction::AND_INT_LIT16:
-        case Instruction::OR_INT_LIT16:
-        case Instruction::XOR_INT_LIT16:
-        case Instruction::ADD_INT_LIT8:
-        case Instruction::RSUB_INT_LIT8:
-        case Instruction::MUL_INT_LIT8:
-        case Instruction::DIV_INT_LIT8:
-        case Instruction::REM_INT_LIT8:
-        case Instruction::AND_INT_LIT8:
-        case Instruction::OR_INT_LIT8:
-        case Instruction::XOR_INT_LIT8:
-        case Instruction::SHL_INT_LIT8:
-        case Instruction::SHR_INT_LIT8:
-        case Instruction::USHR_INT_LIT8:
-            genArithOpIntLit(cUnit, mir, rlDest, rlSrc[0], mir->dalvikInsn.vC);
-            break;
-
-        default:
-            res = true;
+      break;
     }
-    return res;
+    case Instruction::RETURN_VOID:
+      if (!cUnit->attrs & METHOD_IS_LEAF) {
+        genSuspendTest(cUnit, mir);
+      }
+      break;
+
+    case Instruction::RETURN:
+    case Instruction::RETURN_OBJECT:
+      if (!cUnit->attrs & METHOD_IS_LEAF) {
+        genSuspendTest(cUnit, mir);
+      }
+      storeValue(cUnit, oatGetReturn(cUnit, cUnit->shorty[0] == 'F'), rlSrc[0]);
+      break;
+
+    case Instruction::RETURN_WIDE:
+      if (!cUnit->attrs & METHOD_IS_LEAF) {
+        genSuspendTest(cUnit, mir);
+      }
+      storeValueWide(cUnit, oatGetReturnWide(cUnit,
+                       cUnit->shorty[0] == 'D'), rlSrc[0]);
+      break;
+
+    case Instruction::MOVE_RESULT_WIDE:
+      if (mir->optimizationFlags & MIR_INLINED)
+        break;  // Nop - combined w/ previous invoke
+      storeValueWide(cUnit, rlDest, oatGetReturnWide(cUnit, rlDest.fp));
+      break;
+
+    case Instruction::MOVE_RESULT:
+    case Instruction::MOVE_RESULT_OBJECT:
+      if (mir->optimizationFlags & MIR_INLINED)
+        break;  // Nop - combined w/ previous invoke
+      storeValue(cUnit, rlDest, oatGetReturn(cUnit, rlDest.fp));
+      break;
+
+    case Instruction::MOVE:
+    case Instruction::MOVE_OBJECT:
+    case Instruction::MOVE_16:
+    case Instruction::MOVE_OBJECT_16:
+    case Instruction::MOVE_FROM16:
+    case Instruction::MOVE_OBJECT_FROM16:
+      storeValue(cUnit, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::MOVE_WIDE:
+    case Instruction::MOVE_WIDE_16:
+    case Instruction::MOVE_WIDE_FROM16:
+      storeValueWide(cUnit, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::CONST:
+    case Instruction::CONST_4:
+    case Instruction::CONST_16:
+      rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+      loadConstantNoClobber(cUnit, rlResult.lowReg, mir->dalvikInsn.vB);
+      storeValue(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::CONST_HIGH16:
+      rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+      loadConstantNoClobber(cUnit, rlResult.lowReg, mir->dalvikInsn.vB << 16);
+      storeValue(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::CONST_WIDE_16:
+    case Instruction::CONST_WIDE_32:
+      rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+      loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+                            mir->dalvikInsn.vB,
+                            (mir->dalvikInsn.vB & 0x80000000) ? -1 : 0);
+      storeValueWide(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::CONST_WIDE:
+      rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+      loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+                            mir->dalvikInsn.vB_wide & 0xffffffff,
+                            (mir->dalvikInsn.vB_wide >> 32) & 0xffffffff);
+      storeValueWide(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::CONST_WIDE_HIGH16:
+      rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+      loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+                            0, mir->dalvikInsn.vB << 16);
+      storeValueWide(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::MONITOR_ENTER:
+      genMonitorEnter(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::MONITOR_EXIT:
+      genMonitorExit(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::CHECK_CAST:
+      genCheckCast(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::INSTANCE_OF:
+      genInstanceof(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::NEW_INSTANCE:
+      genNewInstance(cUnit, mir, rlDest);
+      break;
+
+    case Instruction::THROW:
+      genThrow(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::THROW_VERIFICATION_ERROR:
+      genThrowVerificationError(cUnit, mir);
+      break;
+
+    case Instruction::ARRAY_LENGTH:
+      int lenOffset;
+      lenOffset = Array::LengthOffset().Int32Value();
+      rlSrc[0] = loadValue(cUnit, rlSrc[0], kCoreReg);
+      genNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg, mir);
+      rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+      loadWordDisp(cUnit, rlSrc[0].lowReg, lenOffset, rlResult.lowReg);
+      storeValue(cUnit, rlDest, rlResult);
+      break;
+
+    case Instruction::CONST_STRING:
+    case Instruction::CONST_STRING_JUMBO:
+      genConstString(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::CONST_CLASS:
+      genConstClass(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::FILL_ARRAY_DATA:
+      genFillArrayData(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::FILLED_NEW_ARRAY:
+      genFilledNewArray(cUnit, mir, false /* not range */);
+      break;
+
+    case Instruction::FILLED_NEW_ARRAY_RANGE:
+      genFilledNewArray(cUnit, mir, true /* range */);
+      break;
+
+    case Instruction::NEW_ARRAY:
+      genNewArray(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::GOTO:
+    case Instruction::GOTO_16:
+    case Instruction::GOTO_32:
+      if (bb->taken->startOffset <= mir->offset) {
+        genSuspendTestAndBranch(cUnit, mir, &labelList[bb->taken->id]);
+      } else {
+        opUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
+      }
+      break;
+
+    case Instruction::PACKED_SWITCH:
+      genPackedSwitch(cUnit, mir, rlSrc[0]);
+      break;
+
+    case Instruction::SPARSE_SWITCH:
+      genSparseSwitch(cUnit, mir, rlSrc[0], labelList);
+      break;
+
+    case Instruction::CMPL_FLOAT:
+    case Instruction::CMPG_FLOAT:
+    case Instruction::CMPL_DOUBLE:
+    case Instruction::CMPG_DOUBLE:
+      res = genCmpFP(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::CMP_LONG:
+      genCmpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::IF_EQ:
+    case Instruction::IF_NE:
+    case Instruction::IF_LT:
+    case Instruction::IF_GE:
+    case Instruction::IF_GT:
+    case Instruction::IF_LE: {
+      bool backwardBranch;
+      backwardBranch = (bb->taken->startOffset <= mir->offset);
+      if (backwardBranch) {
+        genSuspendTest(cUnit, mir);
+      }
+      genCompareAndBranch(cUnit, bb, mir, rlSrc[0], rlSrc[1], labelList);
+      break;
+      }
+
+    case Instruction::IF_EQZ:
+    case Instruction::IF_NEZ:
+    case Instruction::IF_LTZ:
+    case Instruction::IF_GEZ:
+    case Instruction::IF_GTZ:
+    case Instruction::IF_LEZ: {
+      bool backwardBranch;
+      backwardBranch = (bb->taken->startOffset <= mir->offset);
+      if (backwardBranch) {
+        genSuspendTest(cUnit, mir);
+      }
+      genCompareZeroAndBranch(cUnit, bb, mir, rlSrc[0], labelList);
+      break;
+      }
+
+    case Instruction::AGET_WIDE:
+      genArrayGet(cUnit, mir, kLong, rlSrc[0], rlSrc[1], rlDest, 3);
+      break;
+    case Instruction::AGET:
+    case Instruction::AGET_OBJECT:
+      genArrayGet(cUnit, mir, kWord, rlSrc[0], rlSrc[1], rlDest, 2);
+      break;
+    case Instruction::AGET_BOOLEAN:
+      genArrayGet(cUnit, mir, kUnsignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+      break;
+    case Instruction::AGET_BYTE:
+      genArrayGet(cUnit, mir, kSignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+      break;
+    case Instruction::AGET_CHAR:
+      genArrayGet(cUnit, mir, kUnsignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+      break;
+    case Instruction::AGET_SHORT:
+      genArrayGet(cUnit, mir, kSignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+      break;
+    case Instruction::APUT_WIDE:
+      genArrayPut(cUnit, mir, kLong, rlSrc[1], rlSrc[2], rlSrc[0], 3);
+      break;
+    case Instruction::APUT:
+      genArrayPut(cUnit, mir, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+      break;
+    case Instruction::APUT_OBJECT:
+      genArrayObjPut(cUnit, mir, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+      break;
+    case Instruction::APUT_SHORT:
+    case Instruction::APUT_CHAR:
+      genArrayPut(cUnit, mir, kUnsignedHalf, rlSrc[1], rlSrc[2], rlSrc[0], 1);
+      break;
+    case Instruction::APUT_BYTE:
+    case Instruction::APUT_BOOLEAN:
+      genArrayPut(cUnit, mir, kUnsignedByte, rlSrc[1], rlSrc[2],
+            rlSrc[0], 0);
+      break;
+
+    case Instruction::IGET_OBJECT:
+    //case Instruction::IGET_OBJECT_VOLATILE:
+      genIGet(cUnit, mir, kWord, rlDest, rlSrc[0], false, true);
+      break;
+
+    case Instruction::IGET_WIDE:
+    //case Instruction::IGET_WIDE_VOLATILE:
+      genIGet(cUnit, mir, kLong, rlDest, rlSrc[0], true, false);
+      break;
+
+    case Instruction::IGET:
+    //case Instruction::IGET_VOLATILE:
+      genIGet(cUnit, mir, kWord, rlDest, rlSrc[0], false, false);
+      break;
+
+    case Instruction::IGET_CHAR:
+      genIGet(cUnit, mir, kUnsignedHalf, rlDest, rlSrc[0], false, false);
+      break;
+
+    case Instruction::IGET_SHORT:
+      genIGet(cUnit, mir, kSignedHalf, rlDest, rlSrc[0], false, false);
+      break;
+
+    case Instruction::IGET_BOOLEAN:
+    case Instruction::IGET_BYTE:
+      genIGet(cUnit, mir, kUnsignedByte, rlDest, rlSrc[0], false, false);
+      break;
+
+    case Instruction::IPUT_WIDE:
+    //case Instruction::IPUT_WIDE_VOLATILE:
+      genIPut(cUnit, mir, kLong, rlSrc[0], rlSrc[1], true, false);
+      break;
+
+    case Instruction::IPUT_OBJECT:
+    //case Instruction::IPUT_OBJECT_VOLATILE:
+      genIPut(cUnit, mir, kWord, rlSrc[0], rlSrc[1], false, true);
+      break;
+
+    case Instruction::IPUT:
+    //case Instruction::IPUT_VOLATILE:
+      genIPut(cUnit, mir, kWord, rlSrc[0], rlSrc[1], false, false);
+      break;
+
+    case Instruction::IPUT_BOOLEAN:
+    case Instruction::IPUT_BYTE:
+      genIPut(cUnit, mir, kUnsignedByte, rlSrc[0], rlSrc[1], false, false);
+      break;
+
+    case Instruction::IPUT_CHAR:
+      genIPut(cUnit, mir, kUnsignedHalf, rlSrc[0], rlSrc[1], false, false);
+      break;
+
+    case Instruction::IPUT_SHORT:
+      genIPut(cUnit, mir, kSignedHalf, rlSrc[0], rlSrc[1], false, false);
+      break;
+
+    case Instruction::SGET_OBJECT:
+      genSget(cUnit, mir, rlDest, false, true);
+      break;
+    case Instruction::SGET:
+    case Instruction::SGET_BOOLEAN:
+    case Instruction::SGET_BYTE:
+    case Instruction::SGET_CHAR:
+    case Instruction::SGET_SHORT:
+      genSget(cUnit, mir, rlDest, false, false);
+      break;
+
+    case Instruction::SGET_WIDE:
+      genSget(cUnit, mir, rlDest, true, false);
+      break;
+
+    case Instruction::SPUT_OBJECT:
+      genSput(cUnit, mir, rlSrc[0], false, true);
+      break;
+
+    case Instruction::SPUT:
+    case Instruction::SPUT_BOOLEAN:
+    case Instruction::SPUT_BYTE:
+    case Instruction::SPUT_CHAR:
+    case Instruction::SPUT_SHORT:
+      genSput(cUnit, mir, rlSrc[0], false, false);
+      break;
+
+    case Instruction::SPUT_WIDE:
+      genSput(cUnit, mir, rlSrc[0], true, false);
+      break;
+
+    case Instruction::INVOKE_STATIC_RANGE:
+      genInvoke(cUnit, bb, mir, kStatic, true /*range*/);
+      break;
+    case Instruction::INVOKE_STATIC:
+      genInvoke(cUnit, bb, mir, kStatic, false /*range*/);
+      break;
+
+    case Instruction::INVOKE_DIRECT:
+      genInvoke(cUnit, bb,  mir, kDirect, false /*range*/);
+      break;
+    case Instruction::INVOKE_DIRECT_RANGE:
+      genInvoke(cUnit, bb, mir, kDirect, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_VIRTUAL:
+      genInvoke(cUnit, bb, mir, kVirtual, false /*range*/);
+      break;
+    case Instruction::INVOKE_VIRTUAL_RANGE:
+      genInvoke(cUnit, bb, mir, kVirtual, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_SUPER:
+      genInvoke(cUnit, bb, mir, kSuper, false /*range*/);
+      break;
+    case Instruction::INVOKE_SUPER_RANGE:
+      genInvoke(cUnit, bb, mir, kSuper, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_INTERFACE:
+      genInvoke(cUnit, bb, mir, kInterface, false /*range*/);
+      break;
+    case Instruction::INVOKE_INTERFACE_RANGE:
+      genInvoke(cUnit, bb, mir, kInterface, true /*range*/);
+      break;
+
+    case Instruction::NEG_INT:
+    case Instruction::NOT_INT:
+      res = genArithOpInt(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
+      break;
+
+    case Instruction::NEG_LONG:
+    case Instruction::NOT_LONG:
+      res = genArithOpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
+      break;
+
+    case Instruction::NEG_FLOAT:
+      res = genArithOpFloat(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
+      break;
+
+    case Instruction::NEG_DOUBLE:
+      res = genArithOpDouble(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
+      break;
+
+    case Instruction::INT_TO_LONG:
+      genIntToLong(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::LONG_TO_INT:
+      rlSrc[0] = oatUpdateLocWide(cUnit, rlSrc[0]);
+      rlSrc[0] = oatWideToNarrow(cUnit, rlSrc[0]);
+      storeValue(cUnit, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::INT_TO_BYTE:
+    case Instruction::INT_TO_SHORT:
+    case Instruction::INT_TO_CHAR:
+      genIntNarrowing(cUnit, mir, rlDest, rlSrc[0]);
+      break;
+
+    case Instruction::INT_TO_FLOAT:
+    case Instruction::INT_TO_DOUBLE:
+    case Instruction::LONG_TO_FLOAT:
+    case Instruction::LONG_TO_DOUBLE:
+    case Instruction::FLOAT_TO_INT:
+    case Instruction::FLOAT_TO_LONG:
+    case Instruction::FLOAT_TO_DOUBLE:
+    case Instruction::DOUBLE_TO_INT:
+    case Instruction::DOUBLE_TO_LONG:
+    case Instruction::DOUBLE_TO_FLOAT:
+      genConversion(cUnit, mir);
+      break;
+
+    case Instruction::ADD_INT:
+    case Instruction::SUB_INT:
+    case Instruction::MUL_INT:
+    case Instruction::DIV_INT:
+    case Instruction::REM_INT:
+    case Instruction::AND_INT:
+    case Instruction::OR_INT:
+    case Instruction::XOR_INT:
+    case Instruction::SHL_INT:
+    case Instruction::SHR_INT:
+    case Instruction::USHR_INT:
+    case Instruction::ADD_INT_2ADDR:
+    case Instruction::SUB_INT_2ADDR:
+    case Instruction::MUL_INT_2ADDR:
+    case Instruction::DIV_INT_2ADDR:
+    case Instruction::REM_INT_2ADDR:
+    case Instruction::AND_INT_2ADDR:
+    case Instruction::OR_INT_2ADDR:
+    case Instruction::XOR_INT_2ADDR:
+    case Instruction::SHL_INT_2ADDR:
+    case Instruction::SHR_INT_2ADDR:
+    case Instruction::USHR_INT_2ADDR:
+      genArithOpInt(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::ADD_LONG:
+    case Instruction::SUB_LONG:
+    case Instruction::MUL_LONG:
+    case Instruction::DIV_LONG:
+    case Instruction::REM_LONG:
+    case Instruction::AND_LONG:
+    case Instruction::OR_LONG:
+    case Instruction::XOR_LONG:
+    case Instruction::ADD_LONG_2ADDR:
+    case Instruction::SUB_LONG_2ADDR:
+    case Instruction::MUL_LONG_2ADDR:
+    case Instruction::DIV_LONG_2ADDR:
+    case Instruction::REM_LONG_2ADDR:
+    case Instruction::AND_LONG_2ADDR:
+    case Instruction::OR_LONG_2ADDR:
+    case Instruction::XOR_LONG_2ADDR:
+      genArithOpLong(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::SHL_LONG:
+    case Instruction::SHR_LONG:
+    case Instruction::USHR_LONG:
+    case Instruction::SHL_LONG_2ADDR:
+    case Instruction::SHR_LONG_2ADDR:
+    case Instruction::USHR_LONG_2ADDR:
+      genShiftOpLong(cUnit,mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::ADD_FLOAT:
+    case Instruction::SUB_FLOAT:
+    case Instruction::MUL_FLOAT:
+    case Instruction::DIV_FLOAT:
+    case Instruction::REM_FLOAT:
+    case Instruction::ADD_FLOAT_2ADDR:
+    case Instruction::SUB_FLOAT_2ADDR:
+    case Instruction::MUL_FLOAT_2ADDR:
+    case Instruction::DIV_FLOAT_2ADDR:
+    case Instruction::REM_FLOAT_2ADDR:
+      genArithOpFloat(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::ADD_DOUBLE:
+    case Instruction::SUB_DOUBLE:
+    case Instruction::MUL_DOUBLE:
+    case Instruction::DIV_DOUBLE:
+    case Instruction::REM_DOUBLE:
+    case Instruction::ADD_DOUBLE_2ADDR:
+    case Instruction::SUB_DOUBLE_2ADDR:
+    case Instruction::MUL_DOUBLE_2ADDR:
+    case Instruction::DIV_DOUBLE_2ADDR:
+    case Instruction::REM_DOUBLE_2ADDR:
+      genArithOpDouble(cUnit, mir, rlDest, rlSrc[0], rlSrc[1]);
+      break;
+
+    case Instruction::RSUB_INT:
+    case Instruction::ADD_INT_LIT16:
+    case Instruction::MUL_INT_LIT16:
+    case Instruction::DIV_INT_LIT16:
+    case Instruction::REM_INT_LIT16:
+    case Instruction::AND_INT_LIT16:
+    case Instruction::OR_INT_LIT16:
+    case Instruction::XOR_INT_LIT16:
+    case Instruction::ADD_INT_LIT8:
+    case Instruction::RSUB_INT_LIT8:
+    case Instruction::MUL_INT_LIT8:
+    case Instruction::DIV_INT_LIT8:
+    case Instruction::REM_INT_LIT8:
+    case Instruction::AND_INT_LIT8:
+    case Instruction::OR_INT_LIT8:
+    case Instruction::XOR_INT_LIT8:
+    case Instruction::SHL_INT_LIT8:
+    case Instruction::SHR_INT_LIT8:
+    case Instruction::USHR_INT_LIT8:
+      genArithOpIntLit(cUnit, mir, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      break;
+
+    default:
+      res = true;
+  }
+  return res;
 }
 
 const char* extendedMIROpNames[kMirOpLast - kMirOpFirst] = {
-    "kMirOpPhi",
-    "kMirOpCopy",
-    "kMirFusedCmplFloat",
-    "kMirFusedCmpgFloat",
-    "kMirFusedCmplDouble",
-    "kMirFusedCmpgDouble",
-    "kMirFusedCmpLong",
-    "kMirNop",
-    "kMirOpNullNRangeUpCheck",
-    "kMirOpNullNRangeDownCheck",
-    "kMirOpLowerBound",
+  "kMirOpPhi",
+  "kMirOpCopy",
+  "kMirFusedCmplFloat",
+  "kMirFusedCmpgFloat",
+  "kMirFusedCmplDouble",
+  "kMirFusedCmpgDouble",
+  "kMirFusedCmpLong",
+  "kMirNop",
+  "kMirOpNullNRangeUpCheck",
+  "kMirOpNullNRangeDownCheck",
+  "kMirOpLowerBound",
 };
 
 /* Extended MIR instructions like PHI */
 void handleExtendedMethodMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
 {
-    int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
-    char* msg = NULL;
-    if (cUnit->printMe) {
-        msg = (char*)oatNew(cUnit, strlen(extendedMIROpNames[opOffset]) + 1,
-                            false, kAllocDebugInfo);
-        strcpy(msg, extendedMIROpNames[opOffset]);
-    }
-    LIR* op = newLIR1(cUnit, kPseudoExtended, (int) msg);
+  int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
+  char* msg = NULL;
+  if (cUnit->printMe) {
+    msg = (char*)oatNew(cUnit, strlen(extendedMIROpNames[opOffset]) + 1,
+                        false, kAllocDebugInfo);
+    strcpy(msg, extendedMIROpNames[opOffset]);
+  }
+  LIR* op = newLIR1(cUnit, kPseudoExtended, (int) msg);
 
-    switch ((ExtendedMIROpcode)mir->dalvikInsn.opcode) {
-        case kMirOpPhi: {
-            char* ssaString = NULL;
-            if (cUnit->printMe) {
-                ssaString = oatGetSSAString(cUnit, mir->ssaRep);
-            }
-            op->flags.isNop = true;
-            newLIR1(cUnit, kPseudoSSARep, (int) ssaString);
-            break;
-        }
-        case kMirOpCopy: {
-            RegLocation rlSrc = oatGetSrc(cUnit, mir, 0);
-            RegLocation rlDest = oatGetDest(cUnit, mir, 0);
-            storeValue(cUnit, rlDest, rlSrc);
-            break;
-        }
-#if defined(TARGET_ARM)
-        case kMirOpFusedCmplFloat:
-            genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, false /*double*/);
-            break;
-        case kMirOpFusedCmpgFloat:
-            genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, false /*double*/);
-            break;
-        case kMirOpFusedCmplDouble:
-            genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, true /*double*/);
-            break;
-        case kMirOpFusedCmpgDouble:
-            genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, true /*double*/);
-            break;
-        case kMirOpFusedCmpLong:
-            genFusedLongCmpBranch(cUnit, bb, mir);
-            break;
-#endif
-        default:
-            break;
+  switch ((ExtendedMIROpcode)mir->dalvikInsn.opcode) {
+    case kMirOpPhi: {
+      char* ssaString = NULL;
+      if (cUnit->printMe) {
+        ssaString = oatGetSSAString(cUnit, mir->ssaRep);
+      }
+      op->flags.isNop = true;
+      newLIR1(cUnit, kPseudoSSARep, (int) ssaString);
+      break;
     }
+    case kMirOpCopy: {
+      RegLocation rlSrc = oatGetSrc(cUnit, mir, 0);
+      RegLocation rlDest = oatGetDest(cUnit, mir, 0);
+      storeValue(cUnit, rlDest, rlSrc);
+      break;
+    }
+#if defined(TARGET_ARM)
+    case kMirOpFusedCmplFloat:
+      genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, false /*double*/);
+      break;
+    case kMirOpFusedCmpgFloat:
+      genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, false /*double*/);
+      break;
+    case kMirOpFusedCmplDouble:
+      genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, true /*double*/);
+      break;
+    case kMirOpFusedCmpgDouble:
+      genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, true /*double*/);
+      break;
+    case kMirOpFusedCmpLong:
+      genFusedLongCmpBranch(cUnit, bb, mir);
+      break;
+#endif
+    default:
+      break;
+  }
 }
 
 /* Handle the content in each basic block */
 bool methodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    MIR* mir;
-    LIR* labelList = (LIR*) cUnit->blockLabelList;
-    int blockId = bb->id;
+  MIR* mir;
+  LIR* labelList = (LIR*) cUnit->blockLabelList;
+  int blockId = bb->id;
 
-    cUnit->curBlock = bb;
-    labelList[blockId].operands[0] = bb->startOffset;
+  cUnit->curBlock = bb;
+  labelList[blockId].operands[0] = bb->startOffset;
 
-    /* Insert the block label */
-    labelList[blockId].opcode = kPseudoNormalBlockLabel;
-    oatAppendLIR(cUnit, (LIR*) &labelList[blockId]);
+  /* Insert the block label */
+  labelList[blockId].opcode = kPseudoNormalBlockLabel;
+  oatAppendLIR(cUnit, (LIR*) &labelList[blockId]);
 
-    /* Free temp registers and reset redundant store tracking */
+  /* Free temp registers and reset redundant store tracking */
+  oatResetRegPool(cUnit);
+  oatResetDefTracking(cUnit);
+
+  /*
+   * If control reached us from our immediate predecessor via
+   * fallthrough and we have no other incoming arcs we can
+   * reuse existing liveness.  Otherwise, reset.
+   */
+  if (!bb->fallThroughTarget || bb->predecessors->numUsed != 1) {
+    oatClobberAllRegs(cUnit);
+  }
+
+  LIR* headLIR = NULL;
+
+  if (bb->blockType == kEntryBlock) {
+    genEntrySequence(cUnit, bb);
+  } else if (bb->blockType == kExitBlock) {
+    genExitSequence(cUnit, bb);
+  }
+
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+
     oatResetRegPool(cUnit);
-    oatResetDefTracking(cUnit);
-
-    /*
-     * If control reached us from our immediate predecessor via
-     * fallthrough and we have no other incoming arcs we can
-     * reuse existing liveness.  Otherwise, reset.
-     */
-    if (!bb->fallThroughTarget || bb->predecessors->numUsed != 1) {
-        oatClobberAllRegs(cUnit);
+    if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
+      oatClobberAllRegs(cUnit);
     }
 
-    LIR* headLIR = NULL;
-
-    if (bb->blockType == kEntryBlock) {
-        genEntrySequence(cUnit, bb);
-    } else if (bb->blockType == kExitBlock) {
-        genExitSequence(cUnit, bb);
+    if (cUnit->disableOpt & (1 << kSuppressLoads)) {
+      oatResetDefTracking(cUnit);
     }
 
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-
-        oatResetRegPool(cUnit);
-        if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
-            oatClobberAllRegs(cUnit);
-        }
-
-        if (cUnit->disableOpt & (1 << kSuppressLoads)) {
-            oatResetDefTracking(cUnit);
-        }
-
 #ifndef NDEBUG
-        /* Reset temp tracking sanity check */
-        cUnit->liveSReg = INVALID_SREG;
+    /* Reset temp tracking sanity check */
+    cUnit->liveSReg = INVALID_SREG;
 #endif
 
-        cUnit->currentDalvikOffset = mir->offset;
+    cUnit->currentDalvikOffset = mir->offset;
 
-        Instruction::Code dalvikOpcode = mir->dalvikInsn.opcode;
-        Instruction::Format dalvikFormat = Instruction::FormatOf(dalvikOpcode);
+    Instruction::Code dalvikOpcode = mir->dalvikInsn.opcode;
+    Instruction::Format dalvikFormat = Instruction::FormatOf(dalvikOpcode);
 
-        LIR* boundaryLIR;
+    LIR* boundaryLIR;
 
-        /* Mark the beginning of a Dalvik instruction for line tracking */
-        char* instStr = cUnit->printMe ?
-           oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
-        boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
-                              (intptr_t) instStr);
-        cUnit->boundaryMap.Overwrite(mir->offset, boundaryLIR);
-        /* Remember the first LIR for this block */
-        if (headLIR == NULL) {
-            headLIR = boundaryLIR;
-            /* Set the first boundaryLIR as a scheduling barrier */
-            headLIR->defMask = ENCODE_ALL;
-        }
-
-        /* If we're compiling for the debugger, generate an update callout */
-        if (cUnit->genDebugger) {
-            genDebuggerUpdate(cUnit, mir->offset);
-        }
-
-        /* Don't generate the SSA annotation unless verbose mode is on */
-        if (cUnit->printMe && mir->ssaRep) {
-            char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);
-            newLIR1(cUnit, kPseudoSSARep, (int) ssaString);
-        }
-
-        if ((int)mir->dalvikInsn.opcode >= (int)kMirOpFirst) {
-            handleExtendedMethodMIR(cUnit, bb, mir);
-            continue;
-        }
-
-        bool notHandled = compileDalvikInstruction(cUnit, mir, bb, labelList);
-        if (notHandled) {
-          LOG(FATAL) << StringPrintf("%#06x: Opcode %#x (%s) / Fmt %d not handled",
-                                     mir->offset, dalvikOpcode, Instruction::Name(dalvikOpcode), dalvikFormat);
-
-        }
+    /* Mark the beginning of a Dalvik instruction for line tracking */
+    char* instStr = cUnit->printMe ?
+       oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
+    boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
+                          (intptr_t) instStr);
+    cUnit->boundaryMap.Overwrite(mir->offset, boundaryLIR);
+    /* Remember the first LIR for this block */
+    if (headLIR == NULL) {
+      headLIR = boundaryLIR;
+      /* Set the first boundaryLIR as a scheduling barrier */
+      headLIR->defMask = ENCODE_ALL;
     }
 
-    if (headLIR) {
-        /*
-         * Eliminate redundant loads/stores and delay stores into later
-         * slots
-         */
-        oatApplyLocalOptimizations(cUnit, (LIR*) headLIR,
-                                           cUnit->lastLIRInsn);
-
-        /*
-         * Generate an unconditional branch to the fallthrough block.
-         */
-        if (bb->fallThrough) {
-            opUnconditionalBranch(cUnit,
-                                  &labelList[bb->fallThrough->id]);
-        }
+    /* If we're compiling for the debugger, generate an update callout */
+    if (cUnit->genDebugger) {
+      genDebuggerUpdate(cUnit, mir->offset);
     }
-    return false;
+
+    /* Don't generate the SSA annotation unless verbose mode is on */
+    if (cUnit->printMe && mir->ssaRep) {
+      char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);
+      newLIR1(cUnit, kPseudoSSARep, (int) ssaString);
+    }
+
+    if ((int)mir->dalvikInsn.opcode >= (int)kMirOpFirst) {
+      handleExtendedMethodMIR(cUnit, bb, mir);
+      continue;
+    }
+
+    bool notHandled = compileDalvikInstruction(cUnit, mir, bb, labelList);
+    if (notHandled) {
+      LOG(FATAL) << StringPrintf("%#06x: Opcode %#x (%s) / Fmt %d not handled",
+                                 mir->offset, dalvikOpcode,
+                                 Instruction::Name(dalvikOpcode), dalvikFormat);
+
+    }
+  }
+
+  if (headLIR) {
+    /*
+     * Eliminate redundant loads/stores and delay stores into later
+     * slots
+     */
+    oatApplyLocalOptimizations(cUnit, (LIR*) headLIR, cUnit->lastLIRInsn);
+
+    /*
+     * Generate an unconditional branch to the fallthrough block.
+     */
+    if (bb->fallThrough) {
+      opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+    }
+  }
+  return false;
 }
 
 /* Set basic block labels */
 bool labelBlocks(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    LIR* labelList = (LIR*) cUnit->blockLabelList;
-    int blockId = bb->id;
+  LIR* labelList = (LIR*) cUnit->blockLabelList;
+  int blockId = bb->id;
 
-    cUnit->curBlock = bb;
-    labelList[blockId].operands[0] = bb->startOffset;
+  cUnit->curBlock = bb;
+  labelList[blockId].operands[0] = bb->startOffset;
 
-    /* Insert the block label */
-    labelList[blockId].opcode = kPseudoNormalBlockLabel;
-    return false;
+  /* Insert the block label */
+  labelList[blockId].opcode = kPseudoNormalBlockLabel;
+  return false;
 }
 
 void oatSpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase)
 {
-    /* Find the first DalvikByteCode block */
-    int numReachableBlocks = cUnit->numReachableBlocks;
-    const GrowableList *blockList = &cUnit->blockList;
-    BasicBlock*bb = NULL;
-    for (int idx = 0; idx < numReachableBlocks; idx++) {
-        int dfsIndex = cUnit->dfsOrder.elemList[idx];
-        bb = (BasicBlock*)oatGrowableListGetElement(blockList, dfsIndex);
-        if (bb->blockType == kDalvikByteCode) {
-            break;
-        }
+  /* Find the first DalvikByteCode block */
+  int numReachableBlocks = cUnit->numReachableBlocks;
+  const GrowableList *blockList = &cUnit->blockList;
+  BasicBlock*bb = NULL;
+  for (int idx = 0; idx < numReachableBlocks; idx++) {
+    int dfsIndex = cUnit->dfsOrder.elemList[idx];
+    bb = (BasicBlock*)oatGrowableListGetElement(blockList, dfsIndex);
+    if (bb->blockType == kDalvikByteCode) {
+      break;
     }
-    if (bb == NULL) {
-        return;
-    }
-    DCHECK_EQ(bb->startOffset, 0);
-    DCHECK(bb->firstMIRInsn != 0);
+  }
+  if (bb == NULL) {
+    return;
+  }
+  DCHECK_EQ(bb->startOffset, 0);
+  DCHECK(bb->firstMIRInsn != 0);
 
-    /* Get the first instruction */
-    MIR* mir = bb->firstMIRInsn;
+  /* Get the first instruction */
+  MIR* mir = bb->firstMIRInsn;
 
-    /* Free temp registers and reset redundant store tracking */
-    oatResetRegPool(cUnit);
-    oatResetDefTracking(cUnit);
-    oatClobberAllRegs(cUnit);
+  /* Free temp registers and reset redundant store tracking */
+  oatResetRegPool(cUnit);
+  oatResetDefTracking(cUnit);
+  oatClobberAllRegs(cUnit);
 
-    genSpecialCase(cUnit, bb, mir, specialCase);
+  genSpecialCase(cUnit, bb, mir, specialCase);
 }
 
 void oatMethodMIR2LIR(CompilationUnit* cUnit)
 {
-    /* Used to hold the labels of each block */
-    cUnit->blockLabelList =
-        (void *) oatNew(cUnit, sizeof(LIR) * cUnit->numBlocks, true,
-                        kAllocLIR);
+  /* Used to hold the labels of each block */
+  cUnit->blockLabelList =
+      (void *) oatNew(cUnit, sizeof(LIR) * cUnit->numBlocks, true, kAllocLIR);
 
-    oatDataFlowAnalysisDispatcher(cUnit, methodBlockCodeGen,
-                                  kPreOrderDFSTraversal, false /* Iterative */);
+  oatDataFlowAnalysisDispatcher(cUnit, methodBlockCodeGen,
+                                kPreOrderDFSTraversal, false /* Iterative */);
 
-    handleSuspendLaunchpads(cUnit);
+  handleSuspendLaunchpads(cUnit);
 
-    handleThrowLaunchpads(cUnit);
+  handleThrowLaunchpads(cUnit);
 
-    handleIntrinsicLaunchpads(cUnit);
+  handleIntrinsicLaunchpads(cUnit);
 
-    if (!(cUnit->disableOpt & (1 << kSafeOptimizations))) {
-        removeRedundantBranches(cUnit);
-    }
+  if (!(cUnit->disableOpt & (1 << kSafeOptimizations))) {
+    removeRedundantBranches(cUnit);
+  }
 }
 
 /* Needed by the ld/st optmizatons */
 LIR* oatRegCopyNoInsert(CompilationUnit* cUnit, int rDest, int rSrc)
 {
-    return opRegCopyNoInsert(cUnit, rDest, rSrc);
+  return opRegCopyNoInsert(cUnit, rDest, rSrc);
 }
 
 /* Needed by the register allocator */
 void oatRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
 {
-    opRegCopy(cUnit, rDest, rSrc);
+  opRegCopy(cUnit, rDest, rSrc);
 }
 
 /* Needed by the register allocator */
 void oatRegCopyWide(CompilationUnit* cUnit, int destLo, int destHi,
-                            int srcLo, int srcHi)
+              int srcLo, int srcHi)
 {
-    opRegCopyWide(cUnit, destLo, destHi, srcLo, srcHi);
+  opRegCopyWide(cUnit, destLo, destHi, srcLo, srcHi);
 }
 
 void oatFlushRegImpl(CompilationUnit* cUnit, int rBase,
-                             int displacement, int rSrc, OpSize size)
+               int displacement, int rSrc, OpSize size)
 {
-    storeBaseDisp(cUnit, rBase, displacement, rSrc, size);
+  storeBaseDisp(cUnit, rBase, displacement, rSrc, size);
 }
 
 void oatFlushRegWideImpl(CompilationUnit* cUnit, int rBase,
-                                 int displacement, int rSrcLo, int rSrcHi)
+                 int displacement, int rSrcLo, int rSrcHi)
 {
-    storeBaseDispWide(cUnit, rBase, displacement, rSrcLo, rSrcHi);
+  storeBaseDispWide(cUnit, rBase, displacement, rSrcLo, rSrcHi);
 }
 
 }  // namespace art