Merge "Manage llvm::TargetMachine with smart pointer." into ics-mr1-plus-art
diff --git a/src/compiler/Compiler.h b/src/compiler/Compiler.h
index db7f2ba..2f95be2 100644
--- a/src/compiler/Compiler.h
+++ b/src/compiler/Compiler.h
@@ -42,102 +42,102 @@
 
 /* Suppress optimization if corresponding bit set */
 enum optControlVector {
-    kLoadStoreElimination = 0,
-    kLoadHoisting,
-    kSuppressLoads,
-    kNullCheckElimination,
-    kPromoteRegs,
-    kTrackLiveTemps,
-    kSkipLargeMethodOptimization,
-    kSafeOptimizations,
-    kBBOpt,
-    kMatch,
-    kPromoteCompilerTemps,
+  kLoadStoreElimination = 0,
+  kLoadHoisting,
+  kSuppressLoads,
+  kNullCheckElimination,
+  kPromoteRegs,
+  kTrackLiveTemps,
+  kSkipLargeMethodOptimization,
+  kSafeOptimizations,
+  kBBOpt,
+  kMatch,
+  kPromoteCompilerTemps,
 };
 
 /* Type of allocation for memory tuning */
 enum oatAllocKind {
-    kAllocMisc,
-    kAllocBB,
-    kAllocLIR,
-    kAllocMIR,
-    kAllocDFInfo,
-    kAllocGrowableList,
-    kAllocGrowableBitMap,
-    kAllocDalvikToSSAMap,
-    kAllocDebugInfo,
-    kAllocSuccessor,
-    kAllocRegAlloc,
-    kAllocData,
-    kAllocPredecessors,
-    kNumAllocKinds
+  kAllocMisc,
+  kAllocBB,
+  kAllocLIR,
+  kAllocMIR,
+  kAllocDFInfo,
+  kAllocGrowableList,
+  kAllocGrowableBitMap,
+  kAllocDalvikToSSAMap,
+  kAllocDebugInfo,
+  kAllocSuccessor,
+  kAllocRegAlloc,
+  kAllocData,
+  kAllocPredecessors,
+  kNumAllocKinds
 };
 
 /* Type of growable list for memory tuning */
 enum oatListKind {
-    kListMisc = 0,
-    kListBlockList,
-    kListSSAtoDalvikMap,
-    kListDfsOrder,
-    kListDfsPostOrder,
-    kListDomPostOrderTraversal,
-    kListThrowLaunchPads,
-    kListSuspendLaunchPads,
-    kListSwitchTables,
-    kListFillArrayData,
-    kListSuccessorBlocks,
-    kListPredecessors,
-    kNumListKinds
+  kListMisc = 0,
+  kListBlockList,
+  kListSSAtoDalvikMap,
+  kListDfsOrder,
+  kListDfsPostOrder,
+  kListDomPostOrderTraversal,
+  kListThrowLaunchPads,
+  kListSuspendLaunchPads,
+  kListSwitchTables,
+  kListFillArrayData,
+  kListSuccessorBlocks,
+  kListPredecessors,
+  kNumListKinds
 };
 
 /* Type of growable bitmap for memory tuning */
 enum oatBitMapKind {
-    kBitMapMisc = 0,
-    kBitMapUse,
-    kBitMapDef,
-    kBitMapLiveIn,
-    kBitMapBMatrix,
-    kBitMapDominators,
-    kBitMapIDominated,
-    kBitMapDomFrontier,
-    kBitMapPhi,
-    kBitMapTmpBlocks,
-    kBitMapInputBlocks,
-    kBitMapRegisterV,
-    kBitMapTempSSARegisterV,
-    kBitMapNullCheck,
-    kBitMapTmpBlockV,
-    kBitMapPredecessors,
-    kNumBitMapKinds
+  kBitMapMisc = 0,
+  kBitMapUse,
+  kBitMapDef,
+  kBitMapLiveIn,
+  kBitMapBMatrix,
+  kBitMapDominators,
+  kBitMapIDominated,
+  kBitMapDomFrontier,
+  kBitMapPhi,
+  kBitMapTmpBlocks,
+  kBitMapInputBlocks,
+  kBitMapRegisterV,
+  kBitMapTempSSARegisterV,
+  kBitMapNullCheck,
+  kBitMapTmpBlockV,
+  kBitMapPredecessors,
+  kNumBitMapKinds
 };
 
 /* Force code generation paths for testing */
 enum debugControlVector {
-    kDebugDisplayMissingTargets,
-    kDebugVerbose,
-    kDebugDumpCFG,
-    kDebugSlowFieldPath,
-    kDebugSlowInvokePath,
-    kDebugSlowStringPath,
-    kDebugSlowTypePath,
-    kDebugSlowestFieldPath,
-    kDebugSlowestStringPath,
-    kDebugExerciseResolveMethod,
-    kDebugVerifyDataflow,
-    kDebugShowMemoryUsage,
-    kDebugShowNops,
-    kDebugCountOpcodes,
+  kDebugDisplayMissingTargets,
+  kDebugVerbose,
+  kDebugDumpCFG,
+  kDebugSlowFieldPath,
+  kDebugSlowInvokePath,
+  kDebugSlowStringPath,
+  kDebugSlowTypePath,
+  kDebugSlowestFieldPath,
+  kDebugSlowestStringPath,
+  kDebugExerciseResolveMethod,
+  kDebugVerifyDataflow,
+  kDebugShowMemoryUsage,
+  kDebugShowNops,
+  kDebugCountOpcodes,
 };
 
 enum OatMethodAttributes {
-    kIsCallee = 0,      /* Code is part of a callee (invoked by a hot trace) */
-    kIsHot,             /* Code is part of a hot trace */
-    kIsLeaf,            /* Method is leaf */
-    kIsEmpty,           /* Method is empty */
-    kIsThrowFree,       /* Method doesn't throw */
-    kIsGetter,          /* Method fits the getter pattern */
-    kIsSetter,          /* Method fits the setter pattern */
-    kCannotCompile,     /* Method cannot be compiled */
+  kIsCallee = 0,      /* Code is part of a callee (invoked by a hot trace) */
+  kIsHot,             /* Code is part of a hot trace */
+  kIsLeaf,            /* Method is leaf */
+  kIsEmpty,           /* Method is empty */
+  kIsThrowFree,       /* Method doesn't throw */
+  kIsGetter,          /* Method fits the getter pattern */
+  kIsSetter,          /* Method fits the setter pattern */
+  kCannotCompile,     /* Method cannot be compiled */
 };
 
 #define METHOD_IS_CALLEE        (1 << kIsCallee)
@@ -151,12 +151,12 @@
 
 /* Customized node traversal orders for different needs */
 enum DataFlowAnalysisMode {
-    kAllNodes = 0,              // All nodes
-    kReachableNodes,            // All reachable nodes
-    kPreOrderDFSTraversal,      // Depth-First-Search / Pre-Order
-    kPostOrderDFSTraversal,     // Depth-First-Search / Post-Order
-    kPostOrderDOMTraversal,     // Dominator tree / Post-Order
-    kReversePostOrderTraversal, // Depth-First-Search / reverse Post-Order
+  kAllNodes = 0,              // All nodes
+  kReachableNodes,            // All reachable nodes
+  kPreOrderDFSTraversal,      // Depth-First-Search / Pre-Order
+  kPostOrderDFSTraversal,     // Depth-First-Search / Post-Order
+  kPostOrderDOMTraversal,     // Dominator tree / Post-Order
+  kReversePostOrderTraversal, // Depth-First-Search / reverse Post-Order
 };
 
 struct CompilationUnit;
@@ -184,9 +184,9 @@
 char* oatFullDisassembler(CompilationUnit* cUnit, const MIR* mir);
 char* oatGetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep);
 void oatDataFlowAnalysisDispatcher(CompilationUnit* cUnit,
-                bool (*func)(CompilationUnit* , BasicBlock*),
-                DataFlowAnalysisMode dfaMode,
-                bool isIterative);
+                                   bool (*func)(CompilationUnit* , BasicBlock*),
+                                   DataFlowAnalysisMode dfaMode,
+                                   bool isIterative);
 void oatMethodSSATransformation(CompilationUnit* cUnit);
 u8 oatGetRegResourceMask(int reg);
 void oatDumpCFG(CompilationUnit* cUnit, const char* dirPrefix);
diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 67d741a..2e0f6d5 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -31,49 +31,49 @@
 #define SLOW_STRING_PATH (cUnit->enableDebug & (1 << kDebugSlowStringPath))
 #define SLOW_TYPE_PATH (cUnit->enableDebug & (1 << kDebugSlowTypePath))
 #define EXERCISE_SLOWEST_FIELD_PATH (cUnit->enableDebug & \
-    (1 << kDebugSlowestFieldPath))
+  (1 << kDebugSlowestFieldPath))
 #define EXERCISE_SLOWEST_STRING_PATH (cUnit->enableDebug & \
-    (1 << kDebugSlowestStringPath))
+  (1 << kDebugSlowestStringPath))
 #define EXERCISE_RESOLVE_METHOD (cUnit->enableDebug & \
-    (1 << kDebugExerciseResolveMethod))
+  (1 << kDebugExerciseResolveMethod))
 
 enum RegisterClass {
-    kCoreReg,
-    kFPReg,
-    kAnyReg,
+  kCoreReg,
+  kFPReg,
+  kAnyReg,
 };
 
 enum RegLocationType {
-    kLocDalvikFrame = 0, // Normal Dalvik register
-    kLocPhysReg,
-    kLocCompilerTemp,
-    kLocInvalid
+  kLocDalvikFrame = 0, // Normal Dalvik register
+  kLocPhysReg,
+  kLocCompilerTemp,
+  kLocInvalid
 };
 
 struct PromotionMap {
-   RegLocationType coreLocation:3;
-   u1 coreReg;
-   RegLocationType fpLocation:3;
-   u1 fpReg;
-   bool firstInPair;
+  RegLocationType coreLocation:3;
+  u1 coreReg;
+  RegLocationType fpLocation:3;
+  u1 fpReg;
+  bool firstInPair;
 };
 
 struct RegLocation {
-    RegLocationType location:3;
-    unsigned wide:1;
-    unsigned defined:1;   // Do we know the type?
-    unsigned fp:1;        // Floating point?
-    unsigned core:1;      // Non-floating point?
-    unsigned highWord:1;  // High word of pair?
-    unsigned home:1;      // Does this represent the home location?
-    u1 lowReg;            // First physical register
-    u1 highReg;           // 2nd physical register (if wide)
-    int32_t sRegLow;      // SSA name for low Dalvik word
+  RegLocationType location:3;
+  unsigned wide:1;
+  unsigned defined:1;   // Do we know the type?
+  unsigned fp:1;        // Floating point?
+  unsigned core:1;      // Non-floating point?
+  unsigned highWord:1;  // High word of pair?
+  unsigned home:1;      // Does this represent the home location?
+  u1 lowReg;            // First physical register
+  u1 highReg;           // 2nd physical register (if wide)
+  int32_t sRegLow;      // SSA name for low Dalvik word
 };
 
 struct CompilerTemp {
-    int sReg;
-    ArenaBitVector* bv;
+  int sReg;
+  ArenaBitVector* bv;
 };
 
  /*
@@ -83,25 +83,25 @@
  * possible.
  */
 struct RegisterInfo {
-    int reg;                    // Reg number
-    bool inUse;                 // Has it been allocated?
-    bool isTemp;                // Can allocate as temp?
-    bool pair;                  // Part of a register pair?
-    int partner;                // If pair, other reg of pair
-    bool live;                  // Is there an associated SSA name?
-    bool dirty;                 // If live, is it dirty?
-    int sReg;                   // Name of live value
-    LIR *defStart;              // Starting inst in last def sequence
-    LIR *defEnd;                // Ending inst in last def sequence
+  int reg;                    // Reg number
+  bool inUse;                 // Has it been allocated?
+  bool isTemp;                // Can allocate as temp?
+  bool pair;                  // Part of a register pair?
+  int partner;                // If pair, other reg of pair
+  bool live;                  // Is there an associated SSA name?
+  bool dirty;                 // If live, is it dirty?
+  int sReg;                   // Name of live value
+  LIR *defStart;              // Starting inst in last def sequence
+  LIR *defEnd;                // Ending inst in last def sequence
 };
 
 struct RegisterPool {
-    int numCoreRegs;
-    RegisterInfo *coreRegs;
-    int nextCoreReg;
-    int numFPRegs;
-    RegisterInfo *FPRegs;
-    int nextFPReg;
+  int numCoreRegs;
+  RegisterInfo *coreRegs;
+  int nextCoreReg;
+  int numFPRegs;
+  RegisterInfo *FPRegs;
+  int nextFPReg;
 };
 
 #define INVALID_SREG (-1)
@@ -126,11 +126,11 @@
 #define MANY_BLOCKS 4000 /* Non-initializer threshold */
 
 enum BBType {
-    kEntryBlock,
-    kDalvikByteCode,
-    kExitBlock,
-    kExceptionHandling,
-    kCatchEntry,
+  kEntryBlock,
+  kDalvikByteCode,
+  kExitBlock,
+  kExceptionHandling,
+  kCatchEntry,
 };
 
 /* Utility macros to traverse the LIR list */
@@ -141,54 +141,54 @@
 #define PREV_LIR_LVALUE(lir) (lir)->prev
 
 struct LIR {
-    int offset;                        // Offset of this instruction
-    int dalvikOffset;                  // Offset of Dalvik opcode
-    LIR* next;
-    LIR* prev;
-    LIR* target;
-    int opcode;
-    int operands[5];            // [0..4] = [dest, src1, src2, extra, extra2]
-    struct {
-        bool isNop:1;           // LIR is optimized away
-        bool pcRelFixup:1;      // May need pc-relative fixup
-        unsigned int age:4;     // default is 0, set lazily by the optimizer
-        unsigned int size:5;    // in bytes
-        unsigned int unused:21;
-    } flags;
-    int aliasInfo;              // For Dalvik register & litpool disambiguation
-    u8 useMask;                 // Resource mask for use
-    u8 defMask;                 // Resource mask for def
+  int offset;                        // Offset of this instruction
+  int dalvikOffset;                  // Offset of Dalvik opcode
+  LIR* next;
+  LIR* prev;
+  LIR* target;
+  int opcode;
+  int operands[5];            // [0..4] = [dest, src1, src2, extra, extra2]
+  struct {
+    bool isNop:1;           // LIR is optimized away
+    bool pcRelFixup:1;      // May need pc-relative fixup
+    unsigned int age:4;     // default is 0, set lazily by the optimizer
+    unsigned int size:5;    // in bytes
+    unsigned int unused:21;
+  } flags;
+  int aliasInfo;              // For Dalvik register & litpool disambiguation
+  u8 useMask;                 // Resource mask for use
+  u8 defMask;                 // Resource mask for def
 };
 
 enum ExtendedMIROpcode {
-    kMirOpFirst = kNumPackedOpcodes,
-    kMirOpPhi = kMirOpFirst,
-    kMirOpCopy,
-    kMirOpFusedCmplFloat,
-    kMirOpFusedCmpgFloat,
-    kMirOpFusedCmplDouble,
-    kMirOpFusedCmpgDouble,
-    kMirOpFusedCmpLong,
-    kMirOpNop,
-    kMirOpNullNRangeUpCheck,
-    kMirOpNullNRangeDownCheck,
-    kMirOpLowerBound,
-    kMirOpLast,
+  kMirOpFirst = kNumPackedOpcodes,
+  kMirOpPhi = kMirOpFirst,
+  kMirOpCopy,
+  kMirOpFusedCmplFloat,
+  kMirOpFusedCmpgFloat,
+  kMirOpFusedCmplDouble,
+  kMirOpFusedCmpgDouble,
+  kMirOpFusedCmpLong,
+  kMirOpNop,
+  kMirOpNullNRangeUpCheck,
+  kMirOpNullNRangeDownCheck,
+  kMirOpLowerBound,
+  kMirOpLast,
 };
 
 struct SSARepresentation;
 
 enum MIROptimizationFlagPositons {
-    kMIRIgnoreNullCheck = 0,
-    kMIRNullCheckOnly,
-    kMIRIgnoreRangeCheck,
-    kMIRRangeCheckOnly,
-    kMIRInlined,                        // Invoke is inlined (ie dead)
-    kMIRInlinedPred,                    // Invoke is inlined via prediction
-    kMIRCallee,                         // Instruction is inlined from callee
-    kMIRIgnoreSuspendCheck,
-    kMIRDup,
-    kMIRMark,                           // Temporary node mark
+  kMIRIgnoreNullCheck = 0,
+  kMIRNullCheckOnly,
+  kMIRIgnoreRangeCheck,
+  kMIRRangeCheckOnly,
+  kMIRInlined,                        // Invoke is inlined (ie dead)
+  kMIRInlinedPred,                    // Invoke is inlined via prediction
+  kMIRCallee,                         // Instruction is inlined from callee
+  kMIRIgnoreSuspendCheck,
+  kMIRDup,
+  kMIRMark,                           // Temporary node mark
 };
 
 #define MIR_IGNORE_NULL_CHECK           (1 << kMIRIgnoreNullCheck)
@@ -203,68 +203,68 @@
 #define MIR_MARK                        (1 << kMIRMark)
 
 struct CallsiteInfo {
-    const char* classDescriptor;
-    Object* classLoader;
-    const Method* method;
-    LIR* misPredBranchOver;
+  const char* classDescriptor;
+  Object* classLoader;
+  const Method* method;
+  LIR* misPredBranchOver;
 };
 
 struct MIR {
-    DecodedInstruction dalvikInsn;
-    unsigned int width;
-    unsigned int offset;
-    MIR* prev;
-    MIR* next;
-    SSARepresentation* ssaRep;
-    int optimizationFlags;
-    int seqNum;
-    union {
-        // Used by the inlined insn from the callee to find the mother method
-        const Method* calleeMethod;
-        // Used by the inlined invoke to find the class and method pointers
-        CallsiteInfo* callsiteInfo;
-        // Used to quickly locate all Phi opcodes
-        MIR* phiNext;
-    } meta;
+  DecodedInstruction dalvikInsn;
+  unsigned int width;
+  unsigned int offset;
+  MIR* prev;
+  MIR* next;
+  SSARepresentation* ssaRep;
+  int optimizationFlags;
+  int seqNum;
+  union {
+    // Used by the inlined insn from the callee to find the mother method
+    const Method* calleeMethod;
+    // Used by the inlined invoke to find the class and method pointers
+    CallsiteInfo* callsiteInfo;
+    // Used to quickly locate all Phi opcodes
+    MIR* phiNext;
+  } meta;
 };
 
 struct BasicBlockDataFlow;
 
 /* For successorBlockList */
 enum BlockListType {
-    kNotUsed = 0,
-    kCatch,
-    kPackedSwitch,
-    kSparseSwitch,
+  kNotUsed = 0,
+  kCatch,
+  kPackedSwitch,
+  kSparseSwitch,
 };
 
 struct BasicBlock {
-    int id;
-    int dfsId;
-    bool visited;
-    bool hidden;
-    bool catchEntry;
-    bool fallThroughTarget;             // Reached via fallthrough
-    uint16_t startOffset;
-    uint16_t nestingDepth;
-    const Method* containingMethod;     // For blocks from the callee
-    BBType blockType;
-    bool needFallThroughBranch;         // For blocks ended due to length limit
-    bool isFallThroughFromInvoke;       // True means the block needs alignment
-    MIR* firstMIRInsn;
-    MIR* lastMIRInsn;
-    BasicBlock* fallThrough;
-    BasicBlock* taken;
-    BasicBlock* iDom;            // Immediate dominator
-    BasicBlockDataFlow* dataFlowInfo;
-    GrowableList* predecessors;
-    ArenaBitVector* dominators;
-    ArenaBitVector* iDominated;         // Set nodes being immediately dominated
-    ArenaBitVector* domFrontier;        // Dominance frontier
-    struct {                            // For one-to-many successors like
-        BlockListType blockListType;    // switch and exception handling
-        GrowableList blocks;
-    } successorBlockList;
+  int id;
+  int dfsId;
+  bool visited;
+  bool hidden;
+  bool catchEntry;
+  bool fallThroughTarget;             // Reached via fallthrough
+  uint16_t startOffset;
+  uint16_t nestingDepth;
+  const Method* containingMethod;     // For blocks from the callee
+  BBType blockType;
+  bool needFallThroughBranch;         // For blocks ended due to length limit
+  bool isFallThroughFromInvoke;       // True means the block needs alignment
+  MIR* firstMIRInsn;
+  MIR* lastMIRInsn;
+  BasicBlock* fallThrough;
+  BasicBlock* taken;
+  BasicBlock* iDom;            // Immediate dominator
+  BasicBlockDataFlow* dataFlowInfo;
+  GrowableList* predecessors;
+  ArenaBitVector* dominators;
+  ArenaBitVector* iDominated;         // Set nodes being immediately dominated
+  ArenaBitVector* domFrontier;        // Dominance frontier
+  struct {                            // For one-to-many successors like
+    BlockListType blockListType;    // switch and exception handling
+    GrowableList blocks;
+  } successorBlockList;
 };
 
 /*
@@ -274,8 +274,8 @@
  * For swtich blocks, key is the case value.
  */
 struct SuccessorBlockInfo {
-    BasicBlock* block;
-    int key;
+  BasicBlock* block;
+  int key;
 };
 
 struct LoopAnalysis;
@@ -284,412 +284,412 @@
 struct Memstats;
 
 enum AssemblerStatus {
-    kSuccess,
-    kRetryAll,
-    kRetryHalve
+  kSuccess,
+  kRetryAll,
+  kRetryHalve
 };
 
 #define NOTVISITED (-1)
 
 struct CompilationUnit {
   CompilationUnit()
-      : numBlocks(0),
-        compiler(NULL),
-        class_linker(NULL),
-        dex_file(NULL),
-        dex_cache(NULL),
-        class_loader(NULL),
-        method_idx(0),
-        code_item(NULL),
-        access_flags(0),
-        shorty(NULL),
-        firstLIRInsn(NULL),
-        lastLIRInsn(NULL),
-        literalList(NULL),
-        methodLiteralList(NULL),
-        codeLiteralList(NULL),
-        classPointerList(NULL),
-        numClassPointers(0),
-        chainCellOffsetLIR(NULL),
-        disableOpt(0),
-        enableDebug(0),
-        headerSize(0),
-        dataOffset(0),
-        totalSize(0),
-        assemblerStatus(kSuccess),
-        assemblerRetries(0),
-        genDebugger(false),
-        printMe(false),
-        hasClassLiterals(false),
-        hasLoop(false),
-        hasInvoke(false),
-        heapMemOp(false),
-        qdMode(false),
-        usesLinkRegister(false),
-        methodTraceSupport(false),
-        regPool(NULL),
-        optRound(0),
-        instructionSet(kNone),
-        numSSARegs(0),
-        ssaBaseVRegs(NULL),
-        ssaSubscripts(NULL),
-        vRegToSSAMap(NULL),
-        SSALastDefs(NULL),
-        isConstantV(NULL),
-        constantValues(NULL),
-        phiAliasMap(NULL),
-        phiList(NULL),
-        regLocation(NULL),
-        sequenceNumber(0),
-        promotionMap(NULL),
-        methodSReg(0),
-        switchOverflowPad(NULL),
-        numReachableBlocks(0),
-        numDalvikRegisters(0),
-        entryBlock(NULL),
-        exitBlock(NULL),
-        curBlock(NULL),
-        nextCodegenBlock(NULL),
-        iDomList(NULL),
-        tryBlockAddr(NULL),
-        defBlockMatrix(NULL),
-        tempBlockV(NULL),
-        tempDalvikRegisterV(NULL),
-        tempSSARegisterV(NULL),
-        printSSANames(false),
-        blockLabelList(NULL),
-        quitLoopMode(false),
-        preservedRegsUsed(0),
-        numIns(0),
-        numOuts(0),
-        numRegs(0),
-        numCoreSpills(0),
-        numFPSpills(0),
-        numCompilerTemps(0),
-        frameSize(0),
-        coreSpillMask(0U),
-        fpSpillMask(0U),
-        attrs(0U),
-        currentDalvikOffset(0),
-        insns(NULL),
-        insnsSize(0U),
-        disableDataflow(false),
-        defCount(0),
-        compilerFlipMatch(false),
-        arenaHead(NULL),
-        currentArena(NULL),
-        numArenaBlocks(0),
-        mstats(NULL),
-        opcodeCount(NULL) {
+    : numBlocks(0),
+      compiler(NULL),
+      class_linker(NULL),
+      dex_file(NULL),
+      dex_cache(NULL),
+      class_loader(NULL),
+      method_idx(0),
+      code_item(NULL),
+      access_flags(0),
+      shorty(NULL),
+      firstLIRInsn(NULL),
+      lastLIRInsn(NULL),
+      literalList(NULL),
+      methodLiteralList(NULL),
+      codeLiteralList(NULL),
+      classPointerList(NULL),
+      numClassPointers(0),
+      chainCellOffsetLIR(NULL),
+      disableOpt(0),
+      enableDebug(0),
+      headerSize(0),
+      dataOffset(0),
+      totalSize(0),
+      assemblerStatus(kSuccess),
+      assemblerRetries(0),
+      genDebugger(false),
+      printMe(false),
+      hasClassLiterals(false),
+      hasLoop(false),
+      hasInvoke(false),
+      heapMemOp(false),
+      qdMode(false),
+      usesLinkRegister(false),
+      methodTraceSupport(false),
+      regPool(NULL),
+      optRound(0),
+      instructionSet(kNone),
+      numSSARegs(0),
+      ssaBaseVRegs(NULL),
+      ssaSubscripts(NULL),
+      vRegToSSAMap(NULL),
+      SSALastDefs(NULL),
+      isConstantV(NULL),
+      constantValues(NULL),
+      phiAliasMap(NULL),
+      phiList(NULL),
+      regLocation(NULL),
+      sequenceNumber(0),
+      promotionMap(NULL),
+      methodSReg(0),
+      switchOverflowPad(NULL),
+      numReachableBlocks(0),
+      numDalvikRegisters(0),
+      entryBlock(NULL),
+      exitBlock(NULL),
+      curBlock(NULL),
+      nextCodegenBlock(NULL),
+      iDomList(NULL),
+      tryBlockAddr(NULL),
+      defBlockMatrix(NULL),
+      tempBlockV(NULL),
+      tempDalvikRegisterV(NULL),
+      tempSSARegisterV(NULL),
+      printSSANames(false),
+      blockLabelList(NULL),
+      quitLoopMode(false),
+      preservedRegsUsed(0),
+      numIns(0),
+      numOuts(0),
+      numRegs(0),
+      numCoreSpills(0),
+      numFPSpills(0),
+      numCompilerTemps(0),
+      frameSize(0),
+      coreSpillMask(0U),
+      fpSpillMask(0U),
+      attrs(0U),
+      currentDalvikOffset(0),
+      insns(NULL),
+      insnsSize(0U),
+      disableDataflow(false),
+      defCount(0),
+      compilerFlipMatch(false),
+      arenaHead(NULL),
+      currentArena(NULL),
+      numArenaBlocks(0),
+      mstats(NULL),
+      opcodeCount(NULL) {
 #if !defined(NDEBUG)
       liveSReg = 0;
 #endif
-    }
+  }
 
-    int numBlocks;
-    GrowableList blockList;
-    Compiler* compiler;            // Compiler driving this compiler
-    ClassLinker* class_linker;     // Linker to resolve fields and methods
-    const DexFile* dex_file;       // DexFile containing the method being compiled
-    DexCache* dex_cache;           // DexFile's corresponding cache
-    const ClassLoader* class_loader;  // compiling method's class loader
-    uint32_t method_idx;                // compiling method's index into method_ids of DexFile
-    const DexFile::CodeItem* code_item;  // compiling method's DexFile code_item
-    uint32_t access_flags;              // compiling method's access flags
-    const char* shorty;                 // compiling method's shorty
-    LIR* firstLIRInsn;
-    LIR* lastLIRInsn;
-    LIR* literalList;                   // Constants
-    LIR* methodLiteralList;             // Method literals requiring patching
-    LIR* codeLiteralList;               // Code literals requiring patching
-    LIR* classPointerList;              // Relocatable
-    int numClassPointers;
-    LIR* chainCellOffsetLIR;
-    uint32_t disableOpt;                // optControlVector flags
-    uint32_t enableDebug;               // debugControlVector flags
-    int headerSize;                     // bytes before the first code ptr
-    int dataOffset;                     // starting offset of literal pool
-    int totalSize;                      // header + code size
-    AssemblerStatus assemblerStatus;    // Success or fix and retry
-    int assemblerRetries;
-    std::vector<uint8_t> codeBuffer;
-    std::vector<uint32_t> mappingTable;
-    std::vector<uint16_t> coreVmapTable;
-    std::vector<uint16_t> fpVmapTable;
-    bool genDebugger;                   // Generate code for debugger
-    bool printMe;
-    bool hasClassLiterals;              // Contains class ptrs used as literals
-    bool hasLoop;                       // Contains a loop
-    bool hasInvoke;                     // Contains an invoke instruction
-    bool heapMemOp;                     // Mark mem ops for self verification
-    bool qdMode;                        // Compile for code size/compile time
-    bool usesLinkRegister;              // For self-verification only
-    bool methodTraceSupport;            // For TraceView profiling
-    RegisterPool* regPool;
-    int optRound;                       // round number to tell an LIR's age
-    InstructionSet instructionSet;
-    /* Number of total regs used in the whole cUnit after SSA transformation */
-    int numSSARegs;
-    /* Map SSA reg i to the base virtual register/subscript */
-    GrowableList* ssaBaseVRegs;
-    GrowableList* ssaSubscripts;
+  int numBlocks;
+  GrowableList blockList;
+  Compiler* compiler;            // Compiler driving this compiler
+  ClassLinker* class_linker;     // Linker to resolve fields and methods
+  const DexFile* dex_file;       // DexFile containing the method being compiled
+  DexCache* dex_cache;           // DexFile's corresponding cache
+  const ClassLoader* class_loader;  // compiling method's class loader
+  uint32_t method_idx;                // compiling method's index into method_ids of DexFile
+  const DexFile::CodeItem* code_item;  // compiling method's DexFile code_item
+  uint32_t access_flags;              // compiling method's access flags
+  const char* shorty;                 // compiling method's shorty
+  LIR* firstLIRInsn;
+  LIR* lastLIRInsn;
+  LIR* literalList;                   // Constants
+  LIR* methodLiteralList;             // Method literals requiring patching
+  LIR* codeLiteralList;               // Code literals requiring patching
+  LIR* classPointerList;              // Relocatable
+  int numClassPointers;
+  LIR* chainCellOffsetLIR;
+  uint32_t disableOpt;                // optControlVector flags
+  uint32_t enableDebug;               // debugControlVector flags
+  int headerSize;                     // bytes before the first code ptr
+  int dataOffset;                     // starting offset of literal pool
+  int totalSize;                      // header + code size
+  AssemblerStatus assemblerStatus;    // Success or fix and retry
+  int assemblerRetries;
+  std::vector<uint8_t> codeBuffer;
+  std::vector<uint32_t> mappingTable;
+  std::vector<uint16_t> coreVmapTable;
+  std::vector<uint16_t> fpVmapTable;
+  bool genDebugger;                   // Generate code for debugger
+  bool printMe;
+  bool hasClassLiterals;              // Contains class ptrs used as literals
+  bool hasLoop;                       // Contains a loop
+  bool hasInvoke;                     // Contains an invoke instruction
+  bool heapMemOp;                     // Mark mem ops for self verification
+  bool qdMode;                        // Compile for code size/compile time
+  bool usesLinkRegister;              // For self-verification only
+  bool methodTraceSupport;            // For TraceView profiling
+  RegisterPool* regPool;
+  int optRound;                       // round number to tell an LIR's age
+  InstructionSet instructionSet;
+  /* Number of total regs used in the whole cUnit after SSA transformation */
+  int numSSARegs;
+  /* Map SSA reg i to the base virtual register/subscript */
+  GrowableList* ssaBaseVRegs;
+  GrowableList* ssaSubscripts;
 
-    /* The following are new data structures to support SSA representations */
-    /* Map original Dalvik virtual reg i to the current SSA name */
-    int* vRegToSSAMap;                  // length == method->registersSize
-    int* SSALastDefs;                   // length == method->registersSize
-    ArenaBitVector* isConstantV;        // length == numSSAReg
-    int* constantValues;                // length == numSSAReg
-    int* phiAliasMap;                   // length == numSSAReg
-    MIR* phiList;
+  /* The following are new data structures to support SSA representations */
+  /* Map original Dalvik virtual reg i to the current SSA name */
+  int* vRegToSSAMap;                  // length == method->registersSize
+  int* SSALastDefs;                   // length == method->registersSize
+  ArenaBitVector* isConstantV;        // length == numSSAReg
+  int* constantValues;                // length == numSSAReg
+  int* phiAliasMap;                   // length == numSSAReg
+  MIR* phiList;
 
-    /* Use counts of ssa names */
-    GrowableList useCounts;             // Weighted by nesting depth
-    GrowableList rawUseCounts;          // Not weighted
+  /* Use counts of ssa names */
+  GrowableList useCounts;             // Weighted by nesting depth
+  GrowableList rawUseCounts;          // Not weighted
 
-    /* Optimization support */
-    GrowableList loopHeaders;
+  /* Optimization support */
+  GrowableList loopHeaders;
 
-    /* Map SSA names to location */
-    RegLocation* regLocation;
-    int sequenceNumber;
+  /* Map SSA names to location */
+  RegLocation* regLocation;
+  int sequenceNumber;
 
-    /* Keep track of Dalvik vReg to physical register mappings */
-    PromotionMap* promotionMap;
+  /* Keep track of Dalvik vReg to physical register mappings */
+  PromotionMap* promotionMap;
 
-    /* SSA name for Method* */
-    int methodSReg;
+  /* SSA name for Method* */
+  int methodSReg;
 
-    /*
-     * Set to the Dalvik PC of the switch instruction if it has more than
-     * MAX_CHAINED_SWITCH_CASES cases.
-     */
-    const u2* switchOverflowPad;
+  /*
+   * Set to the Dalvik PC of the switch instruction if it has more than
+   * MAX_CHAINED_SWITCH_CASES cases.
+   */
+  const u2* switchOverflowPad;
 
-    int numReachableBlocks;
-    int numDalvikRegisters;             // method->registersSize
-    BasicBlock* entryBlock;
-    BasicBlock* exitBlock;
-    BasicBlock* curBlock;
-    BasicBlock* nextCodegenBlock;       // for extended trace codegen
-    GrowableList dfsOrder;
-    GrowableList dfsPostOrder;
-    GrowableList domPostOrderTraversal;
-    GrowableList throwLaunchpads;
-    GrowableList suspendLaunchpads;
-    GrowableList intrinsicLaunchpads;
-    GrowableList compilerTemps;
-    int* iDomList;
-    ArenaBitVector* tryBlockAddr;
-    ArenaBitVector** defBlockMatrix;    // numDalvikRegister x numBlocks
-    ArenaBitVector* tempBlockV;
-    ArenaBitVector* tempDalvikRegisterV;
-    ArenaBitVector* tempSSARegisterV;   // numSSARegs
-    bool printSSANames;
-    void* blockLabelList;
-    bool quitLoopMode;                  // cold path/complex bytecode
-    int preservedRegsUsed;              // How many callee save regs used
-    /*
-     * Frame layout details.
-     * NOTE: for debug support it will be necessary to add a structure
-     * to map the Dalvik virtual registers to the promoted registers.
-     * NOTE: "num" fields are in 4-byte words, "Size" and "Offset" in bytes.
-     */
-    int numIns;
-    int numOuts;
-    int numRegs;            // Unlike numDalvikRegisters, does not include ins
-    int numCoreSpills;
-    int numFPSpills;
-    int numCompilerTemps;
-    int frameSize;
-    unsigned int coreSpillMask;
-    unsigned int fpSpillMask;
-    unsigned int attrs;
-    /*
-     * CLEANUP/RESTRUCTURE: The code generation utilities don't have a built-in
-     * mechanism to propagate the original Dalvik opcode address to the
-     * associated generated instructions.  For the trace compiler, this wasn't
-     * necessary because the interpreter handled all throws and debugging
-     * requests.  For now we'll handle this by placing the Dalvik offset
-     * in the CompilationUnit struct before codegen for each instruction.
-     * The low-level LIR creation utilites will pull it from here.  Should
-     * be rewritten.
-     */
-    int currentDalvikOffset;
-    GrowableList switchTables;
-    GrowableList fillArrayData;
-    const u2* insns;
-    u4 insnsSize;
-    bool disableDataflow; // Skip dataflow analysis if possible
-    SafeMap<unsigned int, BasicBlock*> blockMap; // findBlock lookup cache
-    SafeMap<unsigned int, LIR*> boundaryMap; // boundary lookup cache
-    int defCount;         // Used to estimate number of SSA names
+  int numReachableBlocks;
+  int numDalvikRegisters;             // method->registersSize
+  BasicBlock* entryBlock;
+  BasicBlock* exitBlock;
+  BasicBlock* curBlock;
+  BasicBlock* nextCodegenBlock;       // for extended trace codegen
+  GrowableList dfsOrder;
+  GrowableList dfsPostOrder;
+  GrowableList domPostOrderTraversal;
+  GrowableList throwLaunchpads;
+  GrowableList suspendLaunchpads;
+  GrowableList intrinsicLaunchpads;
+  GrowableList compilerTemps;
+  int* iDomList;
+  ArenaBitVector* tryBlockAddr;
+  ArenaBitVector** defBlockMatrix;    // numDalvikRegister x numBlocks
+  ArenaBitVector* tempBlockV;
+  ArenaBitVector* tempDalvikRegisterV;
+  ArenaBitVector* tempSSARegisterV;   // numSSARegs
+  bool printSSANames;
+  void* blockLabelList;
+  bool quitLoopMode;                  // cold path/complex bytecode
+  int preservedRegsUsed;              // How many callee save regs used
+  /*
+   * Frame layout details.
+   * NOTE: for debug support it will be necessary to add a structure
+   * to map the Dalvik virtual registers to the promoted registers.
+   * NOTE: "num" fields are in 4-byte words, "Size" and "Offset" in bytes.
+   */
+  int numIns;
+  int numOuts;
+  int numRegs;            // Unlike numDalvikRegisters, does not include ins
+  int numCoreSpills;
+  int numFPSpills;
+  int numCompilerTemps;
+  int frameSize;
+  unsigned int coreSpillMask;
+  unsigned int fpSpillMask;
+  unsigned int attrs;
+  /*
+   * CLEANUP/RESTRUCTURE: The code generation utilities don't have a built-in
+   * mechanism to propagate the original Dalvik opcode address to the
+   * associated generated instructions.  For the trace compiler, this wasn't
+   * necessary because the interpreter handled all throws and debugging
+   * requests.  For now we'll handle this by placing the Dalvik offset
+   * in the CompilationUnit struct before codegen for each instruction.
+   * The low-level LIR creation utilites will pull it from here.  Should
+   * be rewritten.
+   */
+  int currentDalvikOffset;
+  GrowableList switchTables;
+  GrowableList fillArrayData;
+  const u2* insns;
+  u4 insnsSize;
+  bool disableDataflow; // Skip dataflow analysis if possible
+  SafeMap<unsigned int, BasicBlock*> blockMap; // findBlock lookup cache
+  SafeMap<unsigned int, LIR*> boundaryMap; // boundary lookup cache
+  int defCount;         // Used to estimate number of SSA names
 
-    // If non-empty, apply optimizer/debug flags only to matching methods.
-    std::string compilerMethodMatch;
-    // Flips sense of compilerMethodMatch - apply flags if doesn't match.
-    bool compilerFlipMatch;
-    ArenaMemBlock* arenaHead;
-    ArenaMemBlock* currentArena;
-    int numArenaBlocks;
-    Memstats* mstats;
-    int* opcodeCount;    // Count Dalvik opcodes for tuning
+  // If non-empty, apply optimizer/debug flags only to matching methods.
+  std::string compilerMethodMatch;
+  // Flips sense of compilerMethodMatch - apply flags if doesn't match.
+  bool compilerFlipMatch;
+  ArenaMemBlock* arenaHead;
+  ArenaMemBlock* currentArena;
+  int numArenaBlocks;
+  Memstats* mstats;
+  int* opcodeCount;    // Count Dalvik opcodes for tuning
 #ifndef NDEBUG
-    /*
-     * Sanity checking for the register temp tracking.  The same ssa
-     * name should never be associated with one temp register per
-     * instruction compilation.
-     */
-    int liveSReg;
+  /*
+   * Sanity checking for the register temp tracking.  The same ssa
+   * name should never be associated with one temp register per
+   * instruction compilation.
+   */
+  int liveSReg;
 #endif
 };
 
 enum OpSize {
-    kWord,
-    kLong,
-    kSingle,
-    kDouble,
-    kUnsignedHalf,
-    kSignedHalf,
-    kUnsignedByte,
-    kSignedByte,
+  kWord,
+  kLong,
+  kSingle,
+  kDouble,
+  kUnsignedHalf,
+  kSignedHalf,
+  kUnsignedByte,
+  kSignedByte,
 };
 
 enum OpKind {
-    kOpMov,
-    kOpMvn,
-    kOpCmp,
-    kOpLsl,
-    kOpLsr,
-    kOpAsr,
-    kOpRor,
-    kOpNot,
-    kOpAnd,
-    kOpOr,
-    kOpXor,
-    kOpNeg,
-    kOpAdd,
-    kOpAdc,
-    kOpSub,
-    kOpSbc,
-    kOpRsub,
-    kOpMul,
-    kOpDiv,
-    kOpRem,
-    kOpBic,
-    kOpCmn,
-    kOpTst,
-    kOpBkpt,
-    kOpBlx,
-    kOpPush,
-    kOpPop,
-    kOp2Char,
-    kOp2Short,
-    kOp2Byte,
-    kOpCondBr,
-    kOpUncondBr,
-    kOpBx,
-    kOpInvalid,
+  kOpMov,
+  kOpMvn,
+  kOpCmp,
+  kOpLsl,
+  kOpLsr,
+  kOpAsr,
+  kOpRor,
+  kOpNot,
+  kOpAnd,
+  kOpOr,
+  kOpXor,
+  kOpNeg,
+  kOpAdd,
+  kOpAdc,
+  kOpSub,
+  kOpSbc,
+  kOpRsub,
+  kOpMul,
+  kOpDiv,
+  kOpRem,
+  kOpBic,
+  kOpCmn,
+  kOpTst,
+  kOpBkpt,
+  kOpBlx,
+  kOpPush,
+  kOpPop,
+  kOp2Char,
+  kOp2Short,
+  kOp2Byte,
+  kOpCondBr,
+  kOpUncondBr,
+  kOpBx,
+  kOpInvalid,
 };
 
 std::ostream& operator<<(std::ostream& os, const OpKind& kind);
 
 enum ConditionCode {
-    kCondEq,  // equal
-    kCondNe,  // not equal
-    kCondCs,  // carry set (unsigned less than)
-    kCondUlt = kCondCs,
-    kCondCc,  // carry clear (unsigned greater than or same)
-    kCondUge = kCondCc,
-    kCondMi,  // minus
-    kCondPl,  // plus, positive or zero
-    kCondVs,  // overflow
-    kCondVc,  // no overflow
-    kCondHi,  // unsigned greater than
-    kCondLs,  // unsigned lower or same
-    kCondGe,  // signed greater than or equal
-    kCondLt,  // signed less than
-    kCondGt,  // signed greater than
-    kCondLe,  // signed less than or equal
-    kCondAl,  // always
-    kCondNv,  // never
+  kCondEq,  // equal
+  kCondNe,  // not equal
+  kCondCs,  // carry set (unsigned less than)
+  kCondUlt = kCondCs,
+  kCondCc,  // carry clear (unsigned greater than or same)
+  kCondUge = kCondCc,
+  kCondMi,  // minus
+  kCondPl,  // plus, positive or zero
+  kCondVs,  // overflow
+  kCondVc,  // no overflow
+  kCondHi,  // unsigned greater than
+  kCondLs,  // unsigned lower or same
+  kCondGe,  // signed greater than or equal
+  kCondLt,  // signed less than
+  kCondGt,  // signed greater than
+  kCondLe,  // signed less than or equal
+  kCondAl,  // always
+  kCondNv,  // never
 };
 
 enum ThrowKind {
-    kThrowNullPointer,
-    kThrowDivZero,
-    kThrowArrayBounds,
-    kThrowVerificationError,
-    kThrowNoSuchMethod,
-    kThrowStackOverflow,
+  kThrowNullPointer,
+  kThrowDivZero,
+  kThrowArrayBounds,
+  kThrowVerificationError,
+  kThrowNoSuchMethod,
+  kThrowStackOverflow,
 };
 
 struct SwitchTable {
-    int offset;
-    const u2* table;            // Original dex table
-    int vaddr;                  // Dalvik offset of switch opcode
-    LIR* anchor;                // Reference instruction for relative offsets
-    LIR** targets;              // Array of case targets
+  int offset;
+  const u2* table;            // Original dex table
+  int vaddr;                  // Dalvik offset of switch opcode
+  LIR* anchor;                // Reference instruction for relative offsets
+  LIR** targets;              // Array of case targets
 };
 
 struct FillArrayData {
-    int offset;
-    const u2* table;           // Original dex table
-    int size;
-    int vaddr;                 // Dalvik offset of FILL_ARRAY_DATA opcode
+  int offset;
+  const u2* table;           // Original dex table
+  int size;
+  int vaddr;                 // Dalvik offset of FILL_ARRAY_DATA opcode
 };
 
 #define MAX_PATTERN_LEN 5
 
 enum SpecialCaseHandler {
-    kNoHandler,
-    kNullMethod,
-    kConstFunction,
-    kIGet,
-    kIGetBoolean,
-    kIGetObject,
-    kIGetByte,
-    kIGetChar,
-    kIGetShort,
-    kIGetWide,
-    kIPut,
-    kIPutBoolean,
-    kIPutObject,
-    kIPutByte,
-    kIPutChar,
-    kIPutShort,
-    kIPutWide,
-    kIdentity,
+  kNoHandler,
+  kNullMethod,
+  kConstFunction,
+  kIGet,
+  kIGetBoolean,
+  kIGetObject,
+  kIGetByte,
+  kIGetChar,
+  kIGetShort,
+  kIGetWide,
+  kIPut,
+  kIPutBoolean,
+  kIPutObject,
+  kIPutByte,
+  kIPutChar,
+  kIPutShort,
+  kIPutWide,
+  kIdentity,
 };
 
 struct CodePattern {
-    const Instruction::Code opcodes[MAX_PATTERN_LEN];
-    const SpecialCaseHandler handlerCode;
+  const Instruction::Code opcodes[MAX_PATTERN_LEN];
+  const SpecialCaseHandler handlerCode;
 };
 
 static const CodePattern specialPatterns[] = {
-    {{Instruction::RETURN_VOID}, kNullMethod},
-    {{Instruction::CONST, Instruction::RETURN}, kConstFunction},
-    {{Instruction::CONST_4, Instruction::RETURN}, kConstFunction},
-    {{Instruction::CONST_4, Instruction::RETURN_OBJECT}, kConstFunction},
-    {{Instruction::CONST_16, Instruction::RETURN}, kConstFunction},
-    {{Instruction::IGET, Instruction:: RETURN}, kIGet},
-    {{Instruction::IGET_BOOLEAN, Instruction::RETURN}, kIGetBoolean},
-    {{Instruction::IGET_OBJECT, Instruction::RETURN_OBJECT}, kIGetObject},
-    {{Instruction::IGET_BYTE, Instruction::RETURN}, kIGetByte},
-    {{Instruction::IGET_CHAR, Instruction::RETURN}, kIGetChar},
-    {{Instruction::IGET_SHORT, Instruction::RETURN}, kIGetShort},
-    {{Instruction::IGET_WIDE, Instruction::RETURN_WIDE}, kIGetWide},
-    {{Instruction::IPUT, Instruction::RETURN_VOID}, kIPut},
-    {{Instruction::IPUT_BOOLEAN, Instruction::RETURN_VOID}, kIPutBoolean},
-    {{Instruction::IPUT_OBJECT, Instruction::RETURN_VOID}, kIPutObject},
-    {{Instruction::IPUT_BYTE, Instruction::RETURN_VOID}, kIPutByte},
-    {{Instruction::IPUT_CHAR, Instruction::RETURN_VOID}, kIPutChar},
-    {{Instruction::IPUT_SHORT, Instruction::RETURN_VOID}, kIPutShort},
-    {{Instruction::IPUT_WIDE, Instruction::RETURN_VOID}, kIPutWide},
-    {{Instruction::RETURN}, kIdentity},
-    {{Instruction::RETURN_OBJECT}, kIdentity},
-    {{Instruction::RETURN_WIDE}, kIdentity},
+  {{Instruction::RETURN_VOID}, kNullMethod},
+  {{Instruction::CONST, Instruction::RETURN}, kConstFunction},
+  {{Instruction::CONST_4, Instruction::RETURN}, kConstFunction},
+  {{Instruction::CONST_4, Instruction::RETURN_OBJECT}, kConstFunction},
+  {{Instruction::CONST_16, Instruction::RETURN}, kConstFunction},
+  {{Instruction::IGET, Instruction:: RETURN}, kIGet},
+  {{Instruction::IGET_BOOLEAN, Instruction::RETURN}, kIGetBoolean},
+  {{Instruction::IGET_OBJECT, Instruction::RETURN_OBJECT}, kIGetObject},
+  {{Instruction::IGET_BYTE, Instruction::RETURN}, kIGetByte},
+  {{Instruction::IGET_CHAR, Instruction::RETURN}, kIGetChar},
+  {{Instruction::IGET_SHORT, Instruction::RETURN}, kIGetShort},
+  {{Instruction::IGET_WIDE, Instruction::RETURN_WIDE}, kIGetWide},
+  {{Instruction::IPUT, Instruction::RETURN_VOID}, kIPut},
+  {{Instruction::IPUT_BOOLEAN, Instruction::RETURN_VOID}, kIPutBoolean},
+  {{Instruction::IPUT_OBJECT, Instruction::RETURN_VOID}, kIPutObject},
+  {{Instruction::IPUT_BYTE, Instruction::RETURN_VOID}, kIPutByte},
+  {{Instruction::IPUT_CHAR, Instruction::RETURN_VOID}, kIPutChar},
+  {{Instruction::IPUT_SHORT, Instruction::RETURN_VOID}, kIPutShort},
+  {{Instruction::IPUT_WIDE, Instruction::RETURN_VOID}, kIPutWide},
+  {{Instruction::RETURN}, kIdentity},
+  {{Instruction::RETURN_OBJECT}, kIdentity},
+  {{Instruction::RETURN_WIDE}, kIdentity},
 };
 
 BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId);
diff --git a/src/compiler/CompilerUtility.h b/src/compiler/CompilerUtility.h
index 4a15f26..d431678 100644
--- a/src/compiler/CompilerUtility.h
+++ b/src/compiler/CompilerUtility.h
@@ -31,10 +31,10 @@
 //#define WITH_MEMSTATS
 
 struct ArenaMemBlock {
-    size_t blockSize;
-    size_t bytesAllocated;
-    ArenaMemBlock *next;
-    char ptr[0];
+  size_t blockSize;
+  size_t bytesAllocated;
+  ArenaMemBlock *next;
+  char ptr[0];
 };
 
 void* oatNew(CompilationUnit* cUnit, size_t size, bool zero,
@@ -55,9 +55,9 @@
 };
 
 struct GrowableListIterator {
-    GrowableList* list;
-    size_t idx;
-    size_t size;
+  GrowableList* list;
+  size_t idx;
+  size_t size;
 };
 
 /*
@@ -67,19 +67,19 @@
  * All operations on a BitVector are unsynchronized.
  */
 struct ArenaBitVector {
-    bool    expandable;     /* expand bitmap if we run out? */
-    u4      storageSize;    /* current size, in 32-bit words */
-    u4*     storage;
+  bool    expandable;     /* expand bitmap if we run out? */
+  u4      storageSize;    /* current size, in 32-bit words */
+  u4*     storage;
 #ifdef WITH_MEMSTATS
-    oatBitMapKind kind;      /* for memory use tuning */
+  oatBitMapKind kind;      /* for memory use tuning */
 #endif
 };
 
 /* Handy iterator to walk through the bit positions set to 1 */
 struct ArenaBitVectorIterator {
-    ArenaBitVector* pBits;
-    u4 idx;
-    u4 bitSize;
+  ArenaBitVector* pBits;
+  u4 idx;
+  u4 bitSize;
 };
 
 #define GET_ELEM_N(LIST, TYPE, N) (((TYPE*) LIST->elemList)[N])
diff --git a/src/compiler/Dataflow.cc b/src/compiler/Dataflow.cc
index bea5ef0..2ba0cc1 100644
--- a/src/compiler/Dataflow.cc
+++ b/src/compiler/Dataflow.cc
@@ -29,919 +29,916 @@
  * scope of optimizations but will not cause mis-optimizations.
  */
 const int oatDataFlowAttributes[kMirOpLast] = {
-    // 00 NOP
-    DF_NOP,
+  // 00 NOP
+  DF_NOP,
 
-    // 01 MOVE vA, vB
-    DF_DA | DF_UB | DF_IS_MOVE,
+  // 01 MOVE vA, vB
+  DF_DA | DF_UB | DF_IS_MOVE,
 
-    // 02 MOVE_FROM16 vAA, vBBBB
-    DF_DA | DF_UB | DF_IS_MOVE,
+  // 02 MOVE_FROM16 vAA, vBBBB
+  DF_DA | DF_UB | DF_IS_MOVE,
 
-    // 03 MOVE_16 vAAAA, vBBBB
-    DF_DA | DF_UB | DF_IS_MOVE,
+  // 03 MOVE_16 vAAAA, vBBBB
+  DF_DA | DF_UB | DF_IS_MOVE,
 
-    // 04 MOVE_WIDE vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
+  // 04 MOVE_WIDE vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
 
-    // 05 MOVE_WIDE_FROM16 vAA, vBBBB
-    DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
+  // 05 MOVE_WIDE_FROM16 vAA, vBBBB
+  DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
 
-    // 06 MOVE_WIDE_16 vAAAA, vBBBB
-    DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
+  // 06 MOVE_WIDE_16 vAAAA, vBBBB
+  DF_DA_WIDE | DF_UB_WIDE | DF_IS_MOVE,
 
-    // 07 MOVE_OBJECT vA, vB
-    DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
+  // 07 MOVE_OBJECT vA, vB
+  DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
 
-    // 08 MOVE_OBJECT_FROM16 vAA, vBBBB
-    DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
+  // 08 MOVE_OBJECT_FROM16 vAA, vBBBB
+  DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
 
-    // 09 MOVE_OBJECT_16 vAAAA, vBBBB
-    DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
+  // 09 MOVE_OBJECT_16 vAAAA, vBBBB
+  DF_DA | DF_UB | DF_NULL_TRANSFER_0 | DF_IS_MOVE | DF_CORE_A | DF_CORE_B,
 
-    // 0A MOVE_RESULT vAA
-    DF_DA,
+  // 0A MOVE_RESULT vAA
+  DF_DA,
 
-    // 0B MOVE_RESULT_WIDE vAA
-    DF_DA_WIDE,
+  // 0B MOVE_RESULT_WIDE vAA
+  DF_DA_WIDE,
 
-    // 0C MOVE_RESULT_OBJECT vAA
-    DF_DA | DF_CORE_A,
+  // 0C MOVE_RESULT_OBJECT vAA
+  DF_DA | DF_CORE_A,
 
-    // 0D MOVE_EXCEPTION vAA
-    DF_DA | DF_CORE_A,
+  // 0D MOVE_EXCEPTION vAA
+  DF_DA | DF_CORE_A,
 
-    // 0E RETURN_VOID
-    DF_NOP,
+  // 0E RETURN_VOID
+  DF_NOP,
 
-    // 0F RETURN vAA
-    DF_UA,
+  // 0F RETURN vAA
+  DF_UA,
 
-    // 10 RETURN_WIDE vAA
-    DF_UA_WIDE,
+  // 10 RETURN_WIDE vAA
+  DF_UA_WIDE,
 
-    // 11 RETURN_OBJECT vAA
-    DF_UA | DF_CORE_A,
+  // 11 RETURN_OBJECT vAA
+  DF_UA | DF_CORE_A,
 
-    // 12 CONST_4 vA, #+B
-    DF_DA | DF_SETS_CONST,
+  // 12 CONST_4 vA, #+B
+  DF_DA | DF_SETS_CONST,
 
-    // 13 CONST_16 vAA, #+BBBB
-    DF_DA | DF_SETS_CONST,
+  // 13 CONST_16 vAA, #+BBBB
+  DF_DA | DF_SETS_CONST,
 
-    // 14 CONST vAA, #+BBBBBBBB
-    DF_DA | DF_SETS_CONST,
+  // 14 CONST vAA, #+BBBBBBBB
+  DF_DA | DF_SETS_CONST,
 
-    // 15 CONST_HIGH16 VAA, #+BBBB0000
-    DF_DA | DF_SETS_CONST,
+  // 15 CONST_HIGH16 VAA, #+BBBB0000
+  DF_DA | DF_SETS_CONST,
 
-    // 16 CONST_WIDE_16 vAA, #+BBBB
-    DF_DA_WIDE | DF_SETS_CONST,
+  // 16 CONST_WIDE_16 vAA, #+BBBB
+  DF_DA_WIDE | DF_SETS_CONST,
 
-    // 17 CONST_WIDE_32 vAA, #+BBBBBBBB
-    DF_DA_WIDE | DF_SETS_CONST,
+  // 17 CONST_WIDE_32 vAA, #+BBBBBBBB
+  DF_DA_WIDE | DF_SETS_CONST,
 
-    // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB
-    DF_DA_WIDE | DF_SETS_CONST,
+  // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB
+  DF_DA_WIDE | DF_SETS_CONST,
 
-    // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000
-    DF_DA_WIDE | DF_SETS_CONST,
+  // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000
+  DF_DA_WIDE | DF_SETS_CONST,
 
-    // 1A CONST_STRING vAA, string@BBBB
-    DF_DA | DF_CORE_A,
+  // 1A CONST_STRING vAA, string@BBBB
+  DF_DA | DF_CORE_A,
 
-    // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB
-    DF_DA | DF_CORE_A,
+  // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB
+  DF_DA | DF_CORE_A,
 
-    // 1C CONST_CLASS vAA, type@BBBB
-    DF_DA | DF_CORE_A,
+  // 1C CONST_CLASS vAA, type@BBBB
+  DF_DA | DF_CORE_A,
 
-    // 1D MONITOR_ENTER vAA
-    DF_UA | DF_NULL_CHK_0 | DF_CORE_A,
+  // 1D MONITOR_ENTER vAA
+  DF_UA | DF_NULL_CHK_0 | DF_CORE_A,
 
-    // 1E MONITOR_EXIT vAA
-    DF_UA | DF_NULL_CHK_0 | DF_CORE_A,
+  // 1E MONITOR_EXIT vAA
+  DF_UA | DF_NULL_CHK_0 | DF_CORE_A,
 
-    // 1F CHK_CAST vAA, type@BBBB
-    DF_UA | DF_CORE_A | DF_UMS,
+  // 1F CHK_CAST vAA, type@BBBB
+  DF_UA | DF_CORE_A | DF_UMS,
 
-    // 20 INSTANCE_OF vA, vB, type@CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B | DF_UMS,
+  // 20 INSTANCE_OF vA, vB, type@CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B | DF_UMS,
 
-    // 21 ARRAY_LENGTH vA, vB
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_A | DF_CORE_B,
+  // 21 ARRAY_LENGTH vA, vB
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_A | DF_CORE_B,
 
-    // 22 NEW_INSTANCE vAA, type@BBBB
-    DF_DA | DF_NON_NULL_DST | DF_CORE_A | DF_UMS,
+  // 22 NEW_INSTANCE vAA, type@BBBB
+  DF_DA | DF_NON_NULL_DST | DF_CORE_A | DF_UMS,
 
-    // 23 NEW_ARRAY vA, vB, type@CCCC
-    DF_DA | DF_UB | DF_NON_NULL_DST | DF_CORE_A | DF_CORE_B | DF_UMS,
+  // 23 NEW_ARRAY vA, vB, type@CCCC
+  DF_DA | DF_UB | DF_NON_NULL_DST | DF_CORE_A | DF_CORE_B | DF_UMS,
 
-    // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_NON_NULL_RET | DF_UMS,
+  // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_NON_NULL_RET | DF_UMS,
 
-    // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB
-    DF_FORMAT_3RC | DF_NON_NULL_RET | DF_UMS,
+  // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB
+  DF_FORMAT_3RC | DF_NON_NULL_RET | DF_UMS,
 
-    // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB
-    DF_UA | DF_CORE_A | DF_UMS,
+  // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB
+  DF_UA | DF_CORE_A | DF_UMS,
 
-    // 27 THROW vAA
-    DF_UA | DF_CORE_A | DF_UMS,
+  // 27 THROW vAA
+  DF_UA | DF_CORE_A | DF_UMS,
 
-    // 28 GOTO
-    DF_NOP,
+  // 28 GOTO
+  DF_NOP,
 
-    // 29 GOTO_16
-    DF_NOP,
+  // 29 GOTO_16
+  DF_NOP,
 
-    // 2A GOTO_32
-    DF_NOP,
+  // 2A GOTO_32
+  DF_NOP,
 
-    // 2B PACKED_SWITCH vAA, +BBBBBBBB
-    DF_UA,
+  // 2B PACKED_SWITCH vAA, +BBBBBBBB
+  DF_UA,
 
-    // 2C SPARSE_SWITCH vAA, +BBBBBBBB
-    DF_UA,
+  // 2C SPARSE_SWITCH vAA, +BBBBBBBB
+  DF_UA,
 
-    // 2D CMPL_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_B | DF_FP_C | DF_CORE_A,
+  // 2D CMPL_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_B | DF_FP_C | DF_CORE_A,
 
-    // 2E CMPG_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_B | DF_FP_C | DF_CORE_A,
+  // 2E CMPG_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_B | DF_FP_C | DF_CORE_A,
 
-    // 2F CMPL_DOUBLE vAA, vBB, vCC
-    DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_FP_B | DF_FP_C | DF_CORE_A,
+  // 2F CMPL_DOUBLE vAA, vBB, vCC
+  DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_FP_B | DF_FP_C | DF_CORE_A,
 
-    // 30 CMPG_DOUBLE vAA, vBB, vCC
-    DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_FP_B | DF_FP_C | DF_CORE_A,
+  // 30 CMPG_DOUBLE vAA, vBB, vCC
+  DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_FP_B | DF_FP_C | DF_CORE_A,
 
-    // 31 CMP_LONG vAA, vBB, vCC
-    DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 31 CMP_LONG vAA, vBB, vCC
+  DF_DA | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 32 IF_EQ vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 32 IF_EQ vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 33 IF_NE vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 33 IF_NE vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 34 IF_LT vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 34 IF_LT vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 35 IF_GE vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 35 IF_GE vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 36 IF_GT vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 36 IF_GT vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 37 IF_LE vA, vB, +CCCC
-    DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 37 IF_LE vA, vB, +CCCC
+  DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
 
-    // 38 IF_EQZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 38 IF_EQZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 39 IF_NEZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 39 IF_NEZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 3A IF_LTZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 3A IF_LTZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 3B IF_GEZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 3B IF_GEZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 3C IF_GTZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 3C IF_GTZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 3D IF_LEZ vAA, +BBBB
-    DF_UA | DF_CORE_A,
+  // 3D IF_LEZ vAA, +BBBB
+  DF_UA | DF_CORE_A,
 
-    // 3E UNUSED_3E
-    DF_NOP,
+  // 3E UNUSED_3E
+  DF_NOP,
 
-    // 3F UNUSED_3F
-    DF_NOP,
+  // 3F UNUSED_3F
+  DF_NOP,
 
-    // 40 UNUSED_40
-    DF_NOP,
+  // 40 UNUSED_40
+  DF_NOP,
 
-    // 41 UNUSED_41
-    DF_NOP,
+  // 41 UNUSED_41
+  DF_NOP,
 
-    // 42 UNUSED_42
-    DF_NOP,
+  // 42 UNUSED_42
+  DF_NOP,
 
-    // 43 UNUSED_43
-    DF_NOP,
+  // 43 UNUSED_43
+  DF_NOP,
 
-    // 44 AGET vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 44 AGET vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 45 AGET_WIDE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 45 AGET_WIDE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 46 AGET_OBJECT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 46 AGET_OBJECT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 47 AGET_BOOLEAN vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 47 AGET_BOOLEAN vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 48 AGET_BYTE vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 48 AGET_BYTE vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 49 AGET_CHAR vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 49 AGET_CHAR vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 4A AGET_SHORT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
+  // 4A AGET_SHORT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_NULL_CHK_0 | DF_RANGE_CHK_1 | DF_CORE_B | DF_CORE_C,
 
-    // 4B APUT vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 4B APUT vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 4C APUT_WIDE vAA, vBB, vCC
-    DF_UA_WIDE | DF_UB | DF_UC | DF_NULL_CHK_2 | DF_RANGE_CHK_3 | DF_CORE_B | DF_CORE_C,
+  // 4C APUT_WIDE vAA, vBB, vCC
+  DF_UA_WIDE | DF_UB | DF_UC | DF_NULL_CHK_2 | DF_RANGE_CHK_3 | DF_CORE_B | DF_CORE_C,
 
-    // 4D APUT_OBJECT vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 4D APUT_OBJECT vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 4E APUT_BOOLEAN vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 4E APUT_BOOLEAN vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 4F APUT_BYTE vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 4F APUT_BYTE vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 50 APUT_CHAR vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 50 APUT_CHAR vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 51 APUT_SHORT vAA, vBB, vCC
-    DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
+  // 51 APUT_SHORT vAA, vBB, vCC
+  DF_UA | DF_UB | DF_UC | DF_NULL_CHK_1 | DF_RANGE_CHK_2 | DF_CORE_B | DF_CORE_C,
 
-    // 52 IGET vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 52 IGET vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 53 IGET_WIDE vA, vB, field@CCCC
-    DF_DA_WIDE | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 53 IGET_WIDE vA, vB, field@CCCC
+  DF_DA_WIDE | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 54 IGET_OBJECT vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 54 IGET_OBJECT vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 55 IGET_BOOLEAN vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 55 IGET_BOOLEAN vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 56 IGET_BYTE vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 56 IGET_BYTE vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 57 IGET_CHAR vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 57 IGET_CHAR vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 58 IGET_SHORT vA, vB, field@CCCC
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // 58 IGET_SHORT vA, vB, field@CCCC
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // 59 IPUT vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 59 IPUT vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 5A IPUT_WIDE vA, vB, field@CCCC
-    DF_UA_WIDE | DF_UB | DF_NULL_CHK_2 | DF_CORE_B,
+  // 5A IPUT_WIDE vA, vB, field@CCCC
+  DF_UA_WIDE | DF_UB | DF_NULL_CHK_2 | DF_CORE_B,
 
-    // 5B IPUT_OBJECT vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 5B IPUT_OBJECT vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 5C IPUT_BOOLEAN vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 5C IPUT_BOOLEAN vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 5D IPUT_BYTE vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 5D IPUT_BYTE vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 5E IPUT_CHAR vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 5E IPUT_CHAR vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 5F IPUT_SHORT vA, vB, field@CCCC
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // 5F IPUT_SHORT vA, vB, field@CCCC
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // 60 SGET vAA, field@BBBB
-    DF_DA | DF_UMS,
+  // 60 SGET vAA, field@BBBB
+  DF_DA | DF_UMS,
 
-    // 61 SGET_WIDE vAA, field@BBBB
-    DF_DA_WIDE | DF_UMS,
+  // 61 SGET_WIDE vAA, field@BBBB
+  DF_DA_WIDE | DF_UMS,
 
-    // 62 SGET_OBJECT vAA, field@BBBB
-    DF_DA | DF_CORE_A | DF_UMS,
+  // 62 SGET_OBJECT vAA, field@BBBB
+  DF_DA | DF_CORE_A | DF_UMS,
 
-    // 63 SGET_BOOLEAN vAA, field@BBBB
-    DF_DA | DF_UMS,
+  // 63 SGET_BOOLEAN vAA, field@BBBB
+  DF_DA | DF_UMS,
 
-    // 64 SGET_BYTE vAA, field@BBBB
-    DF_DA | DF_UMS,
+  // 64 SGET_BYTE vAA, field@BBBB
+  DF_DA | DF_UMS,
 
-    // 65 SGET_CHAR vAA, field@BBBB
-    DF_DA | DF_UMS,
+  // 65 SGET_CHAR vAA, field@BBBB
+  DF_DA | DF_UMS,
 
-    // 66 SGET_SHORT vAA, field@BBBB
-    DF_DA | DF_UMS,
+  // 66 SGET_SHORT vAA, field@BBBB
+  DF_DA | DF_UMS,
 
-    // 67 SPUT vAA, field@BBBB
-    DF_UA | DF_UMS,
+  // 67 SPUT vAA, field@BBBB
+  DF_UA | DF_UMS,
 
-    // 68 SPUT_WIDE vAA, field@BBBB
-    DF_UA_WIDE | DF_UMS,
+  // 68 SPUT_WIDE vAA, field@BBBB
+  DF_UA_WIDE | DF_UMS,
 
-    // 69 SPUT_OBJECT vAA, field@BBBB
-    DF_UA | DF_CORE_A | DF_UMS,
+  // 69 SPUT_OBJECT vAA, field@BBBB
+  DF_UA | DF_CORE_A | DF_UMS,
 
-    // 6A SPUT_BOOLEAN vAA, field@BBBB
-    DF_UA | DF_UMS,
+  // 6A SPUT_BOOLEAN vAA, field@BBBB
+  DF_UA | DF_UMS,
 
-    // 6B SPUT_BYTE vAA, field@BBBB
-    DF_UA | DF_UMS,
+  // 6B SPUT_BYTE vAA, field@BBBB
+  DF_UA | DF_UMS,
 
-    // 6C SPUT_CHAR vAA, field@BBBB
-    DF_UA | DF_UMS,
+  // 6C SPUT_CHAR vAA, field@BBBB
+  DF_UA | DF_UMS,
 
-    // 6D SPUT_SHORT vAA, field@BBBB
-    DF_UA | DF_UMS,
+  // 6D SPUT_SHORT vAA, field@BBBB
+  DF_UA | DF_UMS,
 
-    // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 6F INVOKE_SUPER {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 6F INVOKE_SUPER {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 71 INVOKE_STATIC {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_UMS,
+  // 71 INVOKE_STATIC {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_UMS,
 
-    // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA}
-    DF_FORMAT_35C | DF_UMS,
+  // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA}
+  DF_FORMAT_35C | DF_UMS,
 
-    // 73 UNUSED_73
-    DF_NOP,
+  // 73 UNUSED_73
+  DF_NOP,
 
-    // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN}
-    DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN}
+  DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN}
-    DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN}
+  DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN}
-    DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
+  // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN}
+  DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN}
-    DF_FORMAT_3RC | DF_UMS,
+  // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN}
+  DF_FORMAT_3RC | DF_UMS,
 
-    // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN}
-    DF_FORMAT_3RC | DF_UMS,
+  // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN}
+  DF_FORMAT_3RC | DF_UMS,
 
-    // 79 UNUSED_79
-    DF_NOP,
+  // 79 UNUSED_79
+  DF_NOP,
 
-    // 7A UNUSED_7A
-    DF_NOP,
+  // 7A UNUSED_7A
+  DF_NOP,
 
-    // 7B NEG_INT vA, vB
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 7B NEG_INT vA, vB
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 7C NOT_INT vA, vB
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 7C NOT_INT vA, vB
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 7D NEG_LONG vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // 7D NEG_LONG vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // 7E NOT_LONG vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // 7E NOT_LONG vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // 7F NEG_FLOAT vA, vB
-    DF_DA | DF_UB | DF_FP_A | DF_FP_B,
+  // 7F NEG_FLOAT vA, vB
+  DF_DA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // 80 NEG_DOUBLE vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // 80 NEG_DOUBLE vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // 81 INT_TO_LONG vA, vB
-    DF_DA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 81 INT_TO_LONG vA, vB
+  DF_DA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 82 INT_TO_FLOAT vA, vB
-    DF_DA | DF_UB | DF_FP_A | DF_CORE_B,
+  // 82 INT_TO_FLOAT vA, vB
+  DF_DA | DF_UB | DF_FP_A | DF_CORE_B,
 
-    // 83 INT_TO_DOUBLE vA, vB
-    DF_DA_WIDE | DF_UB | DF_FP_A | DF_CORE_B,
+  // 83 INT_TO_DOUBLE vA, vB
+  DF_DA_WIDE | DF_UB | DF_FP_A | DF_CORE_B,
 
-    // 84 LONG_TO_INT vA, vB
-    DF_DA | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // 84 LONG_TO_INT vA, vB
+  DF_DA | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // 85 LONG_TO_FLOAT vA, vB
-    DF_DA | DF_UB_WIDE | DF_FP_A | DF_CORE_B,
+  // 85 LONG_TO_FLOAT vA, vB
+  DF_DA | DF_UB_WIDE | DF_FP_A | DF_CORE_B,
 
-    // 86 LONG_TO_DOUBLE vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_FP_A | DF_CORE_B,
+  // 86 LONG_TO_DOUBLE vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_FP_A | DF_CORE_B,
 
-    // 87 FLOAT_TO_INT vA, vB
-    DF_DA | DF_UB | DF_FP_B | DF_CORE_A,
+  // 87 FLOAT_TO_INT vA, vB
+  DF_DA | DF_UB | DF_FP_B | DF_CORE_A,
 
-    // 88 FLOAT_TO_LONG vA, vB
-    DF_DA_WIDE | DF_UB | DF_FP_B | DF_CORE_A,
+  // 88 FLOAT_TO_LONG vA, vB
+  DF_DA_WIDE | DF_UB | DF_FP_B | DF_CORE_A,
 
-    // 89 FLOAT_TO_DOUBLE vA, vB
-    DF_DA_WIDE | DF_UB | DF_FP_A | DF_FP_B,
+  // 89 FLOAT_TO_DOUBLE vA, vB
+  DF_DA_WIDE | DF_UB | DF_FP_A | DF_FP_B,
 
-    // 8A DOUBLE_TO_INT vA, vB
-    DF_DA | DF_UB_WIDE | DF_FP_B | DF_CORE_A,
+  // 8A DOUBLE_TO_INT vA, vB
+  DF_DA | DF_UB_WIDE | DF_FP_B | DF_CORE_A,
 
-    // 8B DOUBLE_TO_LONG vA, vB
-    DF_DA_WIDE | DF_UB_WIDE | DF_FP_B | DF_CORE_A,
+  // 8B DOUBLE_TO_LONG vA, vB
+  DF_DA_WIDE | DF_UB_WIDE | DF_FP_B | DF_CORE_A,
 
-    // 8C DOUBLE_TO_FLOAT vA, vB
-    DF_DA | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // 8C DOUBLE_TO_FLOAT vA, vB
+  DF_DA | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // 8D INT_TO_BYTE vA, vB
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 8D INT_TO_BYTE vA, vB
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 8E INT_TO_CHAR vA, vB
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 8E INT_TO_CHAR vA, vB
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 8F INT_TO_SHORT vA, vB
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // 8F INT_TO_SHORT vA, vB
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // 90 ADD_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 90 ADD_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 91 SUB_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 91 SUB_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 92 MUL_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 92 MUL_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 93 DIV_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 93 DIV_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 94 REM_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 94 REM_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 95 AND_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 95 AND_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 96 OR_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 96 OR_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 97 XOR_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 97 XOR_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 98 SHL_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 98 SHL_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 99 SHR_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 99 SHR_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9A USHR_INT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9A USHR_INT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9B ADD_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9B ADD_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9C SUB_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9C SUB_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9D MUL_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9D MUL_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9E DIV_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9E DIV_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // 9F REM_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // 9F REM_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A0 AND_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A0 AND_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A1 OR_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A1 OR_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A2 XOR_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A2 XOR_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A3 SHL_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A3 SHL_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A4 SHR_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A4 SHR_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A5 USHR_LONG vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
+  // A5 USHR_LONG vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC | DF_CORE_A | DF_CORE_B | DF_CORE_C,
 
-    // A6 ADD_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
+  // A6 ADD_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // A7 SUB_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
+  // A7 SUB_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // A8 MUL_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
+  // A8 MUL_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // A9 DIV_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
+  // A9 DIV_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AA REM_FLOAT vAA, vBB, vCC
-    DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AA REM_FLOAT vAA, vBB, vCC
+  DF_DA | DF_UB | DF_UC | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AB ADD_DOUBLE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AB ADD_DOUBLE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AC SUB_DOUBLE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AC SUB_DOUBLE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AD MUL_DOUBLE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AD MUL_DOUBLE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AE DIV_DOUBLE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AE DIV_DOUBLE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // AF REM_DOUBLE vAA, vBB, vCC
-    DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
+  // AF REM_DOUBLE vAA, vBB, vCC
+  DF_DA_WIDE | DF_UB_WIDE | DF_UC_WIDE | DF_FP_A | DF_FP_B | DF_FP_C,
 
-    // B0 ADD_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B0 ADD_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B1 SUB_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B1 SUB_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B2 MUL_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B2 MUL_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B3 DIV_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B3 DIV_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B4 REM_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B4 REM_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B5 AND_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B5 AND_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B6 OR_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B6 OR_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B7 XOR_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B7 XOR_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B8 SHL_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B8 SHL_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // B9 SHR_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // B9 SHR_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // BA USHR_INT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // BA USHR_INT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // BB ADD_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // BB ADD_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // BC SUB_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // BC SUB_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // BD MUL_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // BD MUL_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // BE DIV_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // BE DIV_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // BF REM_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // BF REM_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // C0 AND_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // C0 AND_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // C1 OR_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // C1 OR_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // C2 XOR_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // C2 XOR_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // C3 SHL_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
+  // C3 SHL_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // C4 SHR_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
+  // C4 SHR_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // C5 USHR_LONG_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
+  // C5 USHR_LONG_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // C6 ADD_FLOAT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // C6 ADD_FLOAT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // C7 SUB_FLOAT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // C7 SUB_FLOAT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // C8 MUL_FLOAT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // C8 MUL_FLOAT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // C9 DIV_FLOAT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // C9 DIV_FLOAT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // CA REM_FLOAT_2ADDR vA, vB
-    DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // CA REM_FLOAT_2ADDR vA, vB
+  DF_DA | DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // CB ADD_DOUBLE_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // CB ADD_DOUBLE_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // CC SUB_DOUBLE_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // CC SUB_DOUBLE_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // CD MUL_DOUBLE_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // CD MUL_DOUBLE_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // CE DIV_DOUBLE_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // CE DIV_DOUBLE_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // CF REM_DOUBLE_2ADDR vA, vB
-    DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // CF REM_DOUBLE_2ADDR vA, vB
+  DF_DA_WIDE | DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // D0 ADD_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D0 ADD_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D1 RSUB_INT vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D1 RSUB_INT vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D2 MUL_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D2 MUL_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D3 DIV_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D3 DIV_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D4 REM_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D4 REM_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D5 AND_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D5 AND_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D6 OR_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D6 OR_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D7 XOR_INT_LIT16 vA, vB, #+CCCC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D7 XOR_INT_LIT16 vA, vB, #+CCCC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // D8 ADD_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B,
+  // D8 ADD_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_IS_LINEAR | DF_CORE_A | DF_CORE_B,
 
-    // D9 RSUB_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // D9 RSUB_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DA MUL_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DA MUL_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DB DIV_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DB DIV_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DC REM_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DC REM_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DD AND_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DD AND_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DE OR_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DE OR_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // DF XOR_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // DF XOR_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // E0 SHL_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // E0 SHL_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // E1 SHR_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // E1 SHR_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // E2 USHR_INT_LIT8 vAA, vBB, #+CC
-    DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
+  // E2 USHR_INT_LIT8 vAA, vBB, #+CC
+  DF_DA | DF_UB | DF_CORE_A | DF_CORE_B,
 
-    // E3 IGET_VOLATILE
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // E3 IGET_VOLATILE
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // E4 IPUT_VOLATILE
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
+  // E4 IPUT_VOLATILE
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_B,
 
-    // E5 SGET_VOLATILE
-    DF_DA | DF_UMS,
+  // E5 SGET_VOLATILE
+  DF_DA | DF_UMS,
 
-    // E6 SPUT_VOLATILE
-    DF_UA | DF_UMS,
+  // E6 SPUT_VOLATILE
+  DF_UA | DF_UMS,
 
-    // E7 IGET_OBJECT_VOLATILE
-    DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_A | DF_CORE_B,
+  // E7 IGET_OBJECT_VOLATILE
+  DF_DA | DF_UB | DF_NULL_CHK_0 | DF_CORE_A | DF_CORE_B,
 
-    // E8 IGET_WIDE_VOLATILE
-    DF_DA_WIDE | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
+  // E8 IGET_WIDE_VOLATILE
+  DF_DA_WIDE | DF_UB | DF_NULL_CHK_0 | DF_CORE_B,
 
-    // E9 IPUT_WIDE_VOLATILE
-    DF_UA_WIDE | DF_UB | DF_NULL_CHK_2 | DF_CORE_B,
+  // E9 IPUT_WIDE_VOLATILE
+  DF_UA_WIDE | DF_UB | DF_NULL_CHK_2 | DF_CORE_B,
 
-    // EA SGET_WIDE_VOLATILE
-    DF_DA_WIDE | DF_UMS,
+  // EA SGET_WIDE_VOLATILE
+  DF_DA_WIDE | DF_UMS,
 
-    // EB SPUT_WIDE_VOLATILE
-    DF_UA_WIDE | DF_UMS,
+  // EB SPUT_WIDE_VOLATILE
+  DF_UA_WIDE | DF_UMS,
 
-    // EC BREAKPOINT
-    DF_NOP,
+  // EC BREAKPOINT
+  DF_NOP,
 
-    // ED THROW_VERIFICATION_ERROR
-    DF_NOP | DF_UMS,
+  // ED THROW_VERIFICATION_ERROR
+  DF_NOP | DF_UMS,
 
-    // EE EXECUTE_INLINE
-    DF_FORMAT_35C,
+  // EE EXECUTE_INLINE
+  DF_FORMAT_35C,
 
-    // EF EXECUTE_INLINE_RANGE
-    DF_FORMAT_3RC,
+  // EF EXECUTE_INLINE_RANGE
+  DF_FORMAT_3RC,
 
-    // F0 INVOKE_OBJECT_INIT_RANGE
-    DF_NOP | DF_NULL_CHK_0,
+  // F0 INVOKE_OBJECT_INIT_RANGE
+  DF_NOP | DF_NULL_CHK_0,
 
-    // F1 RETURN_VOID_BARRIER
-    DF_NOP,
+  // F1 RETURN_VOID_BARRIER
+  DF_NOP,
 
-    // F2 IGET_QUICK
-    DF_DA | DF_UB | DF_NULL_CHK_0,
+  // F2 IGET_QUICK
+  DF_DA | DF_UB | DF_NULL_CHK_0,
 
-    // F3 IGET_WIDE_QUICK
-    DF_DA_WIDE | DF_UB | DF_NULL_CHK_0,
+  // F3 IGET_WIDE_QUICK
+  DF_DA_WIDE | DF_UB | DF_NULL_CHK_0,
 
-    // F4 IGET_OBJECT_QUICK
-    DF_DA | DF_UB | DF_NULL_CHK_0,
+  // F4 IGET_OBJECT_QUICK
+  DF_DA | DF_UB | DF_NULL_CHK_0,
 
-    // F5 IPUT_QUICK
-    DF_UA | DF_UB | DF_NULL_CHK_1,
+  // F5 IPUT_QUICK
+  DF_UA | DF_UB | DF_NULL_CHK_1,
 
-    // F6 IPUT_WIDE_QUICK
-    DF_UA_WIDE | DF_UB | DF_NULL_CHK_2,
+  // F6 IPUT_WIDE_QUICK
+  DF_UA_WIDE | DF_UB | DF_NULL_CHK_2,
 
-    // F7 IPUT_OBJECT_QUICK
-    DF_UA | DF_UB | DF_NULL_CHK_1,
+  // F7 IPUT_OBJECT_QUICK
+  DF_UA | DF_UB | DF_NULL_CHK_1,
 
-    // F8 INVOKE_VIRTUAL_QUICK
-    DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
+  // F8 INVOKE_VIRTUAL_QUICK
+  DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // F9 INVOKE_VIRTUAL_QUICK_RANGE
-    DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
+  // F9 INVOKE_VIRTUAL_QUICK_RANGE
+  DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // FA INVOKE_SUPER_QUICK
-    DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
+  // FA INVOKE_SUPER_QUICK
+  DF_FORMAT_35C | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // FB INVOKE_SUPER_QUICK_RANGE
-    DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
+  // FB INVOKE_SUPER_QUICK_RANGE
+  DF_FORMAT_3RC | DF_NULL_CHK_OUT0 | DF_UMS,
 
-    // FC IPUT_OBJECT_VOLATILE
-    DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_A | DF_CORE_B,
+  // FC IPUT_OBJECT_VOLATILE
+  DF_UA | DF_UB | DF_NULL_CHK_1 | DF_CORE_A | DF_CORE_B,
 
-    // FD SGET_OBJECT_VOLATILE
-    DF_DA | DF_CORE_A | DF_UMS,
+  // FD SGET_OBJECT_VOLATILE
+  DF_DA | DF_CORE_A | DF_UMS,
 
-    // FE SPUT_OBJECT_VOLATILE
-    DF_UA | DF_CORE_A | DF_UMS,
+  // FE SPUT_OBJECT_VOLATILE
+  DF_UA | DF_CORE_A | DF_UMS,
 
-    // FF UNUSED_FF
-    DF_NOP,
+  // FF UNUSED_FF
+  DF_NOP,
 
-    // Beginning of extended MIR opcodes
-    // 100 MIR_PHI
-    DF_PHI | DF_DA | DF_NULL_TRANSFER_N,
+  // Beginning of extended MIR opcodes
+  // 100 MIR_PHI
+  DF_PHI | DF_DA | DF_NULL_TRANSFER_N,
 
-    // 101 MIR_COPY
-    DF_DA | DF_UB | DF_IS_MOVE,
+  // 101 MIR_COPY
+  DF_DA | DF_UB | DF_IS_MOVE,
 
-    // 102 MIR_FUSED_CMPL_FLOAT
-    DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // 102 MIR_FUSED_CMPL_FLOAT
+  DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // 103 MIR_FUSED_CMPG_FLOAT
-    DF_UA | DF_UB | DF_FP_A | DF_FP_B,
+  // 103 MIR_FUSED_CMPG_FLOAT
+  DF_UA | DF_UB | DF_FP_A | DF_FP_B,
 
-    // 104 MIR_FUSED_CMPL_DOUBLE
-    DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // 104 MIR_FUSED_CMPL_DOUBLE
+  DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // 105 MIR_FUSED_CMPG_DOUBLE
-    DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
+  // 105 MIR_FUSED_CMPG_DOUBLE
+  DF_UA_WIDE | DF_UB_WIDE | DF_FP_A | DF_FP_B,
 
-    // 106 MIR_FUSED_CMP_LONG
-    DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
+  // 106 MIR_FUSED_CMP_LONG
+  DF_UA_WIDE | DF_UB_WIDE | DF_CORE_A | DF_CORE_B,
 
-    // 107 MIR_NOP
-    DF_NOP,
+  // 107 MIR_NOP
+  DF_NOP,
 
-    // 108 MIR_NULL_RANGE_UP_CHECK
-    0,
+  // 108 MIR_NULL_RANGE_UP_CHECK
+  0,
 
-    // 109 MIR_NULL_RANGE_DOWN_CHECK
-    0,
+  // 109 MIR_NULL_RANGE_DOWN_CHECK
+  0,
 
-    // 110 MIR_LOWER_BOUND
-    0,
+  // 110 MIR_LOWER_BOUND
+  0,
 };
 
 /* Return the base virtual register for a SSA name */
 int SRegToVReg(const CompilationUnit* cUnit, int ssaReg)
 {
-    DCHECK_LT(ssaReg, (int)cUnit->ssaBaseVRegs->numUsed);
-    return GET_ELEM_N(cUnit->ssaBaseVRegs, int, ssaReg);
+  DCHECK_LT(ssaReg, (int)cUnit->ssaBaseVRegs->numUsed);
+  return GET_ELEM_N(cUnit->ssaBaseVRegs, int, ssaReg);
 }
 
 int SRegToSubscript(const CompilationUnit* cUnit, int ssaReg)
 {
-    DCHECK(ssaReg < (int)cUnit->ssaSubscripts->numUsed);
-    return GET_ELEM_N(cUnit->ssaSubscripts, int, ssaReg);
+  DCHECK(ssaReg < (int)cUnit->ssaSubscripts->numUsed);
+  return GET_ELEM_N(cUnit->ssaSubscripts, int, ssaReg);
 }
 
 int getSSAUseCount(CompilationUnit* cUnit, int sReg)
 {
-    DCHECK(sReg < (int)cUnit->rawUseCounts.numUsed);
-    return cUnit->rawUseCounts.elemList[sReg];
+  DCHECK(sReg < (int)cUnit->rawUseCounts.numUsed);
+  return cUnit->rawUseCounts.elemList[sReg];
 }
 
 
 char* oatGetDalvikDisassembly(CompilationUnit* cUnit,
                               const DecodedInstruction& insn, const char* note)
 {
-    char buffer[256];
-    Instruction::Code opcode = insn.opcode;
-    int dfAttributes = oatDataFlowAttributes[opcode];
-    int flags;
-    char* ret;
+  char buffer[256];
+  Instruction::Code opcode = insn.opcode;
+  int dfAttributes = oatDataFlowAttributes[opcode];
+  int flags;
+  char* ret;
 
-    buffer[0] = 0;
-    if ((int)opcode >= (int)kMirOpFirst) {
-        if ((int)opcode == (int)kMirOpPhi) {
-            strcpy(buffer, "PHI");
-        } else {
-            sprintf(buffer, "Opcode %#x", opcode);
-        }
-        flags = 0;
+  buffer[0] = 0;
+  if ((int)opcode >= (int)kMirOpFirst) {
+    if ((int)opcode == (int)kMirOpPhi) {
+      strcpy(buffer, "PHI");
     } else {
-        strcpy(buffer, Instruction::Name(opcode));
-        flags = Instruction::Flags(opcode);
+      sprintf(buffer, "Opcode %#x", opcode);
     }
+    flags = 0;
+  } else {
+    strcpy(buffer, Instruction::Name(opcode));
+    flags = Instruction::Flags(opcode);
+  }
 
-    if (note)
-        strcat(buffer, note);
+  if (note)
+    strcat(buffer, note);
 
-    /* For branches, decode the instructions to print out the branch targets */
-    if (flags & Instruction::kBranch) {
-        Instruction::Format dalvikFormat = Instruction::FormatOf(insn.opcode);
-        int offset = 0;
-        switch (dalvikFormat) {
-            case Instruction::k21t:
-                snprintf(buffer + strlen(buffer), 256, " v%d,", insn.vA);
-                offset = (int) insn.vB;
-                break;
-            case Instruction::k22t:
-                snprintf(buffer + strlen(buffer), 256, " v%d, v%d,", insn.vA, insn.vB);
-                offset = (int) insn.vC;
-                break;
-            case Instruction::k10t:
-            case Instruction::k20t:
-            case Instruction::k30t:
-                offset = (int) insn.vA;
-                break;
-            default:
-                LOG(FATAL) << "Unexpected branch format " << (int)dalvikFormat
-                    << " / opcode " << (int)opcode;
-        }
-        snprintf(buffer + strlen(buffer), 256, " (%c%x)",
-                 offset > 0 ? '+' : '-',
-                 offset > 0 ? offset : -offset);
-    } else if (dfAttributes & DF_FORMAT_35C) {
-        unsigned int i;
-        for (i = 0; i < insn.vA; i++) {
-            if (i != 0) strcat(buffer, ",");
-            snprintf(buffer + strlen(buffer), 256, " v%d", insn.arg[i]);
-        }
+  /* For branches, decode the instructions to print out the branch targets */
+  if (flags & Instruction::kBranch) {
+    Instruction::Format dalvikFormat = Instruction::FormatOf(insn.opcode);
+    int offset = 0;
+    switch (dalvikFormat) {
+      case Instruction::k21t:
+        snprintf(buffer + strlen(buffer), 256, " v%d,", insn.vA);
+        offset = (int) insn.vB;
+        break;
+      case Instruction::k22t:
+        snprintf(buffer + strlen(buffer), 256, " v%d, v%d,", insn.vA, insn.vB);
+        offset = (int) insn.vC;
+        break;
+      case Instruction::k10t:
+      case Instruction::k20t:
+      case Instruction::k30t:
+        offset = (int) insn.vA;
+        break;
+      default:
+        LOG(FATAL) << "Unexpected branch format " << (int)dalvikFormat
+                   << " / opcode " << (int)opcode;
     }
-    else if (dfAttributes & DF_FORMAT_3RC) {
-        snprintf(buffer + strlen(buffer), 256,
-                 " v%d..v%d", insn.vC, insn.vC + insn.vA - 1);
+    snprintf(buffer + strlen(buffer), 256, " (%c%x)",
+             offset > 0 ? '+' : '-',
+             offset > 0 ? offset : -offset);
+  } else if (dfAttributes & DF_FORMAT_35C) {
+    unsigned int i;
+    for (i = 0; i < insn.vA; i++) {
+      if (i != 0) strcat(buffer, ",");
+        snprintf(buffer + strlen(buffer), 256, " v%d", insn.arg[i]);
     }
-    else {
-        if (dfAttributes & DF_A_IS_REG) {
-            snprintf(buffer + strlen(buffer), 256, " v%d", insn.vA);
-        }
-        if (dfAttributes & DF_B_IS_REG) {
-            snprintf(buffer + strlen(buffer), 256, ", v%d", insn.vB);
-        }
-        else if ((int)opcode < (int)kMirOpFirst) {
-            snprintf(buffer + strlen(buffer), 256, ", (#%d)", insn.vB);
-        }
-        if (dfAttributes & DF_C_IS_REG) {
-            snprintf(buffer + strlen(buffer), 256, ", v%d", insn.vC);
-        }
-        else if ((int)opcode < (int)kMirOpFirst) {
-            snprintf(buffer + strlen(buffer), 256, ", (#%d)", insn.vC);
-        }
+  }
+  else if (dfAttributes & DF_FORMAT_3RC) {
+    snprintf(buffer + strlen(buffer), 256,
+             " v%d..v%d", insn.vC, insn.vC + insn.vA - 1);
+  } else {
+    if (dfAttributes & DF_A_IS_REG) {
+      snprintf(buffer + strlen(buffer), 256, " v%d", insn.vA);
     }
-    int length = strlen(buffer) + 1;
-    ret = (char*)oatNew(cUnit, length, false, kAllocDFInfo);
-    memcpy(ret, buffer, length);
-    return ret;
+    if (dfAttributes & DF_B_IS_REG) {
+      snprintf(buffer + strlen(buffer), 256, ", v%d", insn.vB);
+    } else if ((int)opcode < (int)kMirOpFirst) {
+      snprintf(buffer + strlen(buffer), 256, ", (#%d)", insn.vB);
+    }
+    if (dfAttributes & DF_C_IS_REG) {
+      snprintf(buffer + strlen(buffer), 256, ", v%d", insn.vC);
+    } else if ((int)opcode < (int)kMirOpFirst) {
+      snprintf(buffer + strlen(buffer), 256, ", (#%d)", insn.vC);
+    }
+  }
+  int length = strlen(buffer) + 1;
+  ret = (char*)oatNew(cUnit, length, false, kAllocDFInfo);
+  memcpy(ret, buffer, length);
+  return ret;
 }
 
 char* getSSAName(const CompilationUnit* cUnit, int ssaReg, char* name)
 {
-    sprintf(name, "v%d_%d", SRegToVReg(cUnit, ssaReg),
-            SRegToSubscript(cUnit, ssaReg));
-    return name;
+  sprintf(name, "v%d_%d", SRegToVReg(cUnit, ssaReg),
+          SRegToSubscript(cUnit, ssaReg));
+  return name;
 }
 
 /*
@@ -949,156 +946,154 @@
  */
 char* oatFullDisassembler(CompilationUnit* cUnit, const MIR* mir)
 {
-    char buffer[256];
-    char operand0[32], operand1[32];
-    const DecodedInstruction* insn = &mir->dalvikInsn;
-    Instruction::Code opcode = insn->opcode;
-    int dfAttributes = oatDataFlowAttributes[opcode];
-    char* ret;
-    int length;
+  char buffer[256];
+  char operand0[32], operand1[32];
+  const DecodedInstruction* insn = &mir->dalvikInsn;
+  Instruction::Code opcode = insn->opcode;
+  int dfAttributes = oatDataFlowAttributes[opcode];
+  char* ret;
+  int length;
 
-    buffer[0] = 0;
-    if (static_cast<int>(opcode) >= static_cast<int>(kMirOpFirst)) {
-        if (static_cast<int>(opcode) == static_cast<int>(kMirOpPhi)) {
-            snprintf(buffer, 256, "PHI %s = (%s",
-                     getSSAName(cUnit, mir->ssaRep->defs[0], operand0),
-                     getSSAName(cUnit, mir->ssaRep->uses[0], operand1));
-            int i;
-            for (i = 1; i < mir->ssaRep->numUses; i++) {
-                snprintf(buffer + strlen(buffer), 256, ", %s",
-                         getSSAName(cUnit, mir->ssaRep->uses[i], operand0));
-            }
-            snprintf(buffer + strlen(buffer), 256, ")");
-        }
-        else {
-            sprintf(buffer, "Opcode %#x", opcode);
-        }
-        goto done;
+  buffer[0] = 0;
+  if (static_cast<int>(opcode) >= static_cast<int>(kMirOpFirst)) {
+    if (static_cast<int>(opcode) == static_cast<int>(kMirOpPhi)) {
+      snprintf(buffer, 256, "PHI %s = (%s",
+               getSSAName(cUnit, mir->ssaRep->defs[0], operand0),
+               getSSAName(cUnit, mir->ssaRep->uses[0], operand1));
+      int i;
+      for (i = 1; i < mir->ssaRep->numUses; i++) {
+        snprintf(buffer + strlen(buffer), 256, ", %s",
+        getSSAName(cUnit, mir->ssaRep->uses[i], operand0));
+      }
+      snprintf(buffer + strlen(buffer), 256, ")");
     } else {
-        strcpy(buffer, Instruction::Name(opcode));
+      sprintf(buffer, "Opcode %#x", opcode);
     }
+    goto done;
+  } else {
+    strcpy(buffer, Instruction::Name(opcode));
+  }
 
-    /* For branches, decode the instructions to print out the branch targets */
-    if (Instruction::Flags(insn->opcode) & Instruction::kBranch) {
-        Instruction::Format dalvikFormat = Instruction::FormatOf(insn->opcode);
-        int delta = 0;
+  /* For branches, decode the instructions to print out the branch targets */
+  if (Instruction::Flags(insn->opcode) & Instruction::kBranch) {
+    Instruction::Format dalvikFormat = Instruction::FormatOf(insn->opcode);
+    int delta = 0;
+    switch (dalvikFormat) {
+      case Instruction::k21t:
+        snprintf(buffer + strlen(buffer), 256, " %s, ",
+                 getSSAName(cUnit, mir->ssaRep->uses[0], operand0));
+        delta = (int) insn->vB;
+        break;
+      case Instruction::k22t:
+        snprintf(buffer + strlen(buffer), 256, " %s, %s, ",
+                 getSSAName(cUnit, mir->ssaRep->uses[0], operand0),
+                 getSSAName(cUnit, mir->ssaRep->uses[1], operand1));
+        delta = (int) insn->vC;
+        break;
+      case Instruction::k10t:
+      case Instruction::k20t:
+      case Instruction::k30t:
+        delta = (int) insn->vA;
+        break;
+      default:
+        LOG(FATAL) << "Unexpected branch format: " << (int)dalvikFormat;
+      }
+      snprintf(buffer + strlen(buffer), 256, " %04x",
+               mir->offset + delta);
+  } else if (dfAttributes & (DF_FORMAT_35C | DF_FORMAT_3RC)) {
+    unsigned int i;
+    for (i = 0; i < insn->vA; i++) {
+      if (i != 0) strcat(buffer, ",");
+        snprintf(buffer + strlen(buffer), 256, " %s",
+                 getSSAName(cUnit, mir->ssaRep->uses[i], operand0));
+    }
+  } else {
+    int udIdx;
+    if (mir->ssaRep->numDefs) {
+
+      for (udIdx = 0; udIdx < mir->ssaRep->numDefs; udIdx++) {
+        snprintf(buffer + strlen(buffer), 256, " %s",
+                 getSSAName(cUnit, mir->ssaRep->defs[udIdx], operand0));
+      }
+      strcat(buffer, ",");
+    }
+    if (mir->ssaRep->numUses) {
+      /* No leading ',' for the first use */
+      snprintf(buffer + strlen(buffer), 256, " %s",
+               getSSAName(cUnit, mir->ssaRep->uses[0], operand0));
+      for (udIdx = 1; udIdx < mir->ssaRep->numUses; udIdx++) {
+        snprintf(buffer + strlen(buffer), 256, ", %s",
+                 getSSAName(cUnit, mir->ssaRep->uses[udIdx], operand0));
+        }
+      }
+      if (static_cast<int>(opcode) < static_cast<int>(kMirOpFirst)) {
+        Instruction::Format dalvikFormat = Instruction::FormatOf(opcode);
         switch (dalvikFormat) {
-            case Instruction::k21t:
-                snprintf(buffer + strlen(buffer), 256, " %s, ",
-                         getSSAName(cUnit, mir->ssaRep->uses[0], operand0));
-                delta = (int) insn->vB;
-                break;
-            case Instruction::k22t:
-                snprintf(buffer + strlen(buffer), 256, " %s, %s, ",
-                         getSSAName(cUnit, mir->ssaRep->uses[0], operand0),
-                         getSSAName(cUnit, mir->ssaRep->uses[1], operand1));
-                delta = (int) insn->vC;
-                break;
-            case Instruction::k10t:
-            case Instruction::k20t:
-            case Instruction::k30t:
-                delta = (int) insn->vA;
-                break;
-            default:
-                LOG(FATAL) << "Unexpected branch format: " <<
-                   (int)dalvikFormat;
+          case Instruction::k11n:        // op vA, #+B
+          case Instruction::k21s:        // op vAA, #+BBBB
+          case Instruction::k21h:        // op vAA, #+BBBB00000[00000000]
+          case Instruction::k31i:        // op vAA, #+BBBBBBBB
+          case Instruction::k51l:        // op vAA, #+BBBBBBBBBBBBBBBB
+            snprintf(buffer + strlen(buffer), 256, " #%#x", insn->vB);
+            break;
+          case Instruction::k21c:        // op vAA, thing@BBBB
+          case Instruction::k31c:        // op vAA, thing@BBBBBBBB
+            snprintf(buffer + strlen(buffer), 256, " @%#x", insn->vB);
+            break;
+          case Instruction::k22b:        // op vAA, vBB, #+CC
+          case Instruction::k22s:        // op vA, vB, #+CCCC
+            snprintf(buffer + strlen(buffer), 256, " #%#x", insn->vC);
+            break;
+          case Instruction::k22c:        // op vA, vB, thing@CCCC
+            snprintf(buffer + strlen(buffer), 256, " @%#x", insn->vC);
+            break;
+          /* No need for special printing */
+          default:
+            break;
         }
-        snprintf(buffer + strlen(buffer), 256, " %04x",
-                 mir->offset + delta);
-    } else if (dfAttributes & (DF_FORMAT_35C | DF_FORMAT_3RC)) {
-        unsigned int i;
-        for (i = 0; i < insn->vA; i++) {
-            if (i != 0) strcat(buffer, ",");
-            snprintf(buffer + strlen(buffer), 256, " %s",
-                     getSSAName(cUnit, mir->ssaRep->uses[i], operand0));
-        }
-    } else {
-        int udIdx;
-        if (mir->ssaRep->numDefs) {
-
-            for (udIdx = 0; udIdx < mir->ssaRep->numDefs; udIdx++) {
-                snprintf(buffer + strlen(buffer), 256, " %s",
-                         getSSAName(cUnit, mir->ssaRep->defs[udIdx], operand0));
-            }
-            strcat(buffer, ",");
-        }
-        if (mir->ssaRep->numUses) {
-            /* No leading ',' for the first use */
-            snprintf(buffer + strlen(buffer), 256, " %s",
-                     getSSAName(cUnit, mir->ssaRep->uses[0], operand0));
-            for (udIdx = 1; udIdx < mir->ssaRep->numUses; udIdx++) {
-                snprintf(buffer + strlen(buffer), 256, ", %s",
-                         getSSAName(cUnit, mir->ssaRep->uses[udIdx], operand0));
-            }
-        }
-        if (static_cast<int>(opcode) < static_cast<int>(kMirOpFirst)) {
-            Instruction::Format dalvikFormat = Instruction::FormatOf(opcode);
-            switch (dalvikFormat) {
-                case Instruction::k11n:        // op vA, #+B
-                case Instruction::k21s:        // op vAA, #+BBBB
-                case Instruction::k21h:        // op vAA, #+BBBB00000[00000000]
-                case Instruction::k31i:        // op vAA, #+BBBBBBBB
-                case Instruction::k51l:        // op vAA, #+BBBBBBBBBBBBBBBB
-                    snprintf(buffer + strlen(buffer), 256, " #%#x", insn->vB);
-                    break;
-                case Instruction::k21c:        // op vAA, thing@BBBB
-                case Instruction::k31c:        // op vAA, thing@BBBBBBBB
-                    snprintf(buffer + strlen(buffer), 256, " @%#x", insn->vB);
-                    break;
-                case Instruction::k22b:        // op vAA, vBB, #+CC
-                case Instruction::k22s:        // op vA, vB, #+CCCC
-                    snprintf(buffer + strlen(buffer), 256, " #%#x", insn->vC);
-                    break;
-                case Instruction::k22c:        // op vA, vB, thing@CCCC
-                    snprintf(buffer + strlen(buffer), 256, " @%#x", insn->vC);
-                    break;
-                    /* No need for special printing */
-                default:
-                    break;
-            }
-        }
-    }
+     }
+  }
 
 done:
-    length = strlen(buffer) + 1;
-    ret = (char*) oatNew(cUnit, length, false, kAllocDFInfo);
-    memcpy(ret, buffer, length);
-    return ret;
+  length = strlen(buffer) + 1;
+  ret = (char*) oatNew(cUnit, length, false, kAllocDFInfo);
+  memcpy(ret, buffer, length);
+  return ret;
 }
 
 char* oatGetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep)
 {
-    char buffer[256];
-    char* ret;
-    int i;
+  char buffer[256];
+  char* ret;
+  int i;
 
-    buffer[0] = 0;
-    for (i = 0; i < ssaRep->numDefs; i++) {
-        int ssaReg = ssaRep->defs[i];
-        sprintf(buffer + strlen(buffer), "s%d(v%d_%d) ", ssaReg,
-                SRegToVReg(cUnit, ssaReg), SRegToSubscript(cUnit, ssaReg));
+  buffer[0] = 0;
+  for (i = 0; i < ssaRep->numDefs; i++) {
+    int ssaReg = ssaRep->defs[i];
+    sprintf(buffer + strlen(buffer), "s%d(v%d_%d) ", ssaReg,
+            SRegToVReg(cUnit, ssaReg), SRegToSubscript(cUnit, ssaReg));
+  }
+
+  if (ssaRep->numDefs) {
+    strcat(buffer, "<- ");
+  }
+
+  for (i = 0; i < ssaRep->numUses; i++) {
+    int len = strlen(buffer);
+    int ssaReg = ssaRep->uses[i];
+
+    if (snprintf(buffer + len, 250 - len, "s%d(v%d_%d) ", ssaReg,
+                 SRegToVReg(cUnit, ssaReg),
+                 SRegToSubscript(cUnit, ssaReg))) {
+      strcat(buffer, "...");
+      break;
     }
+  }
 
-    if (ssaRep->numDefs) {
-        strcat(buffer, "<- ");
-    }
-
-    for (i = 0; i < ssaRep->numUses; i++) {
-        int len = strlen(buffer);
-        int ssaReg = ssaRep->uses[i];
-
-        if (snprintf(buffer + len, 250 - len, "s%d(v%d_%d) ", ssaReg,
-                     SRegToVReg(cUnit, ssaReg),
-                     SRegToSubscript(cUnit, ssaReg))) {
-            strcat(buffer, "...");
-            break;
-        }
-    }
-
-    int length = strlen(buffer) + 1;
-    ret = (char*)oatNew(cUnit, length, false, kAllocDFInfo);
-    memcpy(ret, buffer, length);
-    return ret;
+  int length = strlen(buffer) + 1;
+  ret = (char*)oatNew(cUnit, length, false, kAllocDFInfo);
+  memcpy(ret, buffer, length);
+  return ret;
 }
 
 /* Any register that is used before being defined is considered live-in */
@@ -1106,17 +1101,17 @@
                             ArenaBitVector* defV, ArenaBitVector* liveInV,
                             int dalvikRegId)
 {
-    oatSetBit(cUnit, useV, dalvikRegId);
-    if (!oatIsBitSet(defV, dalvikRegId)) {
-        oatSetBit(cUnit, liveInV, dalvikRegId);
-    }
+  oatSetBit(cUnit, useV, dalvikRegId);
+  if (!oatIsBitSet(defV, dalvikRegId)) {
+    oatSetBit(cUnit, liveInV, dalvikRegId);
+  }
 }
 
 /* Mark a reg as being defined */
 inline void handleDef(CompilationUnit* cUnit, ArenaBitVector* defV,
                       int dalvikRegId)
 {
-    oatSetBit(cUnit, defV, dalvikRegId);
+  oatSetBit(cUnit, defV, dalvikRegId);
 }
 
 /*
@@ -1125,567 +1120,556 @@
  */
 bool oatFindLocalLiveIn(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    MIR* mir;
-    ArenaBitVector *useV, *defV, *liveInV;
+  MIR* mir;
+  ArenaBitVector *useV, *defV, *liveInV;
 
-    if (bb->dataFlowInfo == NULL) return false;
+  if (bb->dataFlowInfo == NULL) return false;
 
-    useV = bb->dataFlowInfo->useV =
-        oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapUse);
-    defV = bb->dataFlowInfo->defV =
-        oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapDef);
-    liveInV = bb->dataFlowInfo->liveInV =
-        oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
-                          kBitMapLiveIn);
+  useV = bb->dataFlowInfo->useV =
+      oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapUse);
+  defV = bb->dataFlowInfo->defV =
+      oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapDef);
+  liveInV = bb->dataFlowInfo->liveInV =
+      oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
+                        kBitMapLiveIn);
 
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        int dfAttributes =
-            oatDataFlowAttributes[mir->dalvikInsn.opcode];
-        DecodedInstruction *dInsn = &mir->dalvikInsn;
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
+    DecodedInstruction *dInsn = &mir->dalvikInsn;
 
-        if (dfAttributes & DF_HAS_USES) {
-            if (dfAttributes & DF_UA) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
-            } else if (dfAttributes & DF_UA_WIDE) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA+1);
-            }
-            if (dfAttributes & DF_UB) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
-            } else if (dfAttributes & DF_UB_WIDE) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB+1);
-            }
-            if (dfAttributes & DF_UC) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
-            } else if (dfAttributes & DF_UC_WIDE) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+1);
-            }
-        }
-        if (dfAttributes & DF_FORMAT_35C) {
-            for (unsigned int i = 0; i < dInsn->vA; i++) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->arg[i]);
-           }
-        }
-        if (dfAttributes & DF_FORMAT_3RC) {
-            for (unsigned int i = 0; i < dInsn->vA; i++) {
-                handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+i);
-           }
-        }
-        if (dfAttributes & DF_HAS_DEFS) {
-            handleDef(cUnit, defV, dInsn->vA);
-            if (dfAttributes & DF_DA_WIDE) {
-                handleDef(cUnit, defV, dInsn->vA+1);
-            }
-        }
+    if (dfAttributes & DF_HAS_USES) {
+      if (dfAttributes & DF_UA) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
+      } else if (dfAttributes & DF_UA_WIDE) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA+1);
+      }
+      if (dfAttributes & DF_UB) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
+      } else if (dfAttributes & DF_UB_WIDE) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB+1);
+      }
+      if (dfAttributes & DF_UC) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
+      } else if (dfAttributes & DF_UC_WIDE) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+1);
+      }
     }
-    return true;
+    if (dfAttributes & DF_FORMAT_35C) {
+      for (unsigned int i = 0; i < dInsn->vA; i++) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->arg[i]);
+      }
+    }
+    if (dfAttributes & DF_FORMAT_3RC) {
+      for (unsigned int i = 0; i < dInsn->vA; i++) {
+        handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+i);
+      }
+    }
+    if (dfAttributes & DF_HAS_DEFS) {
+      handleDef(cUnit, defV, dInsn->vA);
+      if (dfAttributes & DF_DA_WIDE) {
+        handleDef(cUnit, defV, dInsn->vA+1);
+      }
+    }
+  }
+  return true;
 }
 
 int addNewSReg(CompilationUnit* cUnit, int vReg)
 {
-    // Compiler temps always have a subscript of 0
-    int subscript = (vReg < 0) ? 0 : ++cUnit->SSALastDefs[vReg];
-    int ssaReg = cUnit->numSSARegs++;
-    oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, vReg);
-    oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, subscript);
-    DCHECK_EQ(cUnit->ssaBaseVRegs->numUsed, cUnit->ssaSubscripts->numUsed);
-    return ssaReg;
+  // Compiler temps always have a subscript of 0
+  int subscript = (vReg < 0) ? 0 : ++cUnit->SSALastDefs[vReg];
+  int ssaReg = cUnit->numSSARegs++;
+  oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, vReg);
+  oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, subscript);
+  DCHECK_EQ(cUnit->ssaBaseVRegs->numUsed, cUnit->ssaSubscripts->numUsed);
+  return ssaReg;
 }
 
 /* Find out the latest SSA register for a given Dalvik register */
 void handleSSAUse(CompilationUnit* cUnit, int* uses, int dalvikReg,
                   int regIndex)
 {
-    DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
-    uses[regIndex] = cUnit->vRegToSSAMap[dalvikReg];
+  DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
+  uses[regIndex] = cUnit->vRegToSSAMap[dalvikReg];
 }
 
 /* Setup a new SSA register for a given Dalvik register */
 void handleSSADef(CompilationUnit* cUnit, int* defs, int dalvikReg,
                   int regIndex)
 {
-    DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
-    int ssaReg = addNewSReg(cUnit, dalvikReg);
-    cUnit->vRegToSSAMap[dalvikReg] = ssaReg;
-    defs[regIndex] = ssaReg;
+  DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
+  int ssaReg = addNewSReg(cUnit, dalvikReg);
+  cUnit->vRegToSSAMap[dalvikReg] = ssaReg;
+  defs[regIndex] = ssaReg;
 }
 
 /* Look up new SSA names for format_35c instructions */
 void dataFlowSSAFormat35C(CompilationUnit* cUnit, MIR* mir)
 {
-    DecodedInstruction *dInsn = &mir->dalvikInsn;
-    int numUses = dInsn->vA;
-    int i;
+  DecodedInstruction *dInsn = &mir->dalvikInsn;
+  int numUses = dInsn->vA;
+  int i;
 
-    mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses, true,
+  mir->ssaRep->numUses = numUses;
+  mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses, true,
+                                    kAllocDFInfo);
+  // NOTE: will be filled in during type & size inference pass
+  mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses, true,
                                       kAllocDFInfo);
-    // NOTE: will be filled in during type & size inference pass
-    mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses, true,
-                                        kAllocDFInfo);
 
-    for (i = 0; i < numUses; i++) {
-        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
-    }
+  for (i = 0; i < numUses; i++) {
+    handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
+  }
 }
 
 /* Look up new SSA names for format_3rc instructions */
 void dataFlowSSAFormat3RC(CompilationUnit* cUnit, MIR* mir)
 {
-    DecodedInstruction *dInsn = &mir->dalvikInsn;
-    int numUses = dInsn->vA;
-    int i;
+  DecodedInstruction *dInsn = &mir->dalvikInsn;
+  int numUses = dInsn->vA;
+  int i;
 
-    mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses, true,
+  mir->ssaRep->numUses = numUses;
+  mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses, true,
+                                    kAllocDFInfo);
+  // NOTE: will be filled in during type & size inference pass
+  mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses, true,
                                       kAllocDFInfo);
-    // NOTE: will be filled in during type & size inference pass
-    mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses, true,
-                                        kAllocDFInfo);
 
-    for (i = 0; i < numUses; i++) {
-        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
-    }
+  for (i = 0; i < numUses; i++) {
+    handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
+  }
 }
 
 /* Entry function to convert a block into SSA representation */
 bool oatDoSSAConversion(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    MIR* mir;
+  MIR* mir;
 
-    if (bb->dataFlowInfo == NULL) return false;
+  if (bb->dataFlowInfo == NULL) return false;
 
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        mir->ssaRep = (struct SSARepresentation *)
-            oatNew(cUnit, sizeof(SSARepresentation), true, kAllocDFInfo);
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    mir->ssaRep = (struct SSARepresentation *)
+        oatNew(cUnit, sizeof(SSARepresentation), true, kAllocDFInfo);
 
-        int dfAttributes =
-            oatDataFlowAttributes[mir->dalvikInsn.opcode];
+    int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
 
-        // If not a pseudo-op, note non-leaf or can throw
-        if (static_cast<int>(mir->dalvikInsn.opcode) < static_cast<int>(kNumPackedOpcodes)) {
-            int flags = Instruction::Flags(mir->dalvikInsn.opcode);
+      // If not a pseudo-op, note non-leaf or can throw
+    if (static_cast<int>(mir->dalvikInsn.opcode) <
+        static_cast<int>(kNumPackedOpcodes)) {
+      int flags = Instruction::Flags(mir->dalvikInsn.opcode);
 
-            if (flags & Instruction::kThrow) {
-                cUnit->attrs &= ~METHOD_IS_THROW_FREE;
-            }
+      if (flags & Instruction::kThrow) {
+        cUnit->attrs &= ~METHOD_IS_THROW_FREE;
+      }
 
-            if (flags & Instruction::kInvoke) {
-                cUnit->attrs &= ~METHOD_IS_LEAF;
-            }
-        }
-
-        int numUses = 0;
-
-        if (dfAttributes & DF_FORMAT_35C) {
-            dataFlowSSAFormat35C(cUnit, mir);
-            continue;
-        }
-
-        if (dfAttributes & DF_FORMAT_3RC) {
-            dataFlowSSAFormat3RC(cUnit, mir);
-            continue;
-        }
-
-        if (dfAttributes & DF_HAS_USES) {
-            if (dfAttributes & DF_UA) {
-                numUses++;
-            } else if (dfAttributes & DF_UA_WIDE) {
-                numUses += 2;
-            }
-            if (dfAttributes & DF_UB) {
-                numUses++;
-            } else if (dfAttributes & DF_UB_WIDE) {
-                numUses += 2;
-            }
-            if (dfAttributes & DF_UC) {
-                numUses++;
-            } else if (dfAttributes & DF_UC_WIDE) {
-                numUses += 2;
-            }
-        }
-
-        if (numUses) {
-            mir->ssaRep->numUses = numUses;
-            mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses,
-                                              false, kAllocDFInfo);
-            mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses,
-                                                false, kAllocDFInfo);
-        }
-
-        int numDefs = 0;
-
-        if (dfAttributes & DF_HAS_DEFS) {
-            numDefs++;
-            if (dfAttributes & DF_DA_WIDE) {
-                numDefs++;
-            }
-        }
-
-        if (numDefs) {
-            mir->ssaRep->numDefs = numDefs;
-            mir->ssaRep->defs = (int *)oatNew(cUnit, sizeof(int) * numDefs,
-                                              false, kAllocDFInfo);
-            mir->ssaRep->fpDef = (bool *)oatNew(cUnit, sizeof(bool) * numDefs,
-                                                false, kAllocDFInfo);
-        }
-
-        DecodedInstruction *dInsn = &mir->dalvikInsn;
-
-        if (dfAttributes & DF_HAS_USES) {
-            numUses = 0;
-            if (dfAttributes & DF_UA) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
-            } else if (dfAttributes & DF_UA_WIDE) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA+1, numUses++);
-            }
-            if (dfAttributes & DF_UB) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
-            } else if (dfAttributes & DF_UB_WIDE) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB+1, numUses++);
-            }
-            if (dfAttributes & DF_UC) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
-            } else if (dfAttributes & DF_UC_WIDE) {
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
-                mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
-                handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+1, numUses++);
-            }
-        }
-        if (dfAttributes & DF_HAS_DEFS) {
-            mir->ssaRep->fpDef[0] = dfAttributes & DF_FP_A;
-            handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA, 0);
-            if (dfAttributes & DF_DA_WIDE) {
-                mir->ssaRep->fpDef[1] = dfAttributes & DF_FP_A;
-                handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA+1, 1);
-            }
-        }
+      if (flags & Instruction::kInvoke) {
+        cUnit->attrs &= ~METHOD_IS_LEAF;
+      }
     }
 
-    if (!cUnit->disableDataflow) {
-        /*
-         * Take a snapshot of Dalvik->SSA mapping at the end of each block. The
-         * input to PHI nodes can be derived from the snapshot of all
-         * predecessor blocks.
-         */
-        bb->dataFlowInfo->vRegToSSAMap =
-            (int *)oatNew(cUnit, sizeof(int) * cUnit->numDalvikRegisters, false,
-                          kAllocDFInfo);
+    int numUses = 0;
 
-        memcpy(bb->dataFlowInfo->vRegToSSAMap, cUnit->vRegToSSAMap,
-               sizeof(int) * cUnit->numDalvikRegisters);
+    if (dfAttributes & DF_FORMAT_35C) {
+      dataFlowSSAFormat35C(cUnit, mir);
+      continue;
     }
-    return true;
+
+    if (dfAttributes & DF_FORMAT_3RC) {
+      dataFlowSSAFormat3RC(cUnit, mir);
+      continue;
+    }
+
+    if (dfAttributes & DF_HAS_USES) {
+      if (dfAttributes & DF_UA) {
+        numUses++;
+      } else if (dfAttributes & DF_UA_WIDE) {
+        numUses += 2;
+      }
+      if (dfAttributes & DF_UB) {
+        numUses++;
+      } else if (dfAttributes & DF_UB_WIDE) {
+        numUses += 2;
+      }
+      if (dfAttributes & DF_UC) {
+        numUses++;
+      } else if (dfAttributes & DF_UC_WIDE) {
+        numUses += 2;
+      }
+    }
+
+    if (numUses) {
+      mir->ssaRep->numUses = numUses;
+      mir->ssaRep->uses = (int *)oatNew(cUnit, sizeof(int) * numUses,
+                                        false, kAllocDFInfo);
+      mir->ssaRep->fpUse = (bool *)oatNew(cUnit, sizeof(bool) * numUses,
+                                          false, kAllocDFInfo);
+    }
+
+    int numDefs = 0;
+
+    if (dfAttributes & DF_HAS_DEFS) {
+      numDefs++;
+      if (dfAttributes & DF_DA_WIDE) {
+        numDefs++;
+      }
+    }
+
+    if (numDefs) {
+      mir->ssaRep->numDefs = numDefs;
+      mir->ssaRep->defs = (int *)oatNew(cUnit, sizeof(int) * numDefs,
+                                        false, kAllocDFInfo);
+      mir->ssaRep->fpDef = (bool *)oatNew(cUnit, sizeof(bool) * numDefs,
+                                          false, kAllocDFInfo);
+    }
+
+    DecodedInstruction *dInsn = &mir->dalvikInsn;
+
+    if (dfAttributes & DF_HAS_USES) {
+      numUses = 0;
+      if (dfAttributes & DF_UA) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
+      } else if (dfAttributes & DF_UA_WIDE) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA+1, numUses++);
+      }
+      if (dfAttributes & DF_UB) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
+      } else if (dfAttributes & DF_UB_WIDE) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB+1, numUses++);
+      }
+      if (dfAttributes & DF_UC) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
+      } else if (dfAttributes & DF_UC_WIDE) {
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
+        mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
+        handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+1, numUses++);
+      }
+    }
+    if (dfAttributes & DF_HAS_DEFS) {
+      mir->ssaRep->fpDef[0] = dfAttributes & DF_FP_A;
+      handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA, 0);
+      if (dfAttributes & DF_DA_WIDE) {
+        mir->ssaRep->fpDef[1] = dfAttributes & DF_FP_A;
+        handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA+1, 1);
+      }
+    }
+  }
+
+  if (!cUnit->disableDataflow) {
+    /*
+     * Take a snapshot of Dalvik->SSA mapping at the end of each block. The
+     * input to PHI nodes can be derived from the snapshot of all
+     * predecessor blocks.
+     */
+    bb->dataFlowInfo->vRegToSSAMap =
+        (int *)oatNew(cUnit, sizeof(int) * cUnit->numDalvikRegisters, false,
+                      kAllocDFInfo);
+
+    memcpy(bb->dataFlowInfo->vRegToSSAMap, cUnit->vRegToSSAMap,
+           sizeof(int) * cUnit->numDalvikRegisters);
+  }
+  return true;
 }
 
 /* Setup a constant value for opcodes thare have the DF_SETS_CONST attribute */
 void setConstant(CompilationUnit* cUnit, int ssaReg, int value)
 {
-    oatSetBit(cUnit, cUnit->isConstantV, ssaReg);
-    cUnit->constantValues[ssaReg] = value;
+  oatSetBit(cUnit, cUnit->isConstantV, ssaReg);
+  cUnit->constantValues[ssaReg] = value;
 }
 
 bool oatDoConstantPropagation(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    MIR* mir;
-    ArenaBitVector *isConstantV = cUnit->isConstantV;
+  MIR* mir;
+  ArenaBitVector *isConstantV = cUnit->isConstantV;
 
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        int dfAttributes =
-            oatDataFlowAttributes[mir->dalvikInsn.opcode];
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
 
-        DecodedInstruction *dInsn = &mir->dalvikInsn;
+    DecodedInstruction *dInsn = &mir->dalvikInsn;
 
-        if (!(dfAttributes & DF_HAS_DEFS)) continue;
+    if (!(dfAttributes & DF_HAS_DEFS)) continue;
 
-        /* Handle instructions that set up constants directly */
-        if (dfAttributes & DF_SETS_CONST) {
-            if (dfAttributes & DF_DA) {
-                switch (dInsn->opcode) {
-                    case Instruction::CONST_4:
-                    case Instruction::CONST_16:
-                    case Instruction::CONST:
-                        setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
-                        break;
-                    case Instruction::CONST_HIGH16:
-                        setConstant(cUnit, mir->ssaRep->defs[0],
-                                    dInsn->vB << 16);
-                        break;
-                    default:
-                        break;
-                }
-            } else if (dfAttributes & DF_DA_WIDE) {
-                switch (dInsn->opcode) {
-                    case Instruction::CONST_WIDE_16:
-                    case Instruction::CONST_WIDE_32:
-                        setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
-                        setConstant(cUnit, mir->ssaRep->defs[1], 0);
-                        break;
-                    case Instruction::CONST_WIDE:
-                        setConstant(cUnit, mir->ssaRep->defs[0],
-                                    (int) dInsn->vB_wide);
-                        setConstant(cUnit, mir->ssaRep->defs[1],
-                                    (int) (dInsn->vB_wide >> 32));
-                        break;
-                    case Instruction::CONST_WIDE_HIGH16:
-                        setConstant(cUnit, mir->ssaRep->defs[0], 0);
-                        setConstant(cUnit, mir->ssaRep->defs[1],
-                                    dInsn->vB << 16);
-                        break;
-                    default:
-                        break;
-                }
+    /* Handle instructions that set up constants directly */
+    if (dfAttributes & DF_SETS_CONST) {
+      if (dfAttributes & DF_DA) {
+        switch (dInsn->opcode) {
+          case Instruction::CONST_4:
+          case Instruction::CONST_16:
+          case Instruction::CONST:
+            setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
+            break;
+          case Instruction::CONST_HIGH16:
+            setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB << 16);
+            break;
+          default:
+            break;
+              }
+          } else if (dfAttributes & DF_DA_WIDE) {
+            switch (dInsn->opcode) {
+              case Instruction::CONST_WIDE_16:
+              case Instruction::CONST_WIDE_32:
+                setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
+                setConstant(cUnit, mir->ssaRep->defs[1], 0);
+                break;
+              case Instruction::CONST_WIDE:
+                setConstant(cUnit, mir->ssaRep->defs[0], (int) dInsn->vB_wide);
+                setConstant(cUnit, mir->ssaRep->defs[1],
+                            (int) (dInsn->vB_wide >> 32));
+                break;
+              case Instruction::CONST_WIDE_HIGH16:
+                setConstant(cUnit, mir->ssaRep->defs[0], 0);
+                setConstant(cUnit, mir->ssaRep->defs[1], dInsn->vB << 16);
+                break;
+              default:
+                break;
             }
-        /* Handle instructions that set up constants directly */
-        } else if (dfAttributes & DF_IS_MOVE) {
-            int i;
+          }
+      /* Handle instructions that set up constants directly */
+      } else if (dfAttributes & DF_IS_MOVE) {
+        int i;
 
-            for (i = 0; i < mir->ssaRep->numUses; i++) {
-                if (!oatIsBitSet(isConstantV, mir->ssaRep->uses[i])) break;
-            }
-            /* Move a register holding a constant to another register */
-            if (i == mir->ssaRep->numUses) {
-                setConstant(cUnit, mir->ssaRep->defs[0],
-                            cUnit->constantValues[mir->ssaRep->uses[0]]);
-                if (dfAttributes & DF_DA_WIDE) {
-                    setConstant(cUnit, mir->ssaRep->defs[1],
-                                cUnit->constantValues[mir->ssaRep->uses[1]]);
-                }
-            }
+        for (i = 0; i < mir->ssaRep->numUses; i++) {
+          if (!oatIsBitSet(isConstantV, mir->ssaRep->uses[i])) break;
+      }
+      /* Move a register holding a constant to another register */
+      if (i == mir->ssaRep->numUses) {
+        setConstant(cUnit, mir->ssaRep->defs[0],
+                    cUnit->constantValues[mir->ssaRep->uses[0]]);
+        if (dfAttributes & DF_DA_WIDE) {
+          setConstant(cUnit, mir->ssaRep->defs[1],
+                      cUnit->constantValues[mir->ssaRep->uses[1]]);
         }
+      }
     }
-    /* TODO: implement code to handle arithmetic operations */
-    return true;
+  }
+  /* TODO: implement code to handle arithmetic operations */
+  return true;
 }
 
 /* Setup the basic data structures for SSA conversion */
 void oatInitializeSSAConversion(CompilationUnit* cUnit)
 {
-    int i;
-    int numDalvikReg = cUnit->numDalvikRegisters;
+  int i;
+  int numDalvikReg = cUnit->numDalvikRegisters;
 
-    cUnit->ssaBaseVRegs = (GrowableList *)oatNew(cUnit, sizeof(GrowableList),
-                                                 false, kAllocDFInfo);
-    cUnit->ssaSubscripts = (GrowableList *)oatNew(cUnit, sizeof(GrowableList),
-                                                  false, kAllocDFInfo);
-    // Create the ssa mappings, estimating the max size
-    oatInitGrowableList(cUnit, cUnit->ssaBaseVRegs,
-                        numDalvikReg + cUnit->defCount + 128,
-                        kListSSAtoDalvikMap);
-    oatInitGrowableList(cUnit, cUnit->ssaSubscripts,
-                        numDalvikReg + cUnit->defCount + 128,
-                        kListSSAtoDalvikMap);
-    /*
-     * Initial number of SSA registers is equal to the number of Dalvik
-     * registers.
-     */
-    cUnit->numSSARegs = numDalvikReg;
+  cUnit->ssaBaseVRegs = (GrowableList *)oatNew(cUnit, sizeof(GrowableList),
+                                               false, kAllocDFInfo);
+  cUnit->ssaSubscripts = (GrowableList *)oatNew(cUnit, sizeof(GrowableList),
+                                                false, kAllocDFInfo);
+  // Create the ssa mappings, estimating the max size
+  oatInitGrowableList(cUnit, cUnit->ssaBaseVRegs,
+                      numDalvikReg + cUnit->defCount + 128,
+                      kListSSAtoDalvikMap);
+  oatInitGrowableList(cUnit, cUnit->ssaSubscripts,
+                      numDalvikReg + cUnit->defCount + 128,
+                      kListSSAtoDalvikMap);
+  /*
+   * Initial number of SSA registers is equal to the number of Dalvik
+   * registers.
+   */
+  cUnit->numSSARegs = numDalvikReg;
 
-    /*
-     * Initialize the SSA2Dalvik map list. For the first numDalvikReg elements,
-     * the subscript is 0 so we use the ENCODE_REG_SUB macro to encode the value
-     * into "(0 << 16) | i"
-     */
-    for (i = 0; i < numDalvikReg; i++) {
-        oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, i);
-        oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, 0);
-    }
+  /*
+   * Initialize the SSA2Dalvik map list. For the first numDalvikReg elements,
+   * the subscript is 0 so we use the ENCODE_REG_SUB macro to encode the value
+   * into "(0 << 16) | i"
+   */
+  for (i = 0; i < numDalvikReg; i++) {
+    oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, i);
+    oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, 0);
+  }
 
-    /*
-     * Initialize the DalvikToSSAMap map. There is one entry for each
-     * Dalvik register, and the SSA names for those are the same.
-     */
-    cUnit->vRegToSSAMap = (int *)oatNew(cUnit, sizeof(int) * numDalvikReg,
-                                          false, kAllocDFInfo);
-    /* Keep track of the higest def for each dalvik reg */
-    cUnit->SSALastDefs = (int *)oatNew(cUnit, sizeof(int) * numDalvikReg,
-                                       false, kAllocDFInfo);
+  /*
+   * Initialize the DalvikToSSAMap map. There is one entry for each
+   * Dalvik register, and the SSA names for those are the same.
+   */
+  cUnit->vRegToSSAMap = (int *)oatNew(cUnit, sizeof(int) * numDalvikReg,
+                                      false, kAllocDFInfo);
+  /* Keep track of the higest def for each dalvik reg */
+  cUnit->SSALastDefs = (int *)oatNew(cUnit, sizeof(int) * numDalvikReg,
+                                     false, kAllocDFInfo);
 
-    for (i = 0; i < numDalvikReg; i++) {
-        cUnit->vRegToSSAMap[i] = i;
-        cUnit->SSALastDefs[i] = 0;
-    }
+  for (i = 0; i < numDalvikReg; i++) {
+    cUnit->vRegToSSAMap[i] = i;
+    cUnit->SSALastDefs[i] = 0;
+  }
 
-    /* Add ssa reg for Method* */
-    cUnit->methodSReg = addNewSReg(cUnit, SSA_METHOD_BASEREG);
+  /* Add ssa reg for Method* */
+  cUnit->methodSReg = addNewSReg(cUnit, SSA_METHOD_BASEREG);
 
-    /*
-     * Allocate the BasicBlockDataFlow structure for the entry and code blocks
-     */
-    GrowableListIterator iterator;
+  /*
+   * Allocate the BasicBlockDataFlow structure for the entry and code blocks
+   */
+  GrowableListIterator iterator;
 
-    oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+  oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
 
-    while (true) {
-        BasicBlock* bb = (BasicBlock *) oatGrowableListIteratorNext(&iterator);
-        if (bb == NULL) break;
-        if (bb->hidden == true) continue;
-        if (bb->blockType == kDalvikByteCode ||
-            bb->blockType == kEntryBlock ||
-            bb->blockType == kExitBlock) {
-            bb->dataFlowInfo = (BasicBlockDataFlow *)
-                oatNew(cUnit, sizeof(BasicBlockDataFlow),
-                       true, kAllocDFInfo);
-        }
-    }
+  while (true) {
+    BasicBlock* bb = (BasicBlock *) oatGrowableListIteratorNext(&iterator);
+    if (bb == NULL) break;
+    if (bb->hidden == true) continue;
+    if (bb->blockType == kDalvikByteCode ||
+      bb->blockType == kEntryBlock ||
+      bb->blockType == kExitBlock) {
+      bb->dataFlowInfo = (BasicBlockDataFlow *)
+          oatNew(cUnit, sizeof(BasicBlockDataFlow), true, kAllocDFInfo);
+      }
+  }
 }
 
 /* Clear the visited flag for each BB */
 bool oatClearVisitedFlag(struct CompilationUnit* cUnit, struct BasicBlock* bb)
 {
-    bb->visited = false;
-    return true;
+  bb->visited = false;
+  return true;
 }
 
 void oatDataFlowAnalysisDispatcher(CompilationUnit* cUnit,
-                bool (*func)(CompilationUnit*, BasicBlock*),
-                DataFlowAnalysisMode dfaMode,
-                bool isIterative)
+                                   bool (*func)(CompilationUnit*, BasicBlock*),
+                                   DataFlowAnalysisMode dfaMode,
+                                   bool isIterative)
 {
-    bool change = true;
+  bool change = true;
 
-    while (change) {
-        change = false;
+  while (change) {
+    change = false;
 
-        switch (dfaMode) {
-        /* Scan all blocks and perform the operations specified in func */
-        case kAllNodes:
-            {
-                GrowableListIterator iterator;
-                oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
-                while (true) {
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListIteratorNext(&iterator);
-                    if (bb == NULL) break;
-                    if (bb->hidden == true) continue;
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-        /* Scan reachable blocks and perform the ops specified in func. */
-        case kReachableNodes:
-            {
-                int numReachableBlocks = cUnit->numReachableBlocks;
-                int idx;
-                const GrowableList *blockList = &cUnit->blockList;
-
-                for (idx = 0; idx < numReachableBlocks; idx++) {
-                    int blockIdx = cUnit->dfsOrder.elemList[idx];
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                 blockIdx);
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-
-        /* Scan reachable blocks by pre-order dfs and invoke func on each. */
-        case kPreOrderDFSTraversal:
-            {
-                int numReachableBlocks = cUnit->numReachableBlocks;
-                int idx;
-                const GrowableList *blockList = &cUnit->blockList;
-
-                for (idx = 0; idx < numReachableBlocks; idx++) {
-                    int dfsIdx = cUnit->dfsOrder.elemList[idx];
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                 dfsIdx);
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-        /* Scan reachable blocks post-order dfs and invoke func on each. */
-        case kPostOrderDFSTraversal:
-            {
-                int numReachableBlocks = cUnit->numReachableBlocks;
-                int idx;
-                const GrowableList *blockList = &cUnit->blockList;
-
-                for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
-                    int dfsIdx = cUnit->dfsOrder.elemList[idx];
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                 dfsIdx);
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-        /* Scan reachable post-order dom tree and invoke func on each. */
-        case kPostOrderDOMTraversal:
-            {
-                int numReachableBlocks = cUnit->numReachableBlocks;
-                int idx;
-                const GrowableList *blockList = &cUnit->blockList;
-
-                for (idx = 0; idx < numReachableBlocks; idx++) {
-                    int domIdx = cUnit->domPostOrderTraversal.elemList[idx];
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                 domIdx);
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-        /* Scan reachable blocks reverse post-order dfs, invoke func on each */
-        case kReversePostOrderTraversal:
-            {
-                int numReachableBlocks = cUnit->numReachableBlocks;
-                int idx;
-                const GrowableList *blockList = &cUnit->blockList;
-
-                for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
-                    int revIdx = cUnit->dfsPostOrder.elemList[idx];
-                    BasicBlock* bb =
-                        (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                 revIdx);
-                    change |= (*func)(cUnit, bb);
-                }
-            }
-            break;
-        default:
-            LOG(FATAL) << "Unknown traversal mode " << (int)dfaMode;
+    switch (dfaMode) {
+      /* Scan all blocks and perform the operations specified in func */
+      case kAllNodes:
+        {
+          GrowableListIterator iterator;
+          oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+          while (true) {
+            BasicBlock* bb =
+                (BasicBlock *) oatGrowableListIteratorNext(&iterator);
+            if (bb == NULL) break;
+            if (bb->hidden == true) continue;
+              change |= (*func)(cUnit, bb);
+          }
         }
-        /* If isIterative is false, exit the loop after the first iteration */
-        change &= isIterative;
+        break;
+      /* Scan reachable blocks and perform the ops specified in func. */
+      case kReachableNodes:
+        {
+          int numReachableBlocks = cUnit->numReachableBlocks;
+          int idx;
+          const GrowableList *blockList = &cUnit->blockList;
+
+          for (idx = 0; idx < numReachableBlocks; idx++) {
+            int blockIdx = cUnit->dfsOrder.elemList[idx];
+            BasicBlock* bb = (BasicBlock *)
+                oatGrowableListGetElement(blockList, blockIdx);
+            change |= (*func)(cUnit, bb);
+          }
+        }
+        break;
+
+      /* Scan reachable blocks by pre-order dfs and invoke func on each. */
+      case kPreOrderDFSTraversal:
+        {
+          int numReachableBlocks = cUnit->numReachableBlocks;
+          int idx;
+          const GrowableList *blockList = &cUnit->blockList;
+
+          for (idx = 0; idx < numReachableBlocks; idx++) {
+            int dfsIdx = cUnit->dfsOrder.elemList[idx];
+            BasicBlock* bb = (BasicBlock *)
+                oatGrowableListGetElement(blockList, dfsIdx);
+            change |= (*func)(cUnit, bb);
+            }
+        }
+        break;
+      /* Scan reachable blocks post-order dfs and invoke func on each. */
+      case kPostOrderDFSTraversal:
+        {
+          int numReachableBlocks = cUnit->numReachableBlocks;
+          int idx;
+          const GrowableList *blockList = &cUnit->blockList;
+
+          for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
+            int dfsIdx = cUnit->dfsOrder.elemList[idx];
+            BasicBlock* bb = (BasicBlock *)
+                oatGrowableListGetElement(blockList, dfsIdx);
+            change |= (*func)(cUnit, bb);
+            }
+        }
+        break;
+      /* Scan reachable post-order dom tree and invoke func on each. */
+      case kPostOrderDOMTraversal:
+        {
+          int numReachableBlocks = cUnit->numReachableBlocks;
+          int idx;
+          const GrowableList *blockList = &cUnit->blockList;
+
+          for (idx = 0; idx < numReachableBlocks; idx++) {
+            int domIdx = cUnit->domPostOrderTraversal.elemList[idx];
+            BasicBlock* bb = (BasicBlock *)
+                oatGrowableListGetElement(blockList, domIdx);
+            change |= (*func)(cUnit, bb);
+          }
+        }
+        break;
+      /* Scan reachable blocks reverse post-order dfs, invoke func on each */
+      case kReversePostOrderTraversal:
+        {
+          int numReachableBlocks = cUnit->numReachableBlocks;
+          int idx;
+          const GrowableList *blockList = &cUnit->blockList;
+
+          for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
+            int revIdx = cUnit->dfsPostOrder.elemList[idx];
+            BasicBlock* bb = (BasicBlock *)
+                oatGrowableListGetElement(blockList, revIdx);
+            change |= (*func)(cUnit, bb);
+            }
+        }
+        break;
+      default:
+        LOG(FATAL) << "Unknown traversal mode " << (int)dfaMode;
     }
+    /* If isIterative is false, exit the loop after the first iteration */
+    change &= isIterative;
+  }
 }
 
 /* Advance to next strictly dominated MIR node in an extended basic block */
-MIR* advanceMIR(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir, ArenaBitVector* bv,
-                bool clearMark) {
-    BasicBlock* bb = *pBb;
-    if (mir != NULL) {
-        mir = mir->next;
-        if (mir == NULL) {
-            bb = bb->fallThrough;
-            if ((bb == NULL) || bb->predecessors->numUsed != 1) {
-                mir = NULL;
-            } else {
-                if (bv) {
-                    oatSetBit(cUnit, bv, bb->id);
-                }
-                *pBb = bb;
-                mir = bb->firstMIRInsn;
-            }
+MIR* advanceMIR(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir,
+                ArenaBitVector* bv, bool clearMark) {
+  BasicBlock* bb = *pBb;
+  if (mir != NULL) {
+    mir = mir->next;
+    if (mir == NULL) {
+      bb = bb->fallThrough;
+      if ((bb == NULL) || bb->predecessors->numUsed != 1) {
+        mir = NULL;
+      } else {
+        if (bv) {
+          oatSetBit(cUnit, bv, bb->id);
         }
+      *pBb = bb;
+      mir = bb->firstMIRInsn;
+      }
     }
-    if (mir && clearMark) {
-        mir->optimizationFlags &= ~MIR_MARK;
-    }
-    return mir;
+  }
+  if (mir && clearMark) {
+    mir->optimizationFlags &= ~MIR_MARK;
+  }
+  return mir;
 }
 
 /*
@@ -1696,563 +1680,562 @@
  * used, a move-result may not be present.
  */
 MIR* oatFindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
-                       bool wide)
+                     bool wide)
 {
-    BasicBlock* tbb = bb;
-    mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
-    while (mir != NULL) {
-        if (!wide && mir->dalvikInsn.opcode == Instruction::MOVE_RESULT) {
-            break;
-        }
-        if (wide && mir->dalvikInsn.opcode == Instruction::MOVE_RESULT_WIDE) {
-            break;
-        }
-        // Keep going if pseudo op, otherwise terminate
-        if (mir->dalvikInsn.opcode < static_cast<Instruction::Code>(kNumPackedOpcodes)) {
-            mir = NULL;
-        } else {
-            mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
-        }
+  BasicBlock* tbb = bb;
+  mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
+  while (mir != NULL) {
+    if (!wide && mir->dalvikInsn.opcode == Instruction::MOVE_RESULT) {
+      break;
     }
-    return mir;
+    if (wide && mir->dalvikInsn.opcode == Instruction::MOVE_RESULT_WIDE) {
+      break;
+    }
+    // Keep going if pseudo op, otherwise terminate
+    if (mir->dalvikInsn.opcode <
+        static_cast<Instruction::Code>(kNumPackedOpcodes)) {
+      mir = NULL;
+    } else {
+      mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
+    }
+  }
+  return mir;
 }
 
 void squashDupRangeChecks(CompilationUnit* cUnit, BasicBlock** pBp, MIR* mir,
-                          int arraySreg, int indexSreg)
+                        int arraySreg, int indexSreg)
 {
-    while (true) {
-       mir = advanceMIR(cUnit, pBp, mir, NULL, false);
-       if (!mir) {
-           break;
-       }
-       if ((mir->ssaRep == NULL) ||
-           (mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
-           continue;
-       }
-       int checkArray = INVALID_SREG;
-       int checkIndex = INVALID_SREG;
-       switch (mir->dalvikInsn.opcode) {
-            case Instruction::AGET:
-            case Instruction::AGET_OBJECT:
-            case Instruction::AGET_BOOLEAN:
-            case Instruction::AGET_BYTE:
-            case Instruction::AGET_CHAR:
-            case Instruction::AGET_SHORT:
-            case Instruction::AGET_WIDE:
-                checkArray = mir->ssaRep->uses[0];
-                checkIndex = mir->ssaRep->uses[1];
-                break;
-                break;
-            case Instruction::APUT:
-            case Instruction::APUT_OBJECT:
-            case Instruction::APUT_SHORT:
-            case Instruction::APUT_CHAR:
-            case Instruction::APUT_BYTE:
-            case Instruction::APUT_BOOLEAN:
-                checkArray = mir->ssaRep->uses[1];
-                checkIndex = mir->ssaRep->uses[2];
-                break;
-            case Instruction::APUT_WIDE:
-                checkArray = mir->ssaRep->uses[2];
-                checkIndex = mir->ssaRep->uses[3];
-            default:
-                break;
-       }
-       if (checkArray == INVALID_SREG) {
-           continue;
-       }
-       if ((arraySreg == checkArray) && (indexSreg == checkIndex)) {
-           if (cUnit->printMe) {
-               LOG(INFO) << "Squashing range check @ 0x" << std::hex
-                         << mir->offset;
-           }
-           mir->optimizationFlags |= MIR_IGNORE_RANGE_CHECK;
-       }
+  while (true) {
+    mir = advanceMIR(cUnit, pBp, mir, NULL, false);
+    if (!mir) {
+      break;
     }
+    if ((mir->ssaRep == NULL) ||
+        (mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
+       continue;
+    }
+    int checkArray = INVALID_SREG;
+    int checkIndex = INVALID_SREG;
+    switch (mir->dalvikInsn.opcode) {
+      case Instruction::AGET:
+      case Instruction::AGET_OBJECT:
+      case Instruction::AGET_BOOLEAN:
+      case Instruction::AGET_BYTE:
+      case Instruction::AGET_CHAR:
+      case Instruction::AGET_SHORT:
+      case Instruction::AGET_WIDE:
+        checkArray = mir->ssaRep->uses[0];
+        checkIndex = mir->ssaRep->uses[1];
+        break;
+      case Instruction::APUT:
+      case Instruction::APUT_OBJECT:
+      case Instruction::APUT_SHORT:
+      case Instruction::APUT_CHAR:
+      case Instruction::APUT_BYTE:
+      case Instruction::APUT_BOOLEAN:
+        checkArray = mir->ssaRep->uses[1];
+        checkIndex = mir->ssaRep->uses[2];
+        break;
+      case Instruction::APUT_WIDE:
+        checkArray = mir->ssaRep->uses[2];
+        checkIndex = mir->ssaRep->uses[3];
+      default:
+        break;
+    }
+    if (checkArray == INVALID_SREG) {
+      continue;
+    }
+    if ((arraySreg == checkArray) && (indexSreg == checkIndex)) {
+      if (cUnit->printMe) {
+        LOG(INFO) << "Squashing range check @ 0x" << std::hex << mir->offset;
+      }
+      mir->optimizationFlags |= MIR_IGNORE_RANGE_CHECK;
+    }
+  }
 }
 
 /* Allocate a compiler temp, return Sreg.  Reuse existing if no conflict */
 int allocCompilerTempSreg(CompilationUnit* cUnit, ArenaBitVector* bv)
 {
-    for (int i = 0; i < cUnit->numCompilerTemps; i++) {
-        CompilerTemp* ct = (CompilerTemp*)cUnit->compilerTemps.elemList[i];
-        ArenaBitVector* tBv = ct->bv;
-        if (!oatTestBitVectors(bv, tBv)) {
-            // Combine live maps and reuse existing temp
-            oatUnifyBitVectors(tBv, tBv, bv);
-            return ct->sReg;
-        }
+  for (int i = 0; i < cUnit->numCompilerTemps; i++) {
+    CompilerTemp* ct = (CompilerTemp*)cUnit->compilerTemps.elemList[i];
+    ArenaBitVector* tBv = ct->bv;
+    if (!oatTestBitVectors(bv, tBv)) {
+      // Combine live maps and reuse existing temp
+      oatUnifyBitVectors(tBv, tBv, bv);
+      return ct->sReg;
     }
+  }
 
-    // Create a new compiler temp & associated live bitmap
-    CompilerTemp* ct = (CompilerTemp*)oatNew(cUnit, sizeof(CompilerTemp),
-                                             true, kAllocMisc);
-    ArenaBitVector *nBv = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
-                                            kBitMapMisc);
-    oatCopyBitVector(nBv, bv);
-    ct->bv = nBv;
-    ct->sReg = addNewSReg(cUnit, SSA_CTEMP_BASEREG - cUnit->numCompilerTemps);
-    cUnit->numCompilerTemps++;
-    oatInsertGrowableList(cUnit, &cUnit->compilerTemps, (intptr_t)ct);
-    DCHECK_EQ(cUnit->numCompilerTemps, (int)cUnit->compilerTemps.numUsed);
-    return ct->sReg;
+  // Create a new compiler temp & associated live bitmap
+  CompilerTemp* ct = (CompilerTemp*)oatNew(cUnit, sizeof(CompilerTemp),
+                                           true, kAllocMisc);
+  ArenaBitVector *nBv = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
+                                          kBitMapMisc);
+  oatCopyBitVector(nBv, bv);
+  ct->bv = nBv;
+  ct->sReg = addNewSReg(cUnit, SSA_CTEMP_BASEREG - cUnit->numCompilerTemps);
+  cUnit->numCompilerTemps++;
+  oatInsertGrowableList(cUnit, &cUnit->compilerTemps, (intptr_t)ct);
+  DCHECK_EQ(cUnit->numCompilerTemps, (int)cUnit->compilerTemps.numUsed);
+  return ct->sReg;
 }
 
 /* Creata a new MIR node for a new pseudo op. */
-MIR* rawMIR(CompilationUnit* cUnit, Instruction::Code opcode, int defs, int uses)
+MIR* rawMIR(CompilationUnit* cUnit, Instruction::Code opcode, int defs,
+            int uses)
 {
-    MIR* res = (MIR*)oatNew( cUnit, sizeof(MIR), true, kAllocMIR);
-    res->ssaRep =(struct SSARepresentation *)
-            oatNew(cUnit, sizeof(SSARepresentation), true, kAllocDFInfo);
-    if (uses) {
-        res->ssaRep->numUses = uses;
-        res->ssaRep->uses = (int*)oatNew(cUnit, sizeof(int) * uses, false, kAllocDFInfo);
-    }
-    if (defs) {
-        res->ssaRep->numDefs = defs;
-        res->ssaRep->defs = (int*)oatNew(cUnit, sizeof(int) * defs, false, kAllocDFInfo);
-        res->ssaRep->fpDef = (bool*)oatNew(cUnit, sizeof(bool) * defs, true, kAllocDFInfo);
-    }
-    res->dalvikInsn.opcode = opcode;
-    return res;
+  MIR* res = (MIR*)oatNew( cUnit, sizeof(MIR), true, kAllocMIR);
+  res->ssaRep =(struct SSARepresentation *)
+      oatNew(cUnit, sizeof(SSARepresentation), true, kAllocDFInfo);
+  if (uses) {
+    res->ssaRep->numUses = uses;
+    res->ssaRep->uses = (int*)oatNew(cUnit, sizeof(int) * uses, false,
+                                     kAllocDFInfo);
+  }
+  if (defs) {
+    res->ssaRep->numDefs = defs;
+    res->ssaRep->defs = (int*)oatNew(cUnit, sizeof(int) * defs, false,
+                                     kAllocDFInfo);
+    res->ssaRep->fpDef = (bool*)oatNew(cUnit, sizeof(bool) * defs, true,
+                                       kAllocDFInfo);
+  }
+  res->dalvikInsn.opcode = opcode;
+  return res;
 }
 
 /* Do some MIR-level basic block optimizations */
 bool basicBlockOpt(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    int numTemps = 0;
+  int numTemps = 0;
 
-    for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        // Look for interesting opcodes, skip otherwise
-        Instruction::Code opcode = mir->dalvikInsn.opcode;
-        switch (opcode) {
-            case Instruction::AGET:
-            case Instruction::AGET_OBJECT:
-            case Instruction::AGET_BOOLEAN:
-            case Instruction::AGET_BYTE:
-            case Instruction::AGET_CHAR:
-            case Instruction::AGET_SHORT:
-            case Instruction::AGET_WIDE:
-                if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
-                    int arrSreg = mir->ssaRep->uses[0];
-                    int idxSreg = mir->ssaRep->uses[1];
-                    BasicBlock* tbb = bb;
-                    squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
-                }
-                break;
-            case Instruction::APUT:
-            case Instruction::APUT_OBJECT:
-            case Instruction::APUT_SHORT:
-            case Instruction::APUT_CHAR:
-            case Instruction::APUT_BYTE:
-            case Instruction::APUT_BOOLEAN:
-            case Instruction::APUT_WIDE:
-                if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
-                    int start = (opcode == Instruction::APUT_WIDE) ? 2 : 1;
-                    int arrSreg = mir->ssaRep->uses[start];
-                    int idxSreg = mir->ssaRep->uses[start + 1];
-                    BasicBlock* tbb = bb;
-                    squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
-                }
-                break;
-            case Instruction::CMPL_FLOAT:
-            case Instruction::CMPL_DOUBLE:
-            case Instruction::CMPG_FLOAT:
-            case Instruction::CMPG_DOUBLE:
-            case Instruction::CMP_LONG:
-                if (mir->next != NULL) {
-                    MIR* mirNext = mir->next;
-                    Instruction::Code brOpcode = mirNext->dalvikInsn.opcode;
-                    ConditionCode ccode = kCondNv;
-                    switch(brOpcode) {
-                        case Instruction::IF_EQZ:
-                            ccode = kCondEq;
-                            break;
-                        case Instruction::IF_NEZ:
-                            ccode = kCondNe;
-                            break;
-                        case Instruction::IF_LTZ:
-                            ccode = kCondLt;
-                            break;
-                        case Instruction::IF_GEZ:
-                            ccode = kCondGe;
-                            break;
-                        case Instruction::IF_GTZ:
-                            ccode = kCondGt;
-                            break;
-                        case Instruction::IF_LEZ:
-                            ccode = kCondLe;
-                            break;
-                        default:
-                            break;
-                    }
-                    // Make sure result of cmp is used by next insn and nowhere else
-                    if ((ccode != kCondNv) &&
-                        (mir->ssaRep->defs[0] == mirNext->ssaRep->uses[0]) &&
-                        (getSSAUseCount(cUnit, mir->ssaRep->defs[0]) == 1)) {
-                        mirNext->dalvikInsn.arg[0] = ccode;
-                        switch(opcode) {
-                            case Instruction::CMPL_FLOAT:
-                                mirNext->dalvikInsn.opcode =
-                                    static_cast<Instruction::Code>(kMirOpFusedCmplFloat);
-                                break;
-                            case Instruction::CMPL_DOUBLE:
-                                mirNext->dalvikInsn.opcode =
-                                    static_cast<Instruction::Code>(kMirOpFusedCmplDouble);
-                                break;
-                            case Instruction::CMPG_FLOAT:
-                                mirNext->dalvikInsn.opcode =
-                                    static_cast<Instruction::Code>(kMirOpFusedCmpgFloat);
-                                break;
-                            case Instruction::CMPG_DOUBLE:
-                                mirNext->dalvikInsn.opcode =
-                                    static_cast<Instruction::Code>(kMirOpFusedCmpgDouble);
-                                break;
-                            case Instruction::CMP_LONG:
-                                mirNext->dalvikInsn.opcode =
-                                    static_cast<Instruction::Code>(kMirOpFusedCmpLong);
-                                break;
-                            default: LOG(ERROR) << "Unexpected opcode: " << (int)opcode;
-                        }
-                        mir->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop);
-                        mirNext->ssaRep->numUses = mir->ssaRep->numUses;
-                        mirNext->ssaRep->uses = mir->ssaRep->uses;
-                        mirNext->ssaRep->fpUse = mir->ssaRep->fpUse;
-                        mirNext->ssaRep->numDefs = 0;
-                        mir->ssaRep->numUses = 0;
-                        mir->ssaRep->numDefs = 0;
-                    }
-                }
-                break;
-            default:
-                break;
+  for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    // Look for interesting opcodes, skip otherwise
+    Instruction::Code opcode = mir->dalvikInsn.opcode;
+    switch (opcode) {
+      case Instruction::AGET:
+      case Instruction::AGET_OBJECT:
+      case Instruction::AGET_BOOLEAN:
+      case Instruction::AGET_BYTE:
+      case Instruction::AGET_CHAR:
+      case Instruction::AGET_SHORT:
+      case Instruction::AGET_WIDE:
+        if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
+          int arrSreg = mir->ssaRep->uses[0];
+          int idxSreg = mir->ssaRep->uses[1];
+          BasicBlock* tbb = bb;
+          squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
         }
+        break;
+      case Instruction::APUT:
+      case Instruction::APUT_OBJECT:
+      case Instruction::APUT_SHORT:
+      case Instruction::APUT_CHAR:
+      case Instruction::APUT_BYTE:
+      case Instruction::APUT_BOOLEAN:
+      case Instruction::APUT_WIDE:
+        if (!(mir->optimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
+          int start = (opcode == Instruction::APUT_WIDE) ? 2 : 1;
+          int arrSreg = mir->ssaRep->uses[start];
+          int idxSreg = mir->ssaRep->uses[start + 1];
+          BasicBlock* tbb = bb;
+          squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
+        }
+        break;
+      case Instruction::CMPL_FLOAT:
+      case Instruction::CMPL_DOUBLE:
+      case Instruction::CMPG_FLOAT:
+      case Instruction::CMPG_DOUBLE:
+      case Instruction::CMP_LONG:
+        if (mir->next != NULL) {
+          MIR* mirNext = mir->next;
+          Instruction::Code brOpcode = mirNext->dalvikInsn.opcode;
+          ConditionCode ccode = kCondNv;
+          switch(brOpcode) {
+            case Instruction::IF_EQZ:
+              ccode = kCondEq;
+              break;
+            case Instruction::IF_NEZ:
+              ccode = kCondNe;
+              break;
+            case Instruction::IF_LTZ:
+              ccode = kCondLt;
+              break;
+            case Instruction::IF_GEZ:
+              ccode = kCondGe;
+              break;
+            case Instruction::IF_GTZ:
+              ccode = kCondGt;
+              break;
+            case Instruction::IF_LEZ:
+              ccode = kCondLe;
+              break;
+            default:
+              break;
+          }
+          // Make sure result of cmp is used by next insn and nowhere else
+          if ((ccode != kCondNv) &&
+              (mir->ssaRep->defs[0] == mirNext->ssaRep->uses[0]) &&
+              (getSSAUseCount(cUnit, mir->ssaRep->defs[0]) == 1)) {
+            mirNext->dalvikInsn.arg[0] = ccode;
+            switch(opcode) {
+              case Instruction::CMPL_FLOAT:
+                mirNext->dalvikInsn.opcode =
+                    static_cast<Instruction::Code>(kMirOpFusedCmplFloat);
+                break;
+              case Instruction::CMPL_DOUBLE:
+                mirNext->dalvikInsn.opcode =
+                    static_cast<Instruction::Code>(kMirOpFusedCmplDouble);
+                break;
+              case Instruction::CMPG_FLOAT:
+                mirNext->dalvikInsn.opcode =
+                    static_cast<Instruction::Code>(kMirOpFusedCmpgFloat);
+                break;
+              case Instruction::CMPG_DOUBLE:
+                mirNext->dalvikInsn.opcode =
+                    static_cast<Instruction::Code>(kMirOpFusedCmpgDouble);
+                break;
+              case Instruction::CMP_LONG:
+                mirNext->dalvikInsn.opcode =
+                    static_cast<Instruction::Code>(kMirOpFusedCmpLong);
+                break;
+              default: LOG(ERROR) << "Unexpected opcode: " << (int)opcode;
+            }
+            mir->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop);
+            mirNext->ssaRep->numUses = mir->ssaRep->numUses;
+            mirNext->ssaRep->uses = mir->ssaRep->uses;
+            mirNext->ssaRep->fpUse = mir->ssaRep->fpUse;
+            mirNext->ssaRep->numDefs = 0;
+            mir->ssaRep->numUses = 0;
+            mir->ssaRep->numDefs = 0;
+          }
+        }
+        break;
+      default:
+        break;
     }
+  }
 
-    if (numTemps > cUnit->numCompilerTemps) {
-        cUnit->numCompilerTemps = numTemps;
-    }
-    return true;
+  if (numTemps > cUnit->numCompilerTemps) {
+    cUnit->numCompilerTemps = numTemps;
+  }
+  return true;
 }
 
 bool nullCheckEliminationInit(struct CompilationUnit* cUnit,
                               struct BasicBlock* bb)
 {
-    if (bb->dataFlowInfo == NULL) return false;
-    bb->dataFlowInfo->endingNullCheckV =
-        oatAllocBitVector(cUnit, cUnit->numSSARegs, false, kBitMapNullCheck);
-    oatClearAllBits(bb->dataFlowInfo->endingNullCheckV);
-    return true;
+  if (bb->dataFlowInfo == NULL) return false;
+  bb->dataFlowInfo->endingNullCheckV =
+      oatAllocBitVector(cUnit, cUnit->numSSARegs, false, kBitMapNullCheck);
+  oatClearAllBits(bb->dataFlowInfo->endingNullCheckV);
+  return true;
 }
 
 /* Eliminate unnecessary null checks for a basic block. */
 bool eliminateNullChecks( struct CompilationUnit* cUnit, struct BasicBlock* bb)
 {
-    if (bb->dataFlowInfo == NULL) return false;
+  if (bb->dataFlowInfo == NULL) return false;
+
+  /*
+   * Set initial state.  Be conservative with catch
+   * blocks and start with no assumptions about null check
+   * status (except for "this").
+   */
+  if ((bb->blockType == kEntryBlock) | bb->catchEntry) {
+    oatClearAllBits(cUnit->tempSSARegisterV);
+    if ((cUnit->access_flags & kAccStatic) == 0) {
+      // If non-static method, mark "this" as non-null
+      int thisReg = cUnit->numDalvikRegisters - cUnit->numIns;
+      oatSetBit(cUnit, cUnit->tempSSARegisterV, thisReg);
+    }
+  } else {
+    // Starting state is intesection of all incoming arcs
+    GrowableListIterator iter;
+    oatGrowableListIteratorInit(bb->predecessors, &iter);
+    BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+    DCHECK(predBB != NULL);
+    oatCopyBitVector(cUnit->tempSSARegisterV,
+                     predBB->dataFlowInfo->endingNullCheckV);
+    while (true) {
+      predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+      if (!predBB) break;
+      if ((predBB->dataFlowInfo == NULL) ||
+          (predBB->dataFlowInfo->endingNullCheckV == NULL)) {
+        continue;
+      }
+      oatIntersectBitVectors(cUnit->tempSSARegisterV,
+                             cUnit->tempSSARegisterV,
+                             predBB->dataFlowInfo->endingNullCheckV);
+    }
+  }
+
+  // Walk through the instruction in the block, updating as necessary
+  for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    if (mir->ssaRep == NULL) {
+        continue;
+    }
+    int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
+
+    // Mark target of NEW* as non-null
+    if (dfAttributes & DF_NON_NULL_DST) {
+      oatSetBit(cUnit, cUnit->tempSSARegisterV, mir->ssaRep->defs[0]);
+    }
+
+    // Mark non-null returns from invoke-style NEW*
+    if (dfAttributes & DF_NON_NULL_RET) {
+      MIR* nextMir = mir->next;
+      // Next should be an MOVE_RESULT_OBJECT
+      if (nextMir &&
+          nextMir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
+        // Mark as null checked
+        oatSetBit(cUnit, cUnit->tempSSARegisterV, nextMir->ssaRep->defs[0]);
+      } else {
+        if (nextMir) {
+          LOG(WARNING) << "Unexpected opcode following new: "
+                       << (int)nextMir->dalvikInsn.opcode;
+        } else if (bb->fallThrough) {
+          // Look in next basic block
+          struct BasicBlock* nextBB = bb->fallThrough;
+          for (MIR* tmir = nextBB->firstMIRInsn; tmir;
+            tmir =tmir->next) {
+            if ((int)tmir->dalvikInsn.opcode >= (int)kMirOpFirst) {
+              continue;
+            }
+            // First non-pseudo should be MOVE_RESULT_OBJECT
+            if (tmir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
+              // Mark as null checked
+              oatSetBit(cUnit, cUnit->tempSSARegisterV, tmir->ssaRep->defs[0]);
+            } else {
+              LOG(WARNING) << "Unexpected op after new: "
+                           << (int)tmir->dalvikInsn.opcode;
+            }
+            break;
+          }
+        }
+      }
+    }
 
     /*
-     * Set initial state.  Be conservative with catch
-     * blocks and start with no assumptions about null check
-     * status (except for "this").
+     * Propagate nullcheck state on register copies (including
+     * Phi pseudo copies.  For the latter, nullcheck state is
+     * the "and" of all the Phi's operands.
      */
-    if ((bb->blockType == kEntryBlock) | bb->catchEntry) {
-        oatClearAllBits(cUnit->tempSSARegisterV);
-        if ((cUnit->access_flags & kAccStatic) == 0) {
-            // If non-static method, mark "this" as non-null
-            int thisReg = cUnit->numDalvikRegisters - cUnit->numIns;
-            oatSetBit(cUnit, cUnit->tempSSARegisterV, thisReg);
-        }
-    } else {
-        // Starting state is intesection of all incoming arcs
-        GrowableListIterator iter;
-        oatGrowableListIteratorInit(bb->predecessors, &iter);
-        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-        DCHECK(predBB != NULL);
-        oatCopyBitVector(cUnit->tempSSARegisterV,
-                         predBB->dataFlowInfo->endingNullCheckV);
-        while (true) {
-            predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-            if (!predBB) break;
-            if ((predBB->dataFlowInfo == NULL) ||
-                (predBB->dataFlowInfo->endingNullCheckV == NULL)) {
-                continue;
-            }
-            oatIntersectBitVectors(cUnit->tempSSARegisterV,
-                cUnit->tempSSARegisterV,
-                predBB->dataFlowInfo->endingNullCheckV);
-        }
+    if (dfAttributes & (DF_NULL_TRANSFER_0 | DF_NULL_TRANSFER_N)) {
+      int tgtSreg = mir->ssaRep->defs[0];
+      int operands = (dfAttributes & DF_NULL_TRANSFER_0) ? 1 :
+          mir->ssaRep->numUses;
+      bool nullChecked = true;
+      for (int i = 0; i < operands; i++) {
+        nullChecked &= oatIsBitSet(cUnit->tempSSARegisterV,
+        mir->ssaRep->uses[i]);
+      }
+      if (nullChecked) {
+        oatSetBit(cUnit, cUnit->tempSSARegisterV, tgtSreg);
+      }
     }
 
-    // Walk through the instruction in the block, updating as necessary
-    for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        if (mir->ssaRep == NULL) {
-            continue;
+    // Already nullchecked?
+    if (dfAttributes & DF_HAS_NULL_CHKS) {
+      int srcIdx;
+      if (dfAttributes & DF_NULL_CHK_1) {
+        srcIdx = 1;
+      } else if (dfAttributes & DF_NULL_CHK_2) {
+        srcIdx = 2;
+      } else {
+        srcIdx = 0;
+      }
+      int srcSreg = mir->ssaRep->uses[srcIdx];
+        if (oatIsBitSet(cUnit->tempSSARegisterV, srcSreg)) {
+          // Eliminate the null check
+          mir->optimizationFlags |= MIR_IGNORE_NULL_CHECK;
+        } else {
+          // Mark sReg as null-checked
+          oatSetBit(cUnit, cUnit->tempSSARegisterV, srcSreg);
         }
-        int dfAttributes =
-            oatDataFlowAttributes[mir->dalvikInsn.opcode];
+     }
+  }
 
-        // Mark target of NEW* as non-null
-        if (dfAttributes & DF_NON_NULL_DST) {
-            oatSetBit(cUnit, cUnit->tempSSARegisterV, mir->ssaRep->defs[0]);
-        }
-
-        // Mark non-null returns from invoke-style NEW*
-        if (dfAttributes & DF_NON_NULL_RET) {
-            MIR* nextMir = mir->next;
-            // Next should be an MOVE_RESULT_OBJECT
-            if (nextMir && nextMir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
-                // Mark as null checked
-                oatSetBit(cUnit, cUnit->tempSSARegisterV,
-                          nextMir->ssaRep->defs[0]);
-            } else {
-                if (nextMir) {
-                    LOG(WARNING) << "Unexpected opcode following new: " <<
-                    (int)nextMir->dalvikInsn.opcode;
-                } else if (bb->fallThrough) {
-                    // Look in next basic block
-                    struct BasicBlock* nextBB = bb->fallThrough;
-                    for (MIR* tmir = nextBB->firstMIRInsn; tmir;
-                         tmir =tmir->next) {
-                       if ((int)tmir->dalvikInsn.opcode >= (int)kMirOpFirst) {
-                           continue;
-                       }
-                       // First non-pseudo should be MOVE_RESULT_OBJECT
-                       if (tmir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
-                           // Mark as null checked
-                           oatSetBit(cUnit, cUnit->tempSSARegisterV,
-                                     tmir->ssaRep->defs[0]);
-                       } else {
-                           LOG(WARNING) << "Unexpected op after new: " <<
-                               (int)tmir->dalvikInsn.opcode;
-                       }
-                       break;
-                    }
-                }
-            }
-        }
-
-        /*
-         * Propagate nullcheck state on register copies (including
-         * Phi pseudo copies.  For the latter, nullcheck state is
-         * the "and" of all the Phi's operands.
-         */
-        if (dfAttributes & (DF_NULL_TRANSFER_0 | DF_NULL_TRANSFER_N)) {
-            int tgtSreg = mir->ssaRep->defs[0];
-            int operands = (dfAttributes & DF_NULL_TRANSFER_0) ? 1 :
-                mir->ssaRep->numUses;
-            bool nullChecked = true;
-            for (int i = 0; i < operands; i++) {
-                nullChecked &= oatIsBitSet(cUnit->tempSSARegisterV,
-                    mir->ssaRep->uses[i]);
-            }
-            if (nullChecked) {
-                oatSetBit(cUnit, cUnit->tempSSARegisterV, tgtSreg);
-            }
-        }
-
-        // Already nullchecked?
-        if (dfAttributes & DF_HAS_NULL_CHKS) {
-            int srcIdx;
-            if (dfAttributes & DF_NULL_CHK_1) {
-                srcIdx = 1;
-            } else if (dfAttributes & DF_NULL_CHK_2) {
-                srcIdx = 2;
-            } else {
-                srcIdx = 0;
-            }
-            int srcSreg = mir->ssaRep->uses[srcIdx];
-            if (oatIsBitSet(cUnit->tempSSARegisterV, srcSreg)) {
-                // Eliminate the null check
-                mir->optimizationFlags |= MIR_IGNORE_NULL_CHECK;
-            } else {
-                // Mark sReg as null-checked
-                oatSetBit(cUnit, cUnit->tempSSARegisterV, srcSreg);
-            }
-        }
-    }
-
-    // Did anything change?
-    bool res = oatCompareBitVectors(bb->dataFlowInfo->endingNullCheckV,
-                                    cUnit->tempSSARegisterV);
-    if (res) {
-        oatCopyBitVector(bb->dataFlowInfo->endingNullCheckV,
-                         cUnit->tempSSARegisterV);
-    }
-    return res;
+  // Did anything change?
+  bool res = oatCompareBitVectors(bb->dataFlowInfo->endingNullCheckV,
+                                  cUnit->tempSSARegisterV);
+  if (res) {
+    oatCopyBitVector(bb->dataFlowInfo->endingNullCheckV,
+                     cUnit->tempSSARegisterV);
+  }
+  return res;
 }
 
 void oatMethodNullCheckElimination(CompilationUnit *cUnit)
 {
-    if (!(cUnit->disableOpt & (1 << kNullCheckElimination))) {
-        DCHECK(cUnit->tempSSARegisterV != NULL);
-        oatDataFlowAnalysisDispatcher(cUnit, nullCheckEliminationInit,
-                                      kAllNodes,
-                                      false /* isIterative */);
-        oatDataFlowAnalysisDispatcher(cUnit, eliminateNullChecks,
-                                      kPreOrderDFSTraversal,
-                                      true /* isIterative */);
-    }
+  if (!(cUnit->disableOpt & (1 << kNullCheckElimination))) {
+    DCHECK(cUnit->tempSSARegisterV != NULL);
+    oatDataFlowAnalysisDispatcher(cUnit, nullCheckEliminationInit, kAllNodes,
+                                  false /* isIterative */);
+    oatDataFlowAnalysisDispatcher(cUnit, eliminateNullChecks,
+                                  kPreOrderDFSTraversal,
+                                  true /* isIterative */);
+  }
 }
 
 void oatMethodBasicBlockOptimization(CompilationUnit *cUnit)
 {
+  if (!(cUnit->disableOpt & (1 << kBBOpt))) {
+    oatInitGrowableList(cUnit, &cUnit->compilerTemps, 6, kListMisc);
+    DCHECK_EQ(cUnit->numCompilerTemps, 0);
     if (!(cUnit->disableOpt & (1 << kBBOpt))) {
-        oatInitGrowableList(cUnit, &cUnit->compilerTemps, 6, kListMisc);
-        DCHECK_EQ(cUnit->numCompilerTemps, 0);
-        if (!(cUnit->disableOpt & (1 << kBBOpt))) {
-            oatDataFlowAnalysisDispatcher(cUnit, basicBlockOpt,
-                                          kAllNodes, false /* isIterative */);
-        }
+      oatDataFlowAnalysisDispatcher(cUnit, basicBlockOpt,
+                                    kAllNodes, false /* isIterative */);
     }
+  }
 }
 
 void addLoopHeader(CompilationUnit* cUnit, BasicBlock* header,
-                   BasicBlock* backEdge)
+                 BasicBlock* backEdge)
 {
-    GrowableListIterator iter;
-    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
-    for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
-         (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
-         if (loop->header == header) {
-             oatInsertGrowableList(cUnit, &loop->incomingBackEdges,
-                                   (intptr_t)backEdge);
-             return;
-         }
+  GrowableListIterator iter;
+  oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+  for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
+      (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
+    if (loop->header == header) {
+      oatInsertGrowableList(cUnit, &loop->incomingBackEdges,
+                            (intptr_t)backEdge);
+      return;
     }
-    LoopInfo* info = (LoopInfo*)oatNew(cUnit, sizeof(LoopInfo), true,
-                                       kAllocDFInfo);
-    info->header = header;
-    oatInitGrowableList(cUnit, &info->incomingBackEdges, 2, kListMisc);
-    oatInsertGrowableList(cUnit, &info->incomingBackEdges, (intptr_t)backEdge);
-    oatInsertGrowableList(cUnit, &cUnit->loopHeaders, (intptr_t)info);
+  }
+  LoopInfo* info = (LoopInfo*)oatNew(cUnit, sizeof(LoopInfo), true,
+                                     kAllocDFInfo);
+  info->header = header;
+  oatInitGrowableList(cUnit, &info->incomingBackEdges, 2, kListMisc);
+  oatInsertGrowableList(cUnit, &info->incomingBackEdges, (intptr_t)backEdge);
+  oatInsertGrowableList(cUnit, &cUnit->loopHeaders, (intptr_t)info);
 }
 
 bool findBackEdges(struct CompilationUnit* cUnit, struct BasicBlock* bb)
 {
-    if ((bb->dataFlowInfo == NULL) || (bb->lastMIRInsn == NULL)) {
-        return false;
-    }
-    Instruction::Code opcode = bb->lastMIRInsn->dalvikInsn.opcode;
-    if (Instruction::Flags(opcode) & Instruction::kBranch) {
-        if (bb->taken && (bb->taken->startOffset <= bb->startOffset)) {
-            DCHECK(bb->dominators != NULL);
-            if (oatIsBitSet(bb->dominators, bb->taken->id)) {
-                if (cUnit->printMe) {
-                    LOG(INFO) << "Loop backedge from 0x"
-                              << std::hex << bb->lastMIRInsn->offset
-                              << " to 0x" << std::hex << bb->taken->startOffset;
-                }
-                addLoopHeader(cUnit, bb->taken, bb);
-            }
-        }
-    }
+  if ((bb->dataFlowInfo == NULL) || (bb->lastMIRInsn == NULL)) {
     return false;
+  }
+  Instruction::Code opcode = bb->lastMIRInsn->dalvikInsn.opcode;
+  if (Instruction::Flags(opcode) & Instruction::kBranch) {
+    if (bb->taken && (bb->taken->startOffset <= bb->startOffset)) {
+      DCHECK(bb->dominators != NULL);
+      if (oatIsBitSet(bb->dominators, bb->taken->id)) {
+        if (cUnit->printMe) {
+          LOG(INFO) << "Loop backedge from 0x"
+                    << std::hex << bb->lastMIRInsn->offset
+                    << " to 0x" << std::hex << bb->taken->startOffset;
+        }
+        addLoopHeader(cUnit, bb->taken, bb);
+      }
+    }
+  }
+  return false;
 }
 
 void addBlocksToLoop(CompilationUnit* cUnit, ArenaBitVector* blocks,
-                     BasicBlock* bb, int headId)
+                   BasicBlock* bb, int headId)
 {
-    if (!oatIsBitSet(bb->dominators, headId) ||
-        oatIsBitSet(blocks, bb->id)) {
-        return;
-    }
-    oatSetBit(cUnit, blocks, bb->id);
-    GrowableListIterator iter;
-    oatGrowableListIteratorInit(bb->predecessors, &iter);
-    BasicBlock* predBB;
-    for (predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); predBB;
-         predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
-             addBlocksToLoop(cUnit, blocks, predBB, headId);
-    }
+  if (!oatIsBitSet(bb->dominators, headId) ||
+    oatIsBitSet(blocks, bb->id)) {
+    return;
+  }
+  oatSetBit(cUnit, blocks, bb->id);
+  GrowableListIterator iter;
+  oatGrowableListIteratorInit(bb->predecessors, &iter);
+  BasicBlock* predBB;
+  for (predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); predBB;
+       predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
+    addBlocksToLoop(cUnit, blocks, predBB, headId);
+  }
 }
 
 void oatDumpLoops(CompilationUnit *cUnit)
 {
+  GrowableListIterator iter;
+  oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+  for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
+      (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
+    LOG(INFO) << "Loop head block id " << loop->header->id
+              << ", offset 0x" << std::hex << loop->header->startOffset
+              << ", Depth: " << loop->header->nestingDepth;
     GrowableListIterator iter;
-    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
-    for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
-         (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
-         LOG(INFO) << "Loop head block id " << loop->header->id
-                   << ", offset 0x" << std::hex << loop->header->startOffset
-                   << ", Depth: " << loop->header->nestingDepth;
-         GrowableListIterator iter;
-         oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
-         BasicBlock* edgeBB;
-         for (edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); edgeBB;
-              edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
-              LOG(INFO) << "    Backedge block id " << edgeBB->id
-                        << ", offset 0x" << std::hex << edgeBB->startOffset;
-              ArenaBitVectorIterator bIter;
-              oatBitVectorIteratorInit(loop->blocks, &bIter);
-              for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
-                   bbId = oatBitVectorIteratorNext(&bIter)) {
-                  BasicBlock *bb;
-                  bb = (BasicBlock*)
-                        oatGrowableListGetElement(&cUnit->blockList, bbId);
-                  LOG(INFO) << "        (" << bb->id << ", 0x" << std::hex
-                            << bb->startOffset << ")";
-              }
-         }
+    oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
+    BasicBlock* edgeBB;
+    for (edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); edgeBB;
+         edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
+      LOG(INFO) << "    Backedge block id " << edgeBB->id
+                << ", offset 0x" << std::hex << edgeBB->startOffset;
+      ArenaBitVectorIterator bIter;
+      oatBitVectorIteratorInit(loop->blocks, &bIter);
+      for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
+           bbId = oatBitVectorIteratorNext(&bIter)) {
+        BasicBlock *bb;
+        bb = (BasicBlock*)
+            oatGrowableListGetElement(&cUnit->blockList, bbId);
+        LOG(INFO) << "        (" << bb->id << ", 0x" << std::hex
+                  << bb->startOffset << ")";
+      }
     }
+  }
 }
 
 void oatMethodLoopDetection(CompilationUnit *cUnit)
 {
-    if (cUnit->disableOpt & (1 << kPromoteRegs)) {
-        return;
-    }
-    oatInitGrowableList(cUnit, &cUnit->loopHeaders, 6, kListMisc);
-    // Find the loop headers
-    oatDataFlowAnalysisDispatcher(cUnit, findBackEdges,
-                                  kAllNodes, false /* isIterative */);
+  if (cUnit->disableOpt & (1 << kPromoteRegs)) {
+    return;
+  }
+  oatInitGrowableList(cUnit, &cUnit->loopHeaders, 6, kListMisc);
+  // Find the loop headers
+  oatDataFlowAnalysisDispatcher(cUnit, findBackEdges,
+                                kAllNodes, false /* isIterative */);
+  GrowableListIterator iter;
+  oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+  // Add blocks to each header
+  for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
+       loop; loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
+    loop->blocks = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
+                                     kBitMapMisc);
+    oatSetBit(cUnit, loop->blocks, loop->header->id);
     GrowableListIterator iter;
-    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
-    // Add blocks to each header
-    for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
-         loop; loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
-         loop->blocks = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
-                                          kBitMapMisc);
-         oatSetBit(cUnit, loop->blocks, loop->header->id);
-         GrowableListIterator iter;
-         oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
-         BasicBlock* edgeBB;
-         for (edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); edgeBB;
-              edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
-             addBlocksToLoop(cUnit, loop->blocks, edgeBB, loop->header->id);
-         }
+    oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
+    BasicBlock* edgeBB;
+    for (edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter); edgeBB;
+         edgeBB = (BasicBlock*)oatGrowableListIteratorNext(&iter)) {
+      addBlocksToLoop(cUnit, loop->blocks, edgeBB, loop->header->id);
     }
-    // Compute the nesting depth of each header
-    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
-    for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
-         loop; loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
-        GrowableListIterator iter2;
-        oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter2);
-        LoopInfo* loop2;
-        for (loop2 = (LoopInfo*)oatGrowableListIteratorNext(&iter2);
-             loop2; loop2 = (LoopInfo*)oatGrowableListIteratorNext(&iter2)) {
-            if (oatIsBitSet(loop2->blocks, loop->header->id)) {
-                loop->header->nestingDepth++;
-            }
-        }
+  }
+  // Compute the nesting depth of each header
+  oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+  for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
+       loop; loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
+    GrowableListIterator iter2;
+    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter2);
+    LoopInfo* loop2;
+    for (loop2 = (LoopInfo*)oatGrowableListIteratorNext(&iter2);
+         loop2; loop2 = (LoopInfo*)oatGrowableListIteratorNext(&iter2)) {
+      if (oatIsBitSet(loop2->blocks, loop->header->id)) {
+         loop->header->nestingDepth++;
+      }
     }
-    // Assign nesting depth to each block in all loops
-    oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
-    for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
-         (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
-        ArenaBitVectorIterator bIter;
-        oatBitVectorIteratorInit(loop->blocks, &bIter);
-        for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
-            bbId = oatBitVectorIteratorNext(&bIter)) {
-            BasicBlock *bb;
-            bb = (BasicBlock*) oatGrowableListGetElement(&cUnit->blockList,
-                                                         bbId);
-            bb->nestingDepth = std::max(bb->nestingDepth,
-                                        loop->header->nestingDepth);
-        }
+  }
+  // Assign nesting depth to each block in all loops
+  oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+  for (LoopInfo* loop = (LoopInfo*)oatGrowableListIteratorNext(&iter);
+       (loop != NULL); loop = (LoopInfo*)oatGrowableListIteratorNext(&iter)) {
+    ArenaBitVectorIterator bIter;
+    oatBitVectorIteratorInit(loop->blocks, &bIter);
+    for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
+        bbId = oatBitVectorIteratorNext(&bIter)) {
+      BasicBlock *bb;
+      bb = (BasicBlock*) oatGrowableListGetElement(&cUnit->blockList, bbId);
+      bb->nestingDepth = std::max(bb->nestingDepth,
+                                  loop->header->nestingDepth);
     }
-    if (cUnit->printMe) {
-        oatDumpLoops(cUnit);
-    }
+  }
+  if (cUnit->printMe) {
+    oatDumpLoops(cUnit);
+  }
 }
 
 /*
@@ -2263,48 +2246,48 @@
  */
 bool invokeUsesMethodStar(CompilationUnit* cUnit, MIR* mir)
 {
-    InvokeType type;
-    Instruction::Code opcode = mir->dalvikInsn.opcode;
-    switch (opcode) {
-        case Instruction::INVOKE_STATIC:
-        case Instruction::INVOKE_STATIC_RANGE:
-            type = kStatic;
-            break;
-        case Instruction::INVOKE_DIRECT:
-        case Instruction::INVOKE_DIRECT_RANGE:
-            type = kDirect;
-            break;
-        case Instruction::INVOKE_VIRTUAL:
-        case Instruction::INVOKE_VIRTUAL_RANGE:
-            type = kVirtual;
-            break;
-        case Instruction::INVOKE_INTERFACE:
-        case Instruction::INVOKE_INTERFACE_RANGE:
-            return false;
-        case Instruction::INVOKE_SUPER_RANGE:
-        case Instruction::INVOKE_SUPER:
-            type = kSuper;
-            break;
-        default:
-            LOG(WARNING) << "Unexpected invoke op: " << (int)opcode;
-            return false;
-    }
-    OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                             *cUnit->dex_file, *cUnit->dex_cache,
-                             cUnit->code_item, cUnit->method_idx,
-                             cUnit->access_flags);
-    // TODO: add a flag so we don't counts the stats for this twice
-    uint32_t dexMethodIdx = mir->dalvikInsn.vB;
-    int vtableIdx;
-    uintptr_t directCode;
-    uintptr_t directMethod;
-    bool fastPath =
-        cUnit->compiler->ComputeInvokeInfo(dexMethodIdx, &mUnit, type,
-                                           vtableIdx, directCode,
-                                           directMethod) &&
-        !SLOW_INVOKE_PATH;
-    return (((type == kDirect) || (type == kStatic)) &&
-            fastPath && ((directCode == 0) || (directMethod == 0)));
+  InvokeType type;
+  Instruction::Code opcode = mir->dalvikInsn.opcode;
+  switch (opcode) {
+    case Instruction::INVOKE_STATIC:
+    case Instruction::INVOKE_STATIC_RANGE:
+      type = kStatic;
+      break;
+    case Instruction::INVOKE_DIRECT:
+    case Instruction::INVOKE_DIRECT_RANGE:
+      type = kDirect;
+      break;
+    case Instruction::INVOKE_VIRTUAL:
+    case Instruction::INVOKE_VIRTUAL_RANGE:
+      type = kVirtual;
+      break;
+    case Instruction::INVOKE_INTERFACE:
+    case Instruction::INVOKE_INTERFACE_RANGE:
+      return false;
+    case Instruction::INVOKE_SUPER_RANGE:
+    case Instruction::INVOKE_SUPER:
+      type = kSuper;
+      break;
+    default:
+      LOG(WARNING) << "Unexpected invoke op: " << (int)opcode;
+      return false;
+  }
+  OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
+                           *cUnit->dex_file, *cUnit->dex_cache,
+                           cUnit->code_item, cUnit->method_idx,
+                           cUnit->access_flags);
+  // TODO: add a flag so we don't counts the stats for this twice
+  uint32_t dexMethodIdx = mir->dalvikInsn.vB;
+  int vtableIdx;
+  uintptr_t directCode;
+  uintptr_t directMethod;
+  bool fastPath =
+      cUnit->compiler->ComputeInvokeInfo(dexMethodIdx, &mUnit, type,
+                                         vtableIdx, directCode,
+                                         directMethod) &&
+      !SLOW_INVOKE_PATH;
+  return (((type == kDirect) || (type == kStatic)) &&
+          fastPath && ((directCode == 0) || (directMethod == 0)));
 }
 
 /*
@@ -2314,61 +2297,61 @@
  */
 bool countUses(struct CompilationUnit* cUnit, struct BasicBlock* bb)
 {
-    if (bb->blockType != kDalvikByteCode) {
-        return false;
-    }
-    for (MIR* mir = bb->firstMIRInsn; (mir != NULL); mir = mir->next) {
-        if (mir->ssaRep == NULL) {
-            continue;
-        }
-        uint32_t weight = std::min(16U, (uint32_t)bb->nestingDepth);
-        for (int i = 0; i < mir->ssaRep->numUses; i++) {
-            int sReg = mir->ssaRep->uses[i];
-            DCHECK_LT(sReg, (int)cUnit->useCounts.numUsed);
-            cUnit->rawUseCounts.elemList[sReg]++;
-            cUnit->useCounts.elemList[sReg] += (1 << weight);
-        }
-        if (!(cUnit->disableOpt & (1 << kPromoteCompilerTemps))) {
-            int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
-            // Implicit use of Method* ? */
-            if (dfAttributes & DF_UMS) {
-                /*
-                 * Some invokes will not use Method* - need to perform test similar
-                 * to that found in genInvoke() to decide whether to count refs
-                 * for Method* on invoke-class opcodes.
-                 * TODO: refactor for common test here, save results for genInvoke
-                 */
-                int usesMethodStar = true;
-                if ((dfAttributes & (DF_FORMAT_35C | DF_FORMAT_3RC)) &&
-                    !(dfAttributes & DF_NON_NULL_RET)) {
-                    usesMethodStar &= invokeUsesMethodStar(cUnit, mir);
-                }
-                if (usesMethodStar) {
-                    cUnit->rawUseCounts.elemList[cUnit->methodSReg]++;
-                    cUnit->useCounts.elemList[cUnit->methodSReg] += (1 << weight);
-                }
-            }
-        }
-    }
+  if (bb->blockType != kDalvikByteCode) {
     return false;
+  }
+  for (MIR* mir = bb->firstMIRInsn; (mir != NULL); mir = mir->next) {
+    if (mir->ssaRep == NULL) {
+      continue;
+    }
+    uint32_t weight = std::min(16U, (uint32_t)bb->nestingDepth);
+    for (int i = 0; i < mir->ssaRep->numUses; i++) {
+      int sReg = mir->ssaRep->uses[i];
+      DCHECK_LT(sReg, (int)cUnit->useCounts.numUsed);
+      cUnit->rawUseCounts.elemList[sReg]++;
+      cUnit->useCounts.elemList[sReg] += (1 << weight);
+    }
+    if (!(cUnit->disableOpt & (1 << kPromoteCompilerTemps))) {
+      int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
+      // Implicit use of Method* ? */
+      if (dfAttributes & DF_UMS) {
+        /*
+         * Some invokes will not use Method* - need to perform test similar
+         * to that found in genInvoke() to decide whether to count refs
+         * for Method* on invoke-class opcodes.
+         * TODO: refactor for common test here, save results for genInvoke
+         */
+        int usesMethodStar = true;
+        if ((dfAttributes & (DF_FORMAT_35C | DF_FORMAT_3RC)) &&
+            !(dfAttributes & DF_NON_NULL_RET)) {
+          usesMethodStar &= invokeUsesMethodStar(cUnit, mir);
+        }
+        if (usesMethodStar) {
+          cUnit->rawUseCounts.elemList[cUnit->methodSReg]++;
+          cUnit->useCounts.elemList[cUnit->methodSReg] += (1 << weight);
+        }
+      }
+    }
+  }
+  return false;
 }
 
 void oatMethodUseCount(CompilationUnit *cUnit)
 {
-    oatInitGrowableList(cUnit, &cUnit->useCounts, cUnit->numSSARegs + 32,
-                        kListMisc);
-    oatInitGrowableList(cUnit, &cUnit->rawUseCounts, cUnit->numSSARegs + 32,
-                        kListMisc);
-    // Initialize list
-    for (int i = 0; i < cUnit->numSSARegs; i++) {
-        oatInsertGrowableList(cUnit, &cUnit->useCounts, 0);
-        oatInsertGrowableList(cUnit, &cUnit->rawUseCounts, 0);
-    }
-    if (cUnit->disableOpt & (1 << kPromoteRegs)) {
-        return;
-    }
-    oatDataFlowAnalysisDispatcher(cUnit, countUses,
-                                  kAllNodes, false /* isIterative */);
+  oatInitGrowableList(cUnit, &cUnit->useCounts, cUnit->numSSARegs + 32,
+                      kListMisc);
+  oatInitGrowableList(cUnit, &cUnit->rawUseCounts, cUnit->numSSARegs + 32,
+                      kListMisc);
+  // Initialize list
+  for (int i = 0; i < cUnit->numSSARegs; i++) {
+    oatInsertGrowableList(cUnit, &cUnit->useCounts, 0);
+    oatInsertGrowableList(cUnit, &cUnit->rawUseCounts, 0);
+  }
+  if (cUnit->disableOpt & (1 << kPromoteRegs)) {
+    return;
+  }
+  oatDataFlowAnalysisDispatcher(cUnit, countUses,
+                                kAllNodes, false /* isIterative */);
 }
 
 }  // namespace art
diff --git a/src/compiler/Dataflow.h b/src/compiler/Dataflow.h
index a51173f..941b544 100644
--- a/src/compiler/Dataflow.h
+++ b/src/compiler/Dataflow.h
@@ -23,38 +23,38 @@
 namespace art {
 
 enum DataFlowAttributePos {
-    kUA = 0,
-    kUB,
-    kUC,
-    kUAWide,
-    kUBWide,
-    kUCWide,
-    kDA,
-    kDAWide,
-    kIsMove,
-    kIsLinear,
-    kSetsConst,
-    kFormat35c,
-    kFormat3rc,
-    kPhi,
-    kNullCheckSrc0,        // Null check of uses[0]
-    kNullCheckSrc1,        // Null check of uses[1]
-    kNullCheckSrc2,        // Null check of uses[2]
-    kNullCheckOut0,        // Null check out outgoing arg0
-    kDstNonNull,           // May assume dst is non-null
-    kRetNonNull,           // May assume retval is non-null
-    kNullTransferSrc0,     // Object copy src[0] -> dst
-    kNullTransferSrcN,     // Phi null check state transfer
-    kRangeCheckSrc1,       // Range check of uses[1]
-    kRangeCheckSrc2,       // Range check of uses[2]
-    kRangeCheckSrc3,       // Range check of uses[3]
-    kFPA,
-    kFPB,
-    kFPC,
-    kCoreA,
-    kCoreB,
-    kCoreC,
-    kUsesMethodStar,       // Implicit use of Method*
+  kUA = 0,
+  kUB,
+  kUC,
+  kUAWide,
+  kUBWide,
+  kUCWide,
+  kDA,
+  kDAWide,
+  kIsMove,
+  kIsLinear,
+  kSetsConst,
+  kFormat35c,
+  kFormat3rc,
+  kPhi,
+  kNullCheckSrc0,        // Null check of uses[0]
+  kNullCheckSrc1,        // Null check of uses[1]
+  kNullCheckSrc2,        // Null check of uses[2]
+  kNullCheckOut0,        // Null check out outgoing arg0
+  kDstNonNull,           // May assume dst is non-null
+  kRetNonNull,           // May assume retval is non-null
+  kNullTransferSrc0,     // Object copy src[0] -> dst
+  kNullTransferSrcN,     // Phi null check state transfer
+  kRangeCheckSrc1,       // Range check of uses[1]
+  kRangeCheckSrc2,       // Range check of uses[2]
+  kRangeCheckSrc3,       // Range check of uses[3]
+  kFPA,
+  kFPB,
+  kFPC,
+  kCoreA,
+  kCoreB,
+  kCoreC,
+  kUsesMethodStar,       // Implicit use of Method*
 };
 
 #define DF_NOP                  0
@@ -114,21 +114,21 @@
 extern const int oatDataFlowAttributes[kMirOpLast];
 
 struct BasicBlockDataFlow {
-    ArenaBitVector* useV;
-    ArenaBitVector* defV;
-    ArenaBitVector* liveInV;
-    ArenaBitVector* phiV;
-    int* vRegToSSAMap;
-    ArenaBitVector* endingNullCheckV;
+  ArenaBitVector* useV;
+  ArenaBitVector* defV;
+  ArenaBitVector* liveInV;
+  ArenaBitVector* phiV;
+  int* vRegToSSAMap;
+  ArenaBitVector* endingNullCheckV;
 };
 
 struct SSARepresentation {
-    int numUses;
-    int* uses;
-    bool* fpUse;
-    int numDefs;
-    int* defs;
-    bool* fpDef;
+  int numUses;
+  int* uses;
+  bool* fpUse;
+  int numDefs;
+  int* defs;
+  bool* fpDef;
 };
 
 /*
@@ -136,24 +136,24 @@
  * induction variable.
  */
 struct InductionVariableInfo {
-    int ssaReg;
-    int basicSSAReg;
-    int m;      // multiplier
-    int c;      // constant
-    int inc;    // loop increment
+  int ssaReg;
+  int basicSSAReg;
+  int m;      // multiplier
+  int c;      // constant
+  int inc;    // loop increment
 };
 
 struct ArrayAccessInfo {
-    int arrayReg;
-    int ivReg;
-    int maxC;                   // For DIV - will affect upper bound checking
-    int minC;                   // For DIV - will affect lower bound checking
+  int arrayReg;
+  int ivReg;
+  int maxC;                   // For DIV - will affect upper bound checking
+  int minC;                   // For DIV - will affect lower bound checking
 };
 
 struct LoopInfo {
-    BasicBlock* header;
-    GrowableList incomingBackEdges;
-    ArenaBitVector* blocks;
+  BasicBlock* header;
+  GrowableList incomingBackEdges;
+  ArenaBitVector* blocks;
 };
 
 void oatMethodLoopDetection(CompilationUnit*);
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index dbaf323..dce9b8b 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -25,51 +25,51 @@
 
 /* Default optimizer/debug setting for the compiler. */
 static uint32_t kCompilerOptimizerDisableFlags = 0 | // Disable specific optimizations
-     //(1 << kLoadStoreElimination) |
-     //(1 << kLoadHoisting) |
-     //(1 << kSuppressLoads) |
-     //(1 << kNullCheckElimination) |
-     //(1 << kPromoteRegs) |
-     //(1 << kTrackLiveTemps) |
-     //(1 << kSkipLargeMethodOptimization) |
-     //(1 << kSafeOptimizations) |
-     //(1 << kBBOpt) |
-     //(1 << kMatch) |
-     //(1 << kPromoteCompilerTemps) |
-     0;
+  //(1 << kLoadStoreElimination) |
+  //(1 << kLoadHoisting) |
+  //(1 << kSuppressLoads) |
+  //(1 << kNullCheckElimination) |
+  //(1 << kPromoteRegs) |
+  //(1 << kTrackLiveTemps) |
+  //(1 << kSkipLargeMethodOptimization) |
+  //(1 << kSafeOptimizations) |
+  //(1 << kBBOpt) |
+  //(1 << kMatch) |
+  //(1 << kPromoteCompilerTemps) |
+  0;
 
 static uint32_t kCompilerDebugFlags = 0 |     // Enable debug/testing modes
-     //(1 << kDebugDisplayMissingTargets) |
-     //(1 << kDebugVerbose) |
-     //(1 << kDebugDumpCFG) |
-     //(1 << kDebugSlowFieldPath) |
-     //(1 << kDebugSlowInvokePath) |
-     //(1 << kDebugSlowStringPath) |
-     //(1 << kDebugSlowestFieldPath) |
-     //(1 << kDebugSlowestStringPath) |
-     //(1 << kDebugExerciseResolveMethod) |
-     //(1 << kDebugVerifyDataflow) |
-     //(1 << kDebugShowMemoryUsage) |
-     //(1 << kDebugShowNops) |
-     //(1 << kDebugCountOpcodes) |
-     0;
+  //(1 << kDebugDisplayMissingTargets) |
+  //(1 << kDebugVerbose) |
+  //(1 << kDebugDumpCFG) |
+  //(1 << kDebugSlowFieldPath) |
+  //(1 << kDebugSlowInvokePath) |
+  //(1 << kDebugSlowStringPath) |
+  //(1 << kDebugSlowestFieldPath) |
+  //(1 << kDebugSlowestStringPath) |
+  //(1 << kDebugExerciseResolveMethod) |
+  //(1 << kDebugVerifyDataflow) |
+  //(1 << kDebugShowMemoryUsage) |
+  //(1 << kDebugShowNops) |
+  //(1 << kDebugCountOpcodes) |
+  0;
 
 inline bool contentIsInsn(const u2* codePtr) {
-    u2 instr = *codePtr;
-    Instruction::Code opcode = (Instruction::Code)(instr & 0xff);
+  u2 instr = *codePtr;
+  Instruction::Code opcode = (Instruction::Code)(instr & 0xff);
 
-    /*
-     * Since the low 8-bit in metadata may look like NOP, we need to check
-     * both the low and whole sub-word to determine whether it is code or data.
-     */
-    return (opcode != Instruction::NOP || instr == 0);
+  /*
+   * Since the low 8-bit in metadata may look like NOP, we need to check
+   * both the low and whole sub-word to determine whether it is code or data.
+   */
+  return (opcode != Instruction::NOP || instr == 0);
 }
 
 /*
  * Parse an instruction, return the length of the instruction
  */
 inline int parseInsn(CompilationUnit* cUnit, const u2* codePtr,
-                     DecodedInstruction* decoded_instruction, bool printMe)
+                   DecodedInstruction* decoded_instruction, bool printMe)
 {
   // Don't parse instruction data
   if (!contentIsInsn(codePtr)) {
@@ -80,8 +80,10 @@
   *decoded_instruction = DecodedInstruction(instruction);
 
   if (printMe) {
-    char* decodedString = oatGetDalvikDisassembly(cUnit, *decoded_instruction, NULL);
-    LOG(INFO) << codePtr << ": 0x" << std::hex << static_cast<int>(decoded_instruction->opcode)
+    char* decodedString = oatGetDalvikDisassembly(cUnit, *decoded_instruction,
+                                                  NULL);
+    LOG(INFO) << codePtr << ": 0x"
+              << std::hex << static_cast<int>(decoded_instruction->opcode)
               << " " << decodedString;
   }
   return instruction->SizeInCodeUnits();
@@ -97,7 +99,7 @@
       return true;
     default:
       return false;
-    }
+  }
 }
 
 /*
@@ -110,90 +112,89 @@
     case Instruction::RETURN_WIDE:
     case Instruction::RETURN_OBJECT:
       return true;
-    default:
-      return isGoto(insn);
+  default:
+    return isGoto(insn);
   }
 }
 
 /* Split an existing block from the specified code offset into two */
 BasicBlock *splitBlock(CompilationUnit* cUnit, unsigned int codeOffset,
-                       BasicBlock* origBlock, BasicBlock** immedPredBlockP)
+                     BasicBlock* origBlock, BasicBlock** immedPredBlockP)
 {
-    MIR* insn = origBlock->firstMIRInsn;
-    while (insn) {
-        if (insn->offset == codeOffset) break;
-        insn = insn->next;
-    }
-    if (insn == NULL) {
-        LOG(FATAL) << "Break split failed";
-    }
-    BasicBlock *bottomBlock = oatNewBB(cUnit, kDalvikByteCode,
-                                       cUnit->numBlocks++);
-    oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) bottomBlock);
+  MIR* insn = origBlock->firstMIRInsn;
+  while (insn) {
+    if (insn->offset == codeOffset) break;
+    insn = insn->next;
+  }
+  if (insn == NULL) {
+    LOG(FATAL) << "Break split failed";
+  }
+  BasicBlock *bottomBlock = oatNewBB(cUnit, kDalvikByteCode,
+                                     cUnit->numBlocks++);
+  oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) bottomBlock);
 
-    bottomBlock->startOffset = codeOffset;
-    bottomBlock->firstMIRInsn = insn;
-    bottomBlock->lastMIRInsn = origBlock->lastMIRInsn;
+  bottomBlock->startOffset = codeOffset;
+  bottomBlock->firstMIRInsn = insn;
+  bottomBlock->lastMIRInsn = origBlock->lastMIRInsn;
 
-    /* Add it to the quick lookup cache */
-    cUnit->blockMap.Put(bottomBlock->startOffset, bottomBlock);
+  /* Add it to the quick lookup cache */
+  cUnit->blockMap.Put(bottomBlock->startOffset, bottomBlock);
 
-    /* Handle the taken path */
-    bottomBlock->taken = origBlock->taken;
-    if (bottomBlock->taken) {
-        origBlock->taken = NULL;
-        oatDeleteGrowableList(bottomBlock->taken->predecessors,
-                              (intptr_t)origBlock);
-        oatInsertGrowableList(cUnit, bottomBlock->taken->predecessors,
-                              (intptr_t)bottomBlock);
-    }
-
-    /* Handle the fallthrough path */
-    bottomBlock->needFallThroughBranch = origBlock->needFallThroughBranch;
-    bottomBlock->fallThrough = origBlock->fallThrough;
-    origBlock->fallThrough = bottomBlock;
-    origBlock->needFallThroughBranch = true;
-    oatInsertGrowableList(cUnit, bottomBlock->predecessors,
+  /* Handle the taken path */
+  bottomBlock->taken = origBlock->taken;
+  if (bottomBlock->taken) {
+    origBlock->taken = NULL;
+    oatDeleteGrowableList(bottomBlock->taken->predecessors,
                           (intptr_t)origBlock);
-    if (bottomBlock->fallThrough) {
-        oatDeleteGrowableList(bottomBlock->fallThrough->predecessors,
-                              (intptr_t)origBlock);
-        oatInsertGrowableList(cUnit, bottomBlock->fallThrough->predecessors,
-                              (intptr_t)bottomBlock);
+    oatInsertGrowableList(cUnit, bottomBlock->taken->predecessors,
+                          (intptr_t)bottomBlock);
+  }
+
+  /* Handle the fallthrough path */
+  bottomBlock->needFallThroughBranch = origBlock->needFallThroughBranch;
+  bottomBlock->fallThrough = origBlock->fallThrough;
+  origBlock->fallThrough = bottomBlock;
+  origBlock->needFallThroughBranch = true;
+  oatInsertGrowableList(cUnit, bottomBlock->predecessors,
+                        (intptr_t)origBlock);
+  if (bottomBlock->fallThrough) {
+    oatDeleteGrowableList(bottomBlock->fallThrough->predecessors,
+                          (intptr_t)origBlock);
+    oatInsertGrowableList(cUnit, bottomBlock->fallThrough->predecessors,
+                          (intptr_t)bottomBlock);
+  }
+
+  /* Handle the successor list */
+  if (origBlock->successorBlockList.blockListType != kNotUsed) {
+    bottomBlock->successorBlockList = origBlock->successorBlockList;
+    origBlock->successorBlockList.blockListType = kNotUsed;
+    GrowableListIterator iterator;
+
+    oatGrowableListIteratorInit(&bottomBlock->successorBlockList.blocks,
+                                &iterator);
+    while (true) {
+      SuccessorBlockInfo *successorBlockInfo =
+          (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+      if (successorBlockInfo == NULL) break;
+      BasicBlock *bb = successorBlockInfo->block;
+      oatDeleteGrowableList(bb->predecessors, (intptr_t)origBlock);
+      oatInsertGrowableList(cUnit, bb->predecessors, (intptr_t)bottomBlock);
     }
+  }
 
-    /* Handle the successor list */
-    if (origBlock->successorBlockList.blockListType != kNotUsed) {
-        bottomBlock->successorBlockList = origBlock->successorBlockList;
-        origBlock->successorBlockList.blockListType = kNotUsed;
-        GrowableListIterator iterator;
+  origBlock->lastMIRInsn = insn->prev;
 
-        oatGrowableListIteratorInit(&bottomBlock->successorBlockList.blocks,
-                                    &iterator);
-        while (true) {
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-            if (successorBlockInfo == NULL) break;
-            BasicBlock *bb = successorBlockInfo->block;
-            oatDeleteGrowableList(bb->predecessors, (intptr_t)origBlock);
-            oatInsertGrowableList(cUnit, bb->predecessors,
-                                  (intptr_t)bottomBlock);
-        }
-    }
-
-    origBlock->lastMIRInsn = insn->prev;
-
-    insn->prev->next = NULL;
-    insn->prev = NULL;
-    /*
-     * Update the immediate predecessor block pointer so that outgoing edges
-     * can be applied to the proper block.
-     */
-    if (immedPredBlockP) {
-        DCHECK_EQ(*immedPredBlockP, origBlock);
-        *immedPredBlockP = bottomBlock;
-    }
-    return bottomBlock;
+  insn->prev->next = NULL;
+  insn->prev = NULL;
+  /*
+   * Update the immediate predecessor block pointer so that outgoing edges
+   * can be applied to the proper block.
+   */
+  if (immedPredBlockP) {
+    DCHECK_EQ(*immedPredBlockP, origBlock);
+    *immedPredBlockP = bottomBlock;
+  }
+  return bottomBlock;
 }
 
 /*
@@ -207,444 +208,441 @@
 BasicBlock *findBlock(CompilationUnit* cUnit, unsigned int codeOffset,
                       bool split, bool create, BasicBlock** immedPredBlockP)
 {
-    GrowableList* blockList = &cUnit->blockList;
-    BasicBlock* bb;
-    unsigned int i;
-    SafeMap<unsigned int, BasicBlock*>::iterator it;
+  GrowableList* blockList = &cUnit->blockList;
+  BasicBlock* bb;
+  unsigned int i;
+  SafeMap<unsigned int, BasicBlock*>::iterator it;
 
-    it = cUnit->blockMap.find(codeOffset);
-    if (it != cUnit->blockMap.end()) {
-        return it->second;
-    } else if (!create) {
-        return NULL;
+  it = cUnit->blockMap.find(codeOffset);
+  if (it != cUnit->blockMap.end()) {
+    return it->second;
+  } else if (!create) {
+    return NULL;
+  }
+
+  if (split) {
+    for (i = 0; i < blockList->numUsed; i++) {
+      bb = (BasicBlock *) blockList->elemList[i];
+      if (bb->blockType != kDalvikByteCode) continue;
+      /* Check if a branch jumps into the middle of an existing block */
+      if ((codeOffset > bb->startOffset) && (bb->lastMIRInsn != NULL) &&
+          (codeOffset <= bb->lastMIRInsn->offset)) {
+        BasicBlock *newBB = splitBlock(cUnit, codeOffset, bb,
+                                       bb == *immedPredBlockP ?
+                                       immedPredBlockP : NULL);
+        return newBB;
+      }
     }
+  }
 
-    if (split) {
-        for (i = 0; i < blockList->numUsed; i++) {
-            bb = (BasicBlock *) blockList->elemList[i];
-            if (bb->blockType != kDalvikByteCode) continue;
-            /* Check if a branch jumps into the middle of an existing block */
-            if ((codeOffset > bb->startOffset) && (bb->lastMIRInsn != NULL) &&
-                (codeOffset <= bb->lastMIRInsn->offset)) {
-                BasicBlock *newBB = splitBlock(cUnit, codeOffset, bb,
-                                               bb == *immedPredBlockP ?
-                                               immedPredBlockP : NULL);
-                return newBB;
-            }
-        }
-    }
-
-    /* Create a new one */
-    bb = oatNewBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
-    oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) bb);
-    bb->startOffset = codeOffset;
-    cUnit->blockMap.Put(bb->startOffset, bb);
-    return bb;
+  /* Create a new one */
+  bb = oatNewBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
+  oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) bb);
+  bb->startOffset = codeOffset;
+  cUnit->blockMap.Put(bb->startOffset, bb);
+  return bb;
 }
 
 /* Dump the CFG into a DOT graph */
 void oatDumpCFG(CompilationUnit* cUnit, const char* dirPrefix)
 {
-    FILE* file;
-    std::string name(PrettyMethod(cUnit->method_idx, *cUnit->dex_file));
-    char startOffset[80];
-    sprintf(startOffset, "_%x", cUnit->entryBlock->fallThrough->startOffset);
-    char* fileName = (char*) oatNew(cUnit,
-                        strlen(dirPrefix) +
-                        name.length() +
-                        strlen(".dot") + 1, true, kAllocDebugInfo);
-    sprintf(fileName, "%s%s%s.dot", dirPrefix, name.c_str(), startOffset);
+  FILE* file;
+  std::string name(PrettyMethod(cUnit->method_idx, *cUnit->dex_file));
+  char startOffset[80];
+  sprintf(startOffset, "_%x", cUnit->entryBlock->fallThrough->startOffset);
+  char* fileName = (char*) oatNew(cUnit, strlen(dirPrefix) +
+                                  name.length() + strlen(".dot") + 1,
+                                  true, kAllocDebugInfo);
+  sprintf(fileName, "%s%s%s.dot", dirPrefix, name.c_str(), startOffset);
 
-    /*
-     * Convert the special characters into a filesystem- and shell-friendly
-     * format.
-     */
-    int i;
-    for (i = strlen(dirPrefix); fileName[i]; i++) {
-        if (fileName[i] == '/') {
-            fileName[i] = '_';
-        } else if (fileName[i] == ';') {
-            fileName[i] = '#';
-        } else if (fileName[i] == '$') {
-            fileName[i] = '+';
-        } else if (fileName[i] == '(' || fileName[i] == ')') {
-            fileName[i] = '@';
-        } else if (fileName[i] == '<' || fileName[i] == '>') {
-            fileName[i] = '=';
-        }
+  /*
+   * Convert the special characters into a filesystem- and shell-friendly
+   * format.
+   */
+  int i;
+  for (i = strlen(dirPrefix); fileName[i]; i++) {
+    if (fileName[i] == '/') {
+      fileName[i] = '_';
+    } else if (fileName[i] == ';') {
+      fileName[i] = '#';
+    } else if (fileName[i] == '$') {
+      fileName[i] = '+';
+    } else if (fileName[i] == '(' || fileName[i] == ')') {
+      fileName[i] = '@';
+    } else if (fileName[i] == '<' || fileName[i] == '>') {
+      fileName[i] = '=';
     }
-    file = fopen(fileName, "w");
-    if (file == NULL) {
-        return;
+  }
+  file = fopen(fileName, "w");
+  if (file == NULL) {
+    return;
+  }
+  fprintf(file, "digraph G {\n");
+
+  fprintf(file, "  rankdir=TB\n");
+
+  int numReachableBlocks = cUnit->numReachableBlocks;
+  int idx;
+  const GrowableList *blockList = &cUnit->blockList;
+
+  for (idx = 0; idx < numReachableBlocks; idx++) {
+    int blockIdx = cUnit->dfsOrder.elemList[idx];
+    BasicBlock *bb = (BasicBlock *) oatGrowableListGetElement(blockList,
+                                                              blockIdx);
+    if (bb == NULL) break;
+    if (bb->blockType == kEntryBlock) {
+      fprintf(file, "  entry [shape=Mdiamond];\n");
+    } else if (bb->blockType == kExitBlock) {
+      fprintf(file, "  exit [shape=Mdiamond];\n");
+    } else if (bb->blockType == kDalvikByteCode) {
+      fprintf(file, "  block%04x [shape=record,label = \"{ \\\n",
+              bb->startOffset);
+      const MIR *mir;
+        fprintf(file, "    {block id %d\\l}%s\\\n", bb->id,
+                bb->firstMIRInsn ? " | " : " ");
+        for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+            fprintf(file, "    {%04x %s\\l}%s\\\n", mir->offset,
+                    mir->ssaRep ? oatFullDisassembler(cUnit, mir) :
+                    Instruction::Name(mir->dalvikInsn.opcode),
+                    mir->next ? " | " : " ");
+        }
+        fprintf(file, "  }\"];\n\n");
+    } else if (bb->blockType == kExceptionHandling) {
+      char blockName[BLOCK_NAME_LEN];
+
+      oatGetBlockName(bb, blockName);
+      fprintf(file, "  %s [shape=invhouse];\n", blockName);
     }
-    fprintf(file, "digraph G {\n");
 
-    fprintf(file, "  rankdir=TB\n");
+    char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
 
-    int numReachableBlocks = cUnit->numReachableBlocks;
-    int idx;
-    const GrowableList *blockList = &cUnit->blockList;
-
-    for (idx = 0; idx < numReachableBlocks; idx++) {
-        int blockIdx = cUnit->dfsOrder.elemList[idx];
-        BasicBlock *bb = (BasicBlock *) oatGrowableListGetElement(blockList,
-                                                                  blockIdx);
-        if (bb == NULL) break;
-        if (bb->blockType == kEntryBlock) {
-            fprintf(file, "  entry [shape=Mdiamond];\n");
-        } else if (bb->blockType == kExitBlock) {
-            fprintf(file, "  exit [shape=Mdiamond];\n");
-        } else if (bb->blockType == kDalvikByteCode) {
-            fprintf(file, "  block%04x [shape=record,label = \"{ \\\n",
-                    bb->startOffset);
-            const MIR *mir;
-            fprintf(file, "    {block id %d\\l}%s\\\n", bb->id,
-                    bb->firstMIRInsn ? " | " : " ");
-            for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-                fprintf(file, "    {%04x %s\\l}%s\\\n", mir->offset,
-                        mir->ssaRep ? oatFullDisassembler(cUnit, mir) : Instruction::Name(mir->dalvikInsn.opcode),
-                        mir->next ? " | " : " ");
-            }
-            fprintf(file, "  }\"];\n\n");
-        } else if (bb->blockType == kExceptionHandling) {
-            char blockName[BLOCK_NAME_LEN];
-
-            oatGetBlockName(bb, blockName);
-            fprintf(file, "  %s [shape=invhouse];\n", blockName);
-        }
-
-        char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
-
-        if (bb->taken) {
-            oatGetBlockName(bb, blockName1);
-            oatGetBlockName(bb->taken, blockName2);
-            fprintf(file, "  %s:s -> %s:n [style=dotted]\n",
-                    blockName1, blockName2);
-        }
-        if (bb->fallThrough) {
-            oatGetBlockName(bb, blockName1);
-            oatGetBlockName(bb->fallThrough, blockName2);
-            fprintf(file, "  %s:s -> %s:n\n", blockName1, blockName2);
-        }
-
-        if (bb->successorBlockList.blockListType != kNotUsed) {
-            fprintf(file, "  succ%04x [shape=%s,label = \"{ \\\n",
-                    bb->startOffset,
-                    (bb->successorBlockList.blockListType == kCatch) ?
-                        "Mrecord" : "record");
-            GrowableListIterator iterator;
-            oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
-                                        &iterator);
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-
-            int succId = 0;
-            while (true) {
-                if (successorBlockInfo == NULL) break;
-
-                BasicBlock *destBlock = successorBlockInfo->block;
-                SuccessorBlockInfo *nextSuccessorBlockInfo =
-                  (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-
-                fprintf(file, "    {<f%d> %04x: %04x\\l}%s\\\n",
-                        succId++,
-                        successorBlockInfo->key,
-                        destBlock->startOffset,
-                        (nextSuccessorBlockInfo != NULL) ? " | " : " ");
-
-                successorBlockInfo = nextSuccessorBlockInfo;
-            }
-            fprintf(file, "  }\"];\n\n");
-
-            oatGetBlockName(bb, blockName1);
-            fprintf(file, "  %s:s -> succ%04x:n [style=dashed]\n",
-                    blockName1, bb->startOffset);
-
-            if (bb->successorBlockList.blockListType == kPackedSwitch ||
-                bb->successorBlockList.blockListType == kSparseSwitch) {
-
-                oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
-                                            &iterator);
-
-                succId = 0;
-                while (true) {
-                    SuccessorBlockInfo *successorBlockInfo =
-                        (SuccessorBlockInfo *)
-                            oatGrowableListIteratorNext(&iterator);
-                    if (successorBlockInfo == NULL) break;
-
-                    BasicBlock *destBlock = successorBlockInfo->block;
-
-                    oatGetBlockName(destBlock, blockName2);
-                    fprintf(file, "  succ%04x:f%d:e -> %s:n\n",
-                            bb->startOffset, succId++,
-                            blockName2);
-                }
-            }
-        }
-        fprintf(file, "\n");
-
-        /* Display the dominator tree */
-        oatGetBlockName(bb, blockName1);
-        fprintf(file, "  cfg%s [label=\"%s\", shape=none];\n",
-                blockName1, blockName1);
-        if (bb->iDom) {
-            oatGetBlockName(bb->iDom, blockName2);
-            fprintf(file, "  cfg%s:s -> cfg%s:n\n\n",
-                    blockName2, blockName1);
-        }
+    if (bb->taken) {
+      oatGetBlockName(bb, blockName1);
+      oatGetBlockName(bb->taken, blockName2);
+      fprintf(file, "  %s:s -> %s:n [style=dotted]\n",
+              blockName1, blockName2);
     }
-    fprintf(file, "}\n");
-    fclose(file);
+    if (bb->fallThrough) {
+      oatGetBlockName(bb, blockName1);
+      oatGetBlockName(bb->fallThrough, blockName2);
+      fprintf(file, "  %s:s -> %s:n\n", blockName1, blockName2);
+    }
+
+    if (bb->successorBlockList.blockListType != kNotUsed) {
+      fprintf(file, "  succ%04x [shape=%s,label = \"{ \\\n",
+              bb->startOffset,
+              (bb->successorBlockList.blockListType == kCatch) ?
+               "Mrecord" : "record");
+      GrowableListIterator iterator;
+      oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+                                  &iterator);
+      SuccessorBlockInfo *successorBlockInfo =
+          (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+
+      int succId = 0;
+      while (true) {
+        if (successorBlockInfo == NULL) break;
+
+        BasicBlock *destBlock = successorBlockInfo->block;
+        SuccessorBlockInfo *nextSuccessorBlockInfo =
+            (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+
+        fprintf(file, "    {<f%d> %04x: %04x\\l}%s\\\n",
+                succId++,
+                successorBlockInfo->key,
+                destBlock->startOffset,
+                (nextSuccessorBlockInfo != NULL) ? " | " : " ");
+
+        successorBlockInfo = nextSuccessorBlockInfo;
+      }
+      fprintf(file, "  }\"];\n\n");
+
+      oatGetBlockName(bb, blockName1);
+      fprintf(file, "  %s:s -> succ%04x:n [style=dashed]\n",
+              blockName1, bb->startOffset);
+
+      if (bb->successorBlockList.blockListType == kPackedSwitch ||
+          bb->successorBlockList.blockListType == kSparseSwitch) {
+
+        oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+                                    &iterator);
+
+        succId = 0;
+        while (true) {
+          SuccessorBlockInfo *successorBlockInfo = (SuccessorBlockInfo *)
+              oatGrowableListIteratorNext(&iterator);
+          if (successorBlockInfo == NULL) break;
+
+          BasicBlock *destBlock = successorBlockInfo->block;
+
+          oatGetBlockName(destBlock, blockName2);
+          fprintf(file, "  succ%04x:f%d:e -> %s:n\n", bb->startOffset,
+                  succId++, blockName2);
+        }
+      }
+    }
+    fprintf(file, "\n");
+
+    /* Display the dominator tree */
+    oatGetBlockName(bb, blockName1);
+    fprintf(file, "  cfg%s [label=\"%s\", shape=none];\n",
+            blockName1, blockName1);
+    if (bb->iDom) {
+      oatGetBlockName(bb->iDom, blockName2);
+      fprintf(file, "  cfg%s:s -> cfg%s:n\n\n", blockName2, blockName1);
+    }
+  }
+  fprintf(file, "}\n");
+  fclose(file);
 }
 
 /* Verify if all the successor is connected with all the claimed predecessors */
 bool verifyPredInfo(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableListIterator iter;
+  GrowableListIterator iter;
 
-    oatGrowableListIteratorInit(bb->predecessors, &iter);
-    while (true) {
-        BasicBlock *predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-        if (!predBB) break;
-        bool found = false;
-        if (predBB->taken == bb) {
+  oatGrowableListIteratorInit(bb->predecessors, &iter);
+  while (true) {
+    BasicBlock *predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+    if (!predBB) break;
+    bool found = false;
+    if (predBB->taken == bb) {
+        found = true;
+    } else if (predBB->fallThrough == bb) {
+        found = true;
+    } else if (predBB->successorBlockList.blockListType != kNotUsed) {
+      GrowableListIterator iterator;
+      oatGrowableListIteratorInit(&predBB->successorBlockList.blocks,
+                                  &iterator);
+      while (true) {
+        SuccessorBlockInfo *successorBlockInfo = (SuccessorBlockInfo *)
+            oatGrowableListIteratorNext(&iterator);
+        if (successorBlockInfo == NULL) break;
+        BasicBlock *succBB = successorBlockInfo->block;
+        if (succBB == bb) {
             found = true;
-        } else if (predBB->fallThrough == bb) {
-            found = true;
-        } else if (predBB->successorBlockList.blockListType != kNotUsed) {
-            GrowableListIterator iterator;
-            oatGrowableListIteratorInit(&predBB->successorBlockList.blocks,
-                                        &iterator);
-            while (true) {
-                SuccessorBlockInfo *successorBlockInfo =
-                    (SuccessorBlockInfo *)
-                        oatGrowableListIteratorNext(&iterator);
-                if (successorBlockInfo == NULL) break;
-                BasicBlock *succBB = successorBlockInfo->block;
-                if (succBB == bb) {
-                    found = true;
-                    break;
-                }
-            }
+            break;
         }
-        if (found == false) {
-            char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
-            oatGetBlockName(bb, blockName1);
-            oatGetBlockName(predBB, blockName2);
-            oatDumpCFG(cUnit, "/sdcard/cfg/");
-            LOG(FATAL) << "Successor " << blockName1 << "not found from "
-                << blockName2;
-        }
+      }
     }
-    return true;
+    if (found == false) {
+      char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
+      oatGetBlockName(bb, blockName1);
+      oatGetBlockName(predBB, blockName2);
+      oatDumpCFG(cUnit, "/sdcard/cfg/");
+      LOG(FATAL) << "Successor " << blockName1 << "not found from "
+                 << blockName2;
+    }
+  }
+  return true;
 }
 
 /* Identify code range in try blocks and set up the empty catch blocks */
 void processTryCatchBlocks(CompilationUnit* cUnit)
 {
-    const DexFile::CodeItem* code_item = cUnit->code_item;
-    int triesSize = code_item->tries_size_;
-    int offset;
+  const DexFile::CodeItem* code_item = cUnit->code_item;
+  int triesSize = code_item->tries_size_;
+  int offset;
 
-    if (triesSize == 0) {
-        return;
+  if (triesSize == 0) {
+    return;
+  }
+
+  ArenaBitVector* tryBlockAddr = cUnit->tryBlockAddr;
+
+  for (int i = 0; i < triesSize; i++) {
+    const DexFile::TryItem* pTry =
+        DexFile::GetTryItems(*code_item, i);
+    int startOffset = pTry->start_addr_;
+    int endOffset = startOffset + pTry->insn_count_;
+    for (offset = startOffset; offset < endOffset; offset++) {
+      oatSetBit(cUnit, tryBlockAddr, offset);
     }
+  }
 
-    ArenaBitVector* tryBlockAddr = cUnit->tryBlockAddr;
-
-    for (int i = 0; i < triesSize; i++) {
-        const DexFile::TryItem* pTry =
-            DexFile::GetTryItems(*code_item, i);
-        int startOffset = pTry->start_addr_;
-        int endOffset = startOffset + pTry->insn_count_;
-        for (offset = startOffset; offset < endOffset; offset++) {
-            oatSetBit(cUnit, tryBlockAddr, offset);
-        }
+  // Iterate over each of the handlers to enqueue the empty Catch blocks
+  const byte* handlers_ptr = DexFile::GetCatchHandlerData(*code_item, 0);
+  uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
+  for (uint32_t idx = 0; idx < handlers_size; idx++) {
+    CatchHandlerIterator iterator(handlers_ptr);
+    for (; iterator.HasNext(); iterator.Next()) {
+      uint32_t address = iterator.GetHandlerAddress();
+      findBlock(cUnit, address, false /* split */, true /*create*/,
+                /* immedPredBlockP */ NULL);
     }
-
-    // Iterate over each of the handlers to enqueue the empty Catch blocks
-    const byte* handlers_ptr =
-        DexFile::GetCatchHandlerData(*code_item, 0);
-    uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
-    for (uint32_t idx = 0; idx < handlers_size; idx++) {
-        CatchHandlerIterator iterator(handlers_ptr);
-        for (; iterator.HasNext(); iterator.Next()) {
-            uint32_t address = iterator.GetHandlerAddress();
-            findBlock(cUnit, address, false /* split */, true /*create*/,
-                      /* immedPredBlockP */ NULL);
-        }
-        handlers_ptr = iterator.EndDataPointer();
-    }
+    handlers_ptr = iterator.EndDataPointer();
+  }
 }
 
 /* Process instructions with the kBranch flag */
 BasicBlock* processCanBranch(CompilationUnit* cUnit, BasicBlock* curBlock,
-                             MIR* insn, int curOffset, int width, int flags,
-                             const u2* codePtr, const u2* codeEnd)
+                           MIR* insn, int curOffset, int width, int flags,
+                           const u2* codePtr, const u2* codeEnd)
 {
-    int target = curOffset;
-    switch (insn->dalvikInsn.opcode) {
-        case Instruction::GOTO:
-        case Instruction::GOTO_16:
-        case Instruction::GOTO_32:
-            target += (int) insn->dalvikInsn.vA;
-            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:
-            target += (int) insn->dalvikInsn.vC;
-            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:
-            target += (int) insn->dalvikInsn.vB;
-            break;
-        default:
-            LOG(FATAL) << "Unexpected opcode(" << (int)insn->dalvikInsn.opcode
-                << ") with kBranch set";
-    }
-    BasicBlock *takenBlock = findBlock(cUnit, target,
-                                       /* split */
-                                       true,
-                                       /* create */
-                                       true,
-                                       /* immedPredBlockP */
-                                       &curBlock);
-    curBlock->taken = takenBlock;
-    oatInsertGrowableList(cUnit, takenBlock->predecessors, (intptr_t)curBlock);
+  int target = curOffset;
+  switch (insn->dalvikInsn.opcode) {
+    case Instruction::GOTO:
+    case Instruction::GOTO_16:
+    case Instruction::GOTO_32:
+      target += (int) insn->dalvikInsn.vA;
+      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:
+      target += (int) insn->dalvikInsn.vC;
+      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:
+      target += (int) insn->dalvikInsn.vB;
+      break;
+    default:
+      LOG(FATAL) << "Unexpected opcode(" << (int)insn->dalvikInsn.opcode
+                 << ") with kBranch set";
+  }
+  BasicBlock *takenBlock = findBlock(cUnit, target,
+                                     /* split */
+                                     true,
+                                     /* create */
+                                     true,
+                                     /* immedPredBlockP */
+                                     &curBlock);
+  curBlock->taken = takenBlock;
+  oatInsertGrowableList(cUnit, takenBlock->predecessors, (intptr_t)curBlock);
 
-    /* Always terminate the current block for conditional branches */
-    if (flags & Instruction::kContinue) {
-        BasicBlock *fallthroughBlock = findBlock(cUnit,
-                                                 curOffset +  width,
-                                                 /*
-                                                  * If the method is processed
-                                                  * in sequential order from the
-                                                  * beginning, we don't need to
-                                                  * specify split for continue
-                                                  * blocks. However, this
-                                                  * routine can be called by
-                                                  * compileLoop, which starts
-                                                  * parsing the method from an
-                                                  * arbitrary address in the
-                                                  * method body.
-                                                  */
-                                                 true,
-                                                 /* create */
-                                                 true,
-                                                 /* immedPredBlockP */
-                                                 &curBlock);
-        curBlock->fallThrough = fallthroughBlock;
-        oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
-                              (intptr_t)curBlock);
-    } else if (codePtr < codeEnd) {
-        /* Create a fallthrough block for real instructions (incl. NOP) */
-        if (contentIsInsn(codePtr)) {
-            findBlock(cUnit, curOffset + width,
-                      /* split */
-                      false,
-                      /* create */
-                      true,
-                      /* immedPredBlockP */
-                      NULL);
-        }
+  /* Always terminate the current block for conditional branches */
+  if (flags & Instruction::kContinue) {
+    BasicBlock *fallthroughBlock = findBlock(cUnit,
+                                             curOffset +  width,
+                                             /*
+                                              * If the method is processed
+                                              * in sequential order from the
+                                              * beginning, we don't need to
+                                              * specify split for continue
+                                              * blocks. However, this
+                                              * routine can be called by
+                                              * compileLoop, which starts
+                                              * parsing the method from an
+                                              * arbitrary address in the
+                                              * method body.
+                                              */
+                                             true,
+                                             /* create */
+                                             true,
+                                             /* immedPredBlockP */
+                                             &curBlock);
+    curBlock->fallThrough = fallthroughBlock;
+    oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+                          (intptr_t)curBlock);
+  } else if (codePtr < codeEnd) {
+    /* Create a fallthrough block for real instructions (incl. NOP) */
+    if (contentIsInsn(codePtr)) {
+      findBlock(cUnit, curOffset + width,
+                /* split */
+                false,
+                /* create */
+                true,
+                /* immedPredBlockP */
+                NULL);
     }
-    return curBlock;
+  }
+  return curBlock;
 }
 
 /* Process instructions with the kSwitch flag */
 void processCanSwitch(CompilationUnit* cUnit, BasicBlock* curBlock,
                       MIR* insn, int curOffset, int width, int flags)
 {
-    u2* switchData= (u2 *) (cUnit->insns + curOffset +
-                            insn->dalvikInsn.vB);
-    int size;
-    int* keyTable;
-    int* targetTable;
-    int i;
-    int firstKey;
+  u2* switchData= (u2 *) (cUnit->insns + curOffset + insn->dalvikInsn.vB);
+  int size;
+  int* keyTable;
+  int* targetTable;
+  int i;
+  int firstKey;
 
-    /*
-     * Packed switch data format:
-     *  ushort ident = 0x0100   magic value
-     *  ushort size             number of entries in the table
-     *  int first_key           first (and lowest) switch case value
-     *  int targets[size]       branch targets, relative to switch opcode
-     *
-     * Total size is (4+size*2) 16-bit code units.
-     */
-    if (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) {
-        DCHECK_EQ(static_cast<int>(switchData[0]), static_cast<int>(Instruction::kPackedSwitchSignature));
-        size = switchData[1];
-        firstKey = switchData[2] | (switchData[3] << 16);
-        targetTable = (int *) &switchData[4];
-        keyTable = NULL;        // Make the compiler happy
-    /*
-     * Sparse switch data format:
-     *  ushort ident = 0x0200   magic value
-     *  ushort size             number of entries in the table; > 0
-     *  int keys[size]          keys, sorted low-to-high; 32-bit aligned
-     *  int targets[size]       branch targets, relative to switch opcode
-     *
-     * Total size is (2+size*4) 16-bit code units.
-     */
-    } else {
-        DCHECK_EQ(static_cast<int>(switchData[0]), static_cast<int>(Instruction::kSparseSwitchSignature));
-        size = switchData[1];
-        keyTable = (int *) &switchData[2];
-        targetTable = (int *) &switchData[2 + size*2];
-        firstKey = 0;   // To make the compiler happy
-    }
+  /*
+   * Packed switch data format:
+   *  ushort ident = 0x0100   magic value
+   *  ushort size             number of entries in the table
+   *  int first_key           first (and lowest) switch case value
+   *  int targets[size]       branch targets, relative to switch opcode
+   *
+   * Total size is (4+size*2) 16-bit code units.
+   */
+  if (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) {
+    DCHECK_EQ(static_cast<int>(switchData[0]),
+              static_cast<int>(Instruction::kPackedSwitchSignature));
+    size = switchData[1];
+    firstKey = switchData[2] | (switchData[3] << 16);
+    targetTable = (int *) &switchData[4];
+    keyTable = NULL;        // Make the compiler happy
+  /*
+   * Sparse switch data format:
+   *  ushort ident = 0x0200   magic value
+   *  ushort size             number of entries in the table; > 0
+   *  int keys[size]          keys, sorted low-to-high; 32-bit aligned
+   *  int targets[size]       branch targets, relative to switch opcode
+   *
+   * Total size is (2+size*4) 16-bit code units.
+   */
+  } else {
+    DCHECK_EQ(static_cast<int>(switchData[0]),
+              static_cast<int>(Instruction::kSparseSwitchSignature));
+    size = switchData[1];
+    keyTable = (int *) &switchData[2];
+    targetTable = (int *) &switchData[2 + size*2];
+    firstKey = 0;   // To make the compiler happy
+  }
 
-    if (curBlock->successorBlockList.blockListType != kNotUsed) {
-        LOG(FATAL) << "Successor block list already in use: " <<
-             (int)curBlock->successorBlockList.blockListType;
-    }
-    curBlock->successorBlockList.blockListType =
+  if (curBlock->successorBlockList.blockListType != kNotUsed) {
+    LOG(FATAL) << "Successor block list already in use: "
+               << (int)curBlock->successorBlockList.blockListType;
+  }
+  curBlock->successorBlockList.blockListType =
+      (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ?
+      kPackedSwitch : kSparseSwitch;
+  oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, size,
+                      kListSuccessorBlocks);
+
+  for (i = 0; i < size; i++) {
+    BasicBlock *caseBlock = findBlock(cUnit, curOffset + targetTable[i],
+                                      /* split */
+                                      true,
+                                      /* create */
+                                      true,
+                                      /* immedPredBlockP */
+                                      &curBlock);
+    SuccessorBlockInfo *successorBlockInfo =
+        (SuccessorBlockInfo *) oatNew(cUnit, sizeof(SuccessorBlockInfo),
+                                      false, kAllocSuccessor);
+    successorBlockInfo->block = caseBlock;
+    successorBlockInfo->key =
         (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ?
-        kPackedSwitch : kSparseSwitch;
-    oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, size,
-                        kListSuccessorBlocks);
-
-    for (i = 0; i < size; i++) {
-        BasicBlock *caseBlock = findBlock(cUnit, curOffset + targetTable[i],
-                                          /* split */
-                                          true,
-                                          /* create */
-                                          true,
-                                          /* immedPredBlockP */
-                                          &curBlock);
-        SuccessorBlockInfo *successorBlockInfo =
-            (SuccessorBlockInfo *) oatNew(cUnit, sizeof(SuccessorBlockInfo),
-                                          false, kAllocSuccessor);
-        successorBlockInfo->block = caseBlock;
-        successorBlockInfo->key = (insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH)?
-                                  firstKey + i : keyTable[i];
-        oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
-                              (intptr_t) successorBlockInfo);
-        oatInsertGrowableList(cUnit, caseBlock->predecessors,
-                              (intptr_t)curBlock);
-    }
-
-    /* Fall-through case */
-    BasicBlock* fallthroughBlock = findBlock(cUnit,
-                                             curOffset +  width,
-                                             /* split */
-                                             false,
-                                             /* create */
-                                             true,
-                                             /* immedPredBlockP */
-                                             NULL);
-    curBlock->fallThrough = fallthroughBlock;
-    oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+        firstKey + i : keyTable[i];
+    oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
+                          (intptr_t) successorBlockInfo);
+    oatInsertGrowableList(cUnit, caseBlock->predecessors,
                           (intptr_t)curBlock);
+  }
+
+  /* Fall-through case */
+  BasicBlock* fallthroughBlock = findBlock(cUnit,
+                                           curOffset +  width,
+                                           /* split */
+                                           false,
+                                           /* create */
+                                           true,
+                                           /* immedPredBlockP */
+                                           NULL);
+  curBlock->fallThrough = fallthroughBlock;
+  oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+                        (intptr_t)curBlock);
 }
 
 /* Process instructions with the kThrow flag */
@@ -653,77 +651,76 @@
                      ArenaBitVector* tryBlockAddr, const u2* codePtr,
                      const u2* codeEnd)
 {
-    const DexFile::CodeItem* code_item = cUnit->code_item;
+  const DexFile::CodeItem* code_item = cUnit->code_item;
 
-    /* In try block */
-    if (oatIsBitSet(tryBlockAddr, curOffset)) {
-        CatchHandlerIterator iterator(*code_item, curOffset);
+  /* In try block */
+  if (oatIsBitSet(tryBlockAddr, curOffset)) {
+    CatchHandlerIterator iterator(*code_item, curOffset);
 
-        if (curBlock->successorBlockList.blockListType != kNotUsed) {
-            LOG(FATAL) << "Successor block list already in use: " <<
-                 (int)curBlock->successorBlockList.blockListType;
-        }
-
-        curBlock->successorBlockList.blockListType = kCatch;
-        oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, 2,
-                            kListSuccessorBlocks);
-
-        for (;iterator.HasNext(); iterator.Next()) {
-            BasicBlock *catchBlock = findBlock(cUnit, iterator.GetHandlerAddress(),
-                                               false /* split*/,
-                                               false /* creat */,
-                                               NULL  /* immedPredBlockP */);
-            catchBlock->catchEntry = true;
-            SuccessorBlockInfo *successorBlockInfo = (SuccessorBlockInfo *)
-                  oatNew(cUnit, sizeof(SuccessorBlockInfo), false,
-                  kAllocSuccessor);
-            successorBlockInfo->block = catchBlock;
-            successorBlockInfo->key = iterator.GetHandlerTypeIndex();
-            oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
-                                  (intptr_t) successorBlockInfo);
-            oatInsertGrowableList(cUnit, catchBlock->predecessors,
-                                  (intptr_t)curBlock);
-        }
-    } else {
-        BasicBlock *ehBlock = oatNewBB(cUnit, kExceptionHandling,
-                                       cUnit->numBlocks++);
-        curBlock->taken = ehBlock;
-        oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) ehBlock);
-        ehBlock->startOffset = curOffset;
-        oatInsertGrowableList(cUnit, ehBlock->predecessors, (intptr_t)curBlock);
+    if (curBlock->successorBlockList.blockListType != kNotUsed) {
+      LOG(FATAL) << "Successor block list already in use: "
+                 << (int)curBlock->successorBlockList.blockListType;
     }
 
-    /*
-     * Force the current block to terminate.
-     *
-     * Data may be present before codeEnd, so we need to parse it to know
-     * whether it is code or data.
-     */
-    if (codePtr < codeEnd) {
-        /* Create a fallthrough block for real instructions (incl. NOP) */
-        if (contentIsInsn(codePtr)) {
-            BasicBlock *fallthroughBlock = findBlock(cUnit,
-                                                     curOffset + width,
-                                                     /* split */
-                                                     false,
-                                                     /* create */
-                                                     true,
-                                                     /* immedPredBlockP */
-                                                     NULL);
-            /*
-             * THROW is an unconditional branch.  NOTE:
-             * THROW_VERIFICATION_ERROR is also an unconditional
-             * branch, but we shouldn't treat it as such until we have
-             * a dead code elimination pass (which won't be important
-             * until inlining w/ constant propogation is implemented.
-             */
-            if (insn->dalvikInsn.opcode != Instruction::THROW) {
-                curBlock->fallThrough = fallthroughBlock;
-                oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
-                                      (intptr_t)curBlock);
-            }
-        }
+    curBlock->successorBlockList.blockListType = kCatch;
+    oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, 2,
+                        kListSuccessorBlocks);
+
+    for (;iterator.HasNext(); iterator.Next()) {
+      BasicBlock *catchBlock = findBlock(cUnit, iterator.GetHandlerAddress(),
+                                         false /* split*/,
+                                         false /* creat */,
+                                         NULL  /* immedPredBlockP */);
+      catchBlock->catchEntry = true;
+      SuccessorBlockInfo *successorBlockInfo = (SuccessorBlockInfo *)
+          oatNew(cUnit, sizeof(SuccessorBlockInfo), false, kAllocSuccessor);
+      successorBlockInfo->block = catchBlock;
+      successorBlockInfo->key = iterator.GetHandlerTypeIndex();
+      oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
+                            (intptr_t) successorBlockInfo);
+      oatInsertGrowableList(cUnit, catchBlock->predecessors,
+                            (intptr_t)curBlock);
     }
+  } else {
+    BasicBlock *ehBlock = oatNewBB(cUnit, kExceptionHandling,
+                                   cUnit->numBlocks++);
+    curBlock->taken = ehBlock;
+    oatInsertGrowableList(cUnit, &cUnit->blockList, (intptr_t) ehBlock);
+    ehBlock->startOffset = curOffset;
+    oatInsertGrowableList(cUnit, ehBlock->predecessors, (intptr_t)curBlock);
+  }
+
+  /*
+   * Force the current block to terminate.
+   *
+   * Data may be present before codeEnd, so we need to parse it to know
+   * whether it is code or data.
+   */
+  if (codePtr < codeEnd) {
+    /* Create a fallthrough block for real instructions (incl. NOP) */
+    if (contentIsInsn(codePtr)) {
+      BasicBlock *fallthroughBlock = findBlock(cUnit,
+                                               curOffset + width,
+                                               /* split */
+                                               false,
+                                               /* create */
+                                               true,
+                                               /* immedPredBlockP */
+                                               NULL);
+      /*
+       * THROW is an unconditional branch.  NOTE:
+       * THROW_VERIFICATION_ERROR is also an unconditional
+       * branch, but we shouldn't treat it as such until we have
+       * a dead code elimination pass (which won't be important
+       * until inlining w/ constant propogation is implemented.
+       */
+      if (insn->dalvikInsn.opcode != Instruction::THROW) {
+        curBlock->fallThrough = fallthroughBlock;
+        oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+                              (intptr_t)curBlock);
+      }
+    }
+  }
 }
 
 void oatInit(CompilationUnit* cUnit, const Compiler& compiler) {
@@ -741,383 +738,387 @@
                                  const ClassLoader* class_loader,
                                  const DexFile& dex_file)
 {
-    VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
+  VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
 
-    const u2* codePtr = code_item->insns_;
-    const u2* codeEnd = code_item->insns_ + code_item->insns_size_in_code_units_;
-    int numBlocks = 0;
-    unsigned int curOffset = 0;
+  const u2* codePtr = code_item->insns_;
+  const u2* codeEnd = code_item->insns_ + code_item->insns_size_in_code_units_;
+  int numBlocks = 0;
+  unsigned int curOffset = 0;
 
-    ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-    UniquePtr<CompilationUnit> cUnit(new CompilationUnit);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  UniquePtr<CompilationUnit> cUnit(new CompilationUnit);
 
-    oatInit(cUnit.get(), compiler);
+  oatInit(cUnit.get(), compiler);
 
-    cUnit->compiler = &compiler;
-    cUnit->class_linker = class_linker;
-    cUnit->dex_file = &dex_file;
-    cUnit->dex_cache = class_linker->FindDexCache(dex_file);
-    cUnit->method_idx = method_idx;
-    cUnit->code_item = code_item;
-    cUnit->access_flags = access_flags;
-    cUnit->shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
-    cUnit->instructionSet = compiler.GetInstructionSet();
-    cUnit->insns = code_item->insns_;
-    cUnit->insnsSize = code_item->insns_size_in_code_units_;
-    cUnit->numIns = code_item->ins_size_;
-    cUnit->numRegs = code_item->registers_size_ - cUnit->numIns;
-    cUnit->numOuts = code_item->outs_size_;
-    /* Adjust this value accordingly once inlining is performed */
-    cUnit->numDalvikRegisters = code_item->registers_size_;
-    // TODO: set this from command line
-    cUnit->compilerFlipMatch = false;
-    bool useMatch = !cUnit->compilerMethodMatch.empty();
-    bool match = useMatch && (cUnit->compilerFlipMatch ^
-        (PrettyMethod(method_idx, dex_file).find(cUnit->compilerMethodMatch) != std::string::npos));
-    if (!useMatch || match) {
-        cUnit->disableOpt = kCompilerOptimizerDisableFlags;
-        cUnit->enableDebug = kCompilerDebugFlags;
-        cUnit->printMe = VLOG_IS_ON(compiler) || (cUnit->enableDebug & (1 << kDebugVerbose));
-    }
-    if (cUnit->instructionSet == kX86) {
-        // Disable optimizations on X86 for now
-        cUnit->disableOpt = -1;
-    }
-    /* Are we generating code for the debugger? */
-    if (compiler.IsDebuggingSupported()) {
-        cUnit->genDebugger = true;
-        // Yes, disable most optimizations
-        cUnit->disableOpt |= (
-            (1 << kLoadStoreElimination) |
-            (1 << kLoadHoisting) |
-            (1 << kSuppressLoads) |
-            (1 << kPromoteRegs) |
-            (1 << kBBOpt) |
-            (1 << kMatch) |
-            (1 << kTrackLiveTemps));
+  cUnit->compiler = &compiler;
+  cUnit->class_linker = class_linker;
+  cUnit->dex_file = &dex_file;
+  cUnit->dex_cache = class_linker->FindDexCache(dex_file);
+  cUnit->method_idx = method_idx;
+  cUnit->code_item = code_item;
+  cUnit->access_flags = access_flags;
+  cUnit->shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
+  cUnit->instructionSet = compiler.GetInstructionSet();
+  cUnit->insns = code_item->insns_;
+  cUnit->insnsSize = code_item->insns_size_in_code_units_;
+  cUnit->numIns = code_item->ins_size_;
+  cUnit->numRegs = code_item->registers_size_ - cUnit->numIns;
+  cUnit->numOuts = code_item->outs_size_;
+  /* Adjust this value accordingly once inlining is performed */
+  cUnit->numDalvikRegisters = code_item->registers_size_;
+  // TODO: set this from command line
+  cUnit->compilerFlipMatch = false;
+  bool useMatch = !cUnit->compilerMethodMatch.empty();
+  bool match = useMatch && (cUnit->compilerFlipMatch ^
+      (PrettyMethod(method_idx, dex_file).find(cUnit->compilerMethodMatch) !=
+       std::string::npos));
+  if (!useMatch || match) {
+    cUnit->disableOpt = kCompilerOptimizerDisableFlags;
+    cUnit->enableDebug = kCompilerDebugFlags;
+    cUnit->printMe = VLOG_IS_ON(compiler) ||
+        (cUnit->enableDebug & (1 << kDebugVerbose));
+  }
+  if (cUnit->instructionSet == kX86) {
+    // Disable optimizations on X86 for now
+    cUnit->disableOpt = -1;
+  }
+  /* Are we generating code for the debugger? */
+  if (compiler.IsDebuggingSupported()) {
+    cUnit->genDebugger = true;
+    // Yes, disable most optimizations
+    cUnit->disableOpt |= (
+        (1 << kLoadStoreElimination) |
+        (1 << kLoadHoisting) |
+        (1 << kSuppressLoads) |
+        (1 << kPromoteRegs) |
+        (1 << kBBOpt) |
+        (1 << kMatch) |
+        (1 << kTrackLiveTemps));
+  }
+
+  /* Gathering opcode stats? */
+  if (kCompilerDebugFlags & (1 << kDebugCountOpcodes)) {
+    cUnit->opcodeCount = (int*)oatNew(cUnit.get(),
+       kNumPackedOpcodes * sizeof(int), true, kAllocMisc);
+  }
+
+  /* Assume non-throwing leaf */
+  cUnit->attrs = (METHOD_IS_LEAF | METHOD_IS_THROW_FREE);
+
+  /* Initialize the block list, estimate size based on insnsSize */
+  oatInitGrowableList(cUnit.get(), &cUnit->blockList, cUnit->insnsSize,
+                      kListBlockList);
+
+  /* Initialize the switchTables list */
+  oatInitGrowableList(cUnit.get(), &cUnit->switchTables, 4,
+                      kListSwitchTables);
+
+  /* Intialize the fillArrayData list */
+  oatInitGrowableList(cUnit.get(), &cUnit->fillArrayData, 4,
+                      kListFillArrayData);
+
+  /* Intialize the throwLaunchpads list, estimate size based on insnsSize */
+  oatInitGrowableList(cUnit.get(), &cUnit->throwLaunchpads, cUnit->insnsSize,
+                      kListThrowLaunchPads);
+
+  /* Intialize the instrinsicLaunchpads list */
+  oatInitGrowableList(cUnit.get(), &cUnit->intrinsicLaunchpads, 4,
+                      kListMisc);
+
+
+  /* Intialize the suspendLaunchpads list */
+  oatInitGrowableList(cUnit.get(), &cUnit->suspendLaunchpads, 2048,
+                      kListSuspendLaunchPads);
+
+  /* Allocate the bit-vector to track the beginning of basic blocks */
+  ArenaBitVector *tryBlockAddr = oatAllocBitVector(cUnit.get(),
+                                                   cUnit->insnsSize,
+                                                   true /* expandable */);
+  cUnit->tryBlockAddr = tryBlockAddr;
+
+  /* Create the default entry and exit blocks and enter them to the list */
+  BasicBlock *entryBlock = oatNewBB(cUnit.get(), kEntryBlock, numBlocks++);
+  BasicBlock *exitBlock = oatNewBB(cUnit.get(), kExitBlock, numBlocks++);
+
+  cUnit->entryBlock = entryBlock;
+  cUnit->exitBlock = exitBlock;
+
+  oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) entryBlock);
+  oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) exitBlock);
+
+  /* Current block to record parsed instructions */
+  BasicBlock *curBlock = oatNewBB(cUnit.get(), kDalvikByteCode, numBlocks++);
+  curBlock->startOffset = 0;
+  oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) curBlock);
+  /* Add first block to the fast lookup cache */
+  cUnit->blockMap.Put(curBlock->startOffset, curBlock);
+  entryBlock->fallThrough = curBlock;
+  oatInsertGrowableList(cUnit.get(), curBlock->predecessors,
+                        (intptr_t)entryBlock);
+
+  /*
+   * Store back the number of blocks since new blocks may be created of
+   * accessing cUnit.
+   */
+  cUnit->numBlocks = numBlocks;
+
+  /* Identify code range in try blocks and set up the empty catch blocks */
+  processTryCatchBlocks(cUnit.get());
+
+  /* Set up for simple method detection */
+  int numPatterns = sizeof(specialPatterns)/sizeof(specialPatterns[0]);
+  bool livePattern = (numPatterns > 0) && !(cUnit->disableOpt & (1 << kMatch));
+  bool* deadPattern = (bool*)oatNew(cUnit.get(), sizeof(bool) * numPatterns,
+                                     kAllocMisc);
+  SpecialCaseHandler specialCase = kNoHandler;
+  int patternPos = 0;
+
+  /* Parse all instructions and put them into containing basic blocks */
+  while (codePtr < codeEnd) {
+    MIR *insn = (MIR *) oatNew(cUnit.get(), sizeof(MIR), true, kAllocMIR);
+    insn->offset = curOffset;
+    int width = parseInsn(cUnit.get(), codePtr, &insn->dalvikInsn, false);
+    insn->width = width;
+    Instruction::Code opcode = insn->dalvikInsn.opcode;
+    if (cUnit->opcodeCount != NULL) {
+      cUnit->opcodeCount[static_cast<int>(opcode)]++;
     }
 
-    /* Gathering opcode stats? */
-    if (kCompilerDebugFlags & (1 << kDebugCountOpcodes)) {
-        cUnit->opcodeCount = (int*)oatNew(cUnit.get(),
-            kNumPackedOpcodes * sizeof(int), true, kAllocMisc);
+    /* Terminate when the data section is seen */
+    if (width == 0)
+      break;
+
+    /* Possible simple method? */
+    if (livePattern) {
+      livePattern = false;
+      specialCase = kNoHandler;
+      for (int i = 0; i < numPatterns; i++) {
+        if (!deadPattern[i]) {
+          if (specialPatterns[i].opcodes[patternPos] == opcode) {
+            livePattern = true;
+            specialCase = specialPatterns[i].handlerCode;
+          } else {
+             deadPattern[i] = true;
+          }
+        }
+      }
+    patternPos++;
     }
 
-    /* Assume non-throwing leaf */
-    cUnit->attrs = (METHOD_IS_LEAF | METHOD_IS_THROW_FREE);
+    oatAppendMIR(curBlock, insn);
 
-    /* Initialize the block list, estimate size based on insnsSize */
-    oatInitGrowableList(cUnit.get(), &cUnit->blockList, cUnit->insnsSize,
-                        kListBlockList);
+    codePtr += width;
+    int flags = Instruction::Flags(insn->dalvikInsn.opcode);
 
-    /* Initialize the switchTables list */
-    oatInitGrowableList(cUnit.get(), &cUnit->switchTables, 4,
-                        kListSwitchTables);
+    int dfFlags = oatDataFlowAttributes[insn->dalvikInsn.opcode];
 
-    /* Intialize the fillArrayData list */
-    oatInitGrowableList(cUnit.get(), &cUnit->fillArrayData, 4,
-                        kListFillArrayData);
+    if (dfFlags & DF_HAS_DEFS) {
+      cUnit->defCount += (dfFlags & DF_DA_WIDE) ? 2 : 1;
+    }
 
-    /* Intialize the throwLaunchpads list, estimate size based on insnsSize */
-    oatInitGrowableList(cUnit.get(), &cUnit->throwLaunchpads, cUnit->insnsSize,
-                        kListThrowLaunchPads);
+    if (flags & Instruction::kBranch) {
+      curBlock = processCanBranch(cUnit.get(), curBlock, insn, curOffset,
+                                  width, flags, codePtr, codeEnd);
+    } else if (flags & Instruction::kReturn) {
+      curBlock->fallThrough = exitBlock;
+      oatInsertGrowableList(cUnit.get(), exitBlock->predecessors,
+                            (intptr_t)curBlock);
+      /*
+       * Terminate the current block if there are instructions
+       * afterwards.
+       */
+      if (codePtr < codeEnd) {
+        /*
+         * Create a fallthrough block for real instructions
+         * (incl. NOP).
+         */
+        if (contentIsInsn(codePtr)) {
+            findBlock(cUnit.get(), curOffset + width,
+                      /* split */
+                      false,
+                      /* create */
+                      true,
+                      /* immedPredBlockP */
+                      NULL);
+        }
+      }
+    } else if (flags & Instruction::kThrow) {
+      processCanThrow(cUnit.get(), curBlock, insn, curOffset, width, flags,
+                      tryBlockAddr, codePtr, codeEnd);
+    } else if (flags & Instruction::kSwitch) {
+      processCanSwitch(cUnit.get(), curBlock, insn, curOffset, width, flags);
+    }
+    curOffset += width;
+    BasicBlock *nextBlock = findBlock(cUnit.get(), curOffset,
+                                      /* split */
+                                      false,
+                                      /* create */
+                                      false,
+                                      /* immedPredBlockP */
+                                      NULL);
+    if (nextBlock) {
+      /*
+       * The next instruction could be the target of a previously parsed
+       * forward branch so a block is already created. If the current
+       * instruction is not an unconditional branch, connect them through
+       * the fall-through link.
+       */
+      DCHECK(curBlock->fallThrough == NULL ||
+             curBlock->fallThrough == nextBlock ||
+             curBlock->fallThrough == exitBlock);
 
-    /* Intialize the instrinsicLaunchpads list */
-    oatInitGrowableList(cUnit.get(), &cUnit->intrinsicLaunchpads, 4,
-                        kListMisc);
+      if ((curBlock->fallThrough == NULL) && (flags & Instruction::kContinue)) {
+        curBlock->fallThrough = nextBlock;
+        oatInsertGrowableList(cUnit.get(), nextBlock->predecessors,
+                              (intptr_t)curBlock);
+      }
+      curBlock = nextBlock;
+    }
+  }
 
+  if (!(cUnit->disableOpt & (1 << kSkipLargeMethodOptimization))) {
+    if ((cUnit->numBlocks > MANY_BLOCKS) ||
+        ((cUnit->numBlocks > MANY_BLOCKS_INITIALIZER) &&
+      PrettyMethod(method_idx, dex_file, false).find("init>") !=
+          std::string::npos)) {
+        cUnit->qdMode = true;
+    }
+  }
 
-    /* Intialize the suspendLaunchpads list */
-    oatInitGrowableList(cUnit.get(), &cUnit->suspendLaunchpads, 2048,
-                        kListSuspendLaunchPads);
+  if (cUnit->qdMode) {
+    cUnit->disableDataflow = true;
+    // Disable optimization which require dataflow/ssa
+    cUnit->disableOpt |=
+        (1 << kNullCheckElimination) |
+        (1 << kBBOpt) |
+        (1 << kPromoteRegs);
+    if (cUnit->printMe) {
+        LOG(INFO) << "QD mode enabled: "
+                  << PrettyMethod(method_idx, dex_file)
+                  << " too big: " << cUnit->numBlocks;
+    }
+  }
 
-    /* Allocate the bit-vector to track the beginning of basic blocks */
-    ArenaBitVector *tryBlockAddr = oatAllocBitVector(cUnit.get(),
-                                                     cUnit->insnsSize,
-                                                     true /* expandable */);
-    cUnit->tryBlockAddr = tryBlockAddr;
+  if (cUnit->printMe) {
+    oatDumpCompilationUnit(cUnit.get());
+  }
 
-    /* Create the default entry and exit blocks and enter them to the list */
-    BasicBlock *entryBlock = oatNewBB(cUnit.get(), kEntryBlock, numBlocks++);
-    BasicBlock *exitBlock = oatNewBB(cUnit.get(), kExitBlock, numBlocks++);
+  if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
+    /* Verify if all blocks are connected as claimed */
+    oatDataFlowAnalysisDispatcher(cUnit.get(), verifyPredInfo, kAllNodes,
+                                  false /* isIterative */);
+  }
 
-    cUnit->entryBlock = entryBlock;
-    cUnit->exitBlock = exitBlock;
+  /* Perform SSA transformation for the whole method */
+  oatMethodSSATransformation(cUnit.get());
 
-    oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) entryBlock);
-    oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) exitBlock);
+  /* Detect loops */
+  oatMethodLoopDetection(cUnit.get());
 
-    /* Current block to record parsed instructions */
-    BasicBlock *curBlock = oatNewBB(cUnit.get(), kDalvikByteCode, numBlocks++);
-    curBlock->startOffset = 0;
-    oatInsertGrowableList(cUnit.get(), &cUnit->blockList, (intptr_t) curBlock);
-    /* Add first block to the fast lookup cache */
-    cUnit->blockMap.Put(curBlock->startOffset, curBlock);
-    entryBlock->fallThrough = curBlock;
-    oatInsertGrowableList(cUnit.get(), curBlock->predecessors,
-                          (intptr_t)entryBlock);
+  /* Count uses */
+  oatMethodUseCount(cUnit.get());
 
+  /* Perform null check elimination */
+  oatMethodNullCheckElimination(cUnit.get());
+
+  /* Do some basic block optimizations */
+  oatMethodBasicBlockOptimization(cUnit.get());
+
+  oatInitializeRegAlloc(cUnit.get());  // Needs to happen after SSA naming
+
+  /* Allocate Registers using simple local allocation scheme */
+  oatSimpleRegAlloc(cUnit.get());
+
+  if (specialCase != kNoHandler) {
     /*
-     * Store back the number of blocks since new blocks may be created of
-     * accessing cUnit.
+     * Custom codegen for special cases.  If for any reason the
+     * special codegen doesn't success, cUnit->firstLIRInsn will
+     * set to NULL;
      */
-    cUnit->numBlocks = numBlocks;
+    oatSpecialMIR2LIR(cUnit.get(), specialCase);
+  }
 
-    /* Identify code range in try blocks and set up the empty catch blocks */
-    processTryCatchBlocks(cUnit.get());
+  /* Convert MIR to LIR, etc. */
+  if (cUnit->firstLIRInsn == NULL) {
+    oatMethodMIR2LIR(cUnit.get());
+  }
 
-    /* Set up for simple method detection */
-    int numPatterns = sizeof(specialPatterns)/sizeof(specialPatterns[0]);
-    bool livePattern = (numPatterns > 0) && !(cUnit->disableOpt & (1 << kMatch));
-    bool* deadPattern = (bool*)oatNew(cUnit.get(), sizeof(bool) * numPatterns,
-                                       kAllocMisc);
-    SpecialCaseHandler specialCase = kNoHandler;
-    int patternPos = 0;
+  // Debugging only
+  if (cUnit->enableDebug & (1 << kDebugDumpCFG)) {
+    oatDumpCFG(cUnit.get(), "/sdcard/cfg/");
+  }
 
-    /* Parse all instructions and put them into containing basic blocks */
-    while (codePtr < codeEnd) {
-        MIR *insn = (MIR *) oatNew(cUnit.get(), sizeof(MIR), true, kAllocMIR);
-        insn->offset = curOffset;
-        int width = parseInsn(cUnit.get(), codePtr, &insn->dalvikInsn, false);
-        insn->width = width;
-        Instruction::Code opcode = insn->dalvikInsn.opcode;
-        if (cUnit->opcodeCount != NULL) {
-            cUnit->opcodeCount[static_cast<int>(opcode)]++;
-        }
+  /* Method is not empty */
+  if (cUnit->firstLIRInsn) {
 
-        /* Terminate when the data section is seen */
-        if (width == 0)
-            break;
+    // mark the targets of switch statement case labels
+    oatProcessSwitchTables(cUnit.get());
 
-        /* Possible simple method? */
-        if (livePattern) {
-            livePattern = false;
-            specialCase = kNoHandler;
-            for (int i = 0; i < numPatterns; i++) {
-                if (!deadPattern[i]) {
-                    if (specialPatterns[i].opcodes[patternPos] == opcode) {
-                        livePattern = true;
-                        specialCase = specialPatterns[i].handlerCode;
-                    } else {
-                        deadPattern[i] = true;
-                    }
-                }
-            }
-            patternPos++;
-        }
-
-        oatAppendMIR(curBlock, insn);
-
-        codePtr += width;
-        int flags = Instruction::Flags(insn->dalvikInsn.opcode);
-
-        int dfFlags = oatDataFlowAttributes[insn->dalvikInsn.opcode];
-
-        if (dfFlags & DF_HAS_DEFS) {
-            cUnit->defCount += (dfFlags & DF_DA_WIDE) ? 2 : 1;
-        }
-
-        if (flags & Instruction::kBranch) {
-            curBlock = processCanBranch(cUnit.get(), curBlock, insn, curOffset,
-                                        width, flags, codePtr, codeEnd);
-        } else if (flags & Instruction::kReturn) {
-            curBlock->fallThrough = exitBlock;
-            oatInsertGrowableList(cUnit.get(), exitBlock->predecessors,
-                                  (intptr_t)curBlock);
-            /*
-             * Terminate the current block if there are instructions
-             * afterwards.
-             */
-            if (codePtr < codeEnd) {
-                /*
-                 * Create a fallthrough block for real instructions
-                 * (incl. NOP).
-                 */
-                if (contentIsInsn(codePtr)) {
-                    findBlock(cUnit.get(), curOffset + width,
-                              /* split */
-                              false,
-                              /* create */
-                              true,
-                              /* immedPredBlockP */
-                              NULL);
-                }
-            }
-        } else if (flags & Instruction::kThrow) {
-            processCanThrow(cUnit.get(), curBlock, insn, curOffset, width, flags,
-                            tryBlockAddr, codePtr, codeEnd);
-        } else if (flags & Instruction::kSwitch) {
-            processCanSwitch(cUnit.get(), curBlock, insn, curOffset, width, flags);
-        }
-        curOffset += width;
-        BasicBlock *nextBlock = findBlock(cUnit.get(), curOffset,
-                                          /* split */
-                                          false,
-                                          /* create */
-                                          false,
-                                          /* immedPredBlockP */
-                                          NULL);
-        if (nextBlock) {
-            /*
-             * The next instruction could be the target of a previously parsed
-             * forward branch so a block is already created. If the current
-             * instruction is not an unconditional branch, connect them through
-             * the fall-through link.
-             */
-            DCHECK(curBlock->fallThrough == NULL ||
-                   curBlock->fallThrough == nextBlock ||
-                   curBlock->fallThrough == exitBlock);
-
-            if ((curBlock->fallThrough == NULL) && (flags & Instruction::kContinue)) {
-                curBlock->fallThrough = nextBlock;
-                oatInsertGrowableList(cUnit.get(), nextBlock->predecessors,
-                                      (intptr_t)curBlock);
-            }
-            curBlock = nextBlock;
-        }
-    }
-
-    if (!(cUnit->disableOpt & (1 << kSkipLargeMethodOptimization))) {
-        if ((cUnit->numBlocks > MANY_BLOCKS) ||
-              ((cUnit->numBlocks > MANY_BLOCKS_INITIALIZER) &&
-               PrettyMethod(method_idx, dex_file, false).find("init>") !=
-               std::string::npos)) {
-            cUnit->qdMode = true;
-        }
-    }
-
-    if (cUnit->qdMode) {
-        cUnit->disableDataflow = true;
-        // Disable optimization which require dataflow/ssa
-        cUnit->disableOpt |=
-            (1 << kNullCheckElimination) |
-            (1 << kBBOpt) |
-            (1 << kPromoteRegs);
-        if (cUnit->printMe) {
-            LOG(INFO) << "QD mode enabled: "
-                      << PrettyMethod(method_idx, dex_file)
-                      << " too big: " << cUnit->numBlocks;
-        }
-    }
+    /* Convert LIR into machine code. */
+    oatAssembleLIR(cUnit.get());
 
     if (cUnit->printMe) {
-        oatDumpCompilationUnit(cUnit.get());
+      oatCodegenDump(cUnit.get());
     }
 
-    if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
-        /* Verify if all blocks are connected as claimed */
-        oatDataFlowAnalysisDispatcher(cUnit.get(), verifyPredInfo, kAllNodes,
-                                      false /* isIterative */);
-    }
-
-    /* Perform SSA transformation for the whole method */
-    oatMethodSSATransformation(cUnit.get());
-
-    /* Detect loops */
-    oatMethodLoopDetection(cUnit.get());
-
-    /* Count uses */
-    oatMethodUseCount(cUnit.get());
-
-    /* Perform null check elimination */
-    oatMethodNullCheckElimination(cUnit.get());
-
-    /* Do some basic block optimizations */
-    oatMethodBasicBlockOptimization(cUnit.get());
-
-    oatInitializeRegAlloc(cUnit.get());  // Needs to happen after SSA naming
-
-    /* Allocate Registers using simple local allocation scheme */
-    oatSimpleRegAlloc(cUnit.get());
-
-    if (specialCase != kNoHandler) {
-        /*
-         * Custom codegen for special cases.  If for any reason the
-         * special codegen doesn't success, cUnit->firstLIRInsn will
-         * set to NULL;
-         */
-        oatSpecialMIR2LIR(cUnit.get(), specialCase);
-    }
-
-    /* Convert MIR to LIR, etc. */
-    if (cUnit->firstLIRInsn == NULL) {
-        oatMethodMIR2LIR(cUnit.get());
-    }
-
-    // Debugging only
-    if (cUnit->enableDebug & (1 << kDebugDumpCFG)) {
-        oatDumpCFG(cUnit.get(), "/sdcard/cfg/");
-    }
-
-    /* Method is not empty */
-    if (cUnit->firstLIRInsn) {
-
-        // mark the targets of switch statement case labels
-        oatProcessSwitchTables(cUnit.get());
-
-        /* Convert LIR into machine code. */
-        oatAssembleLIR(cUnit.get());
-
-        if (cUnit->printMe) {
-            oatCodegenDump(cUnit.get());
+    if (cUnit->opcodeCount != NULL) {
+      LOG(INFO) << "Opcode Count";
+      for (int i = 0; i < kNumPackedOpcodes; i++) {
+        if (cUnit->opcodeCount[i] != 0) {
+          LOG(INFO) << "-C- "
+                    << Instruction::Name(static_cast<Instruction::Code>(i))
+                    << " " << cUnit->opcodeCount[i];
         }
+      }
+    }
+  }
 
-        if (cUnit->opcodeCount != NULL) {
-            LOG(INFO) << "Opcode Count";
-            for (int i = 0; i < kNumPackedOpcodes; i++) {
-                if (cUnit->opcodeCount[i] != 0) {
-                    LOG(INFO) << "-C- "
-                              <<Instruction::Name(static_cast<Instruction::Code>(i))
-                              << " " << cUnit->opcodeCount[i];
-                }
-            }
-        }
-    }
+  // Combine vmap tables - core regs, then fp regs - into vmapTable
+  std::vector<uint16_t> vmapTable;
+  for (size_t i = 0 ; i < cUnit->coreVmapTable.size(); i++) {
+    vmapTable.push_back(cUnit->coreVmapTable[i]);
+  }
+  // If we have a frame, push a marker to take place of lr
+  if (cUnit->frameSize > 0) {
+    vmapTable.push_back(INVALID_VREG);
+  } else {
+    DCHECK_EQ(__builtin_popcount(cUnit->coreSpillMask), 0);
+    DCHECK_EQ(__builtin_popcount(cUnit->fpSpillMask), 0);
+  }
+  // Combine vmap tables - core regs, then fp regs
+  for (uint32_t i = 0; i < cUnit->fpVmapTable.size(); i++) {
+    vmapTable.push_back(cUnit->fpVmapTable[i]);
+  }
+  CompiledMethod* result =
+      new CompiledMethod(cUnit->instructionSet, cUnit->codeBuffer,
+                         cUnit->frameSize, cUnit->coreSpillMask,
+                         cUnit->fpSpillMask, cUnit->mappingTable, vmapTable);
 
-    // Combine vmap tables - core regs, then fp regs - into vmapTable
-    std::vector<uint16_t> vmapTable;
-    for (size_t i = 0 ; i < cUnit->coreVmapTable.size(); i++) {
-        vmapTable.push_back(cUnit->coreVmapTable[i]);
-    }
-    // If we have a frame, push a marker to take place of lr
-    if (cUnit->frameSize > 0) {
-        vmapTable.push_back(INVALID_VREG);
-    } else {
-        DCHECK_EQ(__builtin_popcount(cUnit->coreSpillMask), 0);
-        DCHECK_EQ(__builtin_popcount(cUnit->fpSpillMask), 0);
-    }
-    // Combine vmap tables - core regs, then fp regs
-    for (uint32_t i = 0; i < cUnit->fpVmapTable.size(); i++) {
-        vmapTable.push_back(cUnit->fpVmapTable[i]);
-    }
-    CompiledMethod* result = new CompiledMethod(cUnit->instructionSet, cUnit->codeBuffer,
-                                                cUnit->frameSize, cUnit->coreSpillMask,
-                                                cUnit->fpSpillMask, cUnit->mappingTable,
-                                                vmapTable);
-
-    VLOG(compiler) << "Compiled " << PrettyMethod(method_idx, dex_file)
-       << " (" << (cUnit->codeBuffer.size() * sizeof(cUnit->codeBuffer[0]))
-       << " bytes)";
+  VLOG(compiler) << "Compiled " << PrettyMethod(method_idx, dex_file)
+     << " (" << (cUnit->codeBuffer.size() * sizeof(cUnit->codeBuffer[0]))
+     << " bytes)";
 
 #ifdef WITH_MEMSTATS
-    if (cUnit->enableDebug & (1 << kDebugShowMemoryUsage)) {
-        oatDumpMemStats(cUnit.get());
-    }
+  if (cUnit->enableDebug & (1 << kDebugShowMemoryUsage)) {
+    oatDumpMemStats(cUnit.get());
+  }
 #endif
 
-    oatArenaReset(cUnit.get());
+  oatArenaReset(cUnit.get());
 
-    return result;
+  return result;
 }
 
 }  // namespace art
 
-extern "C" art::CompiledMethod* ArtCompileMethod(art::Compiler& compiler,
-                                                 const art::DexFile::CodeItem* code_item,
-                                                 uint32_t access_flags, uint32_t method_idx,
-                                                 const art::ClassLoader* class_loader,
-                                                 const art::DexFile& dex_file)
+extern "C" art::CompiledMethod*
+    ArtCompileMethod(art::Compiler& compiler,
+                     const art::DexFile::CodeItem* code_item,
+                     uint32_t access_flags, uint32_t method_idx,
+                     const art::ClassLoader* class_loader,
+                     const art::DexFile& dex_file)
 {
   CHECK_EQ(compiler.GetInstructionSet(), art::oatInstructionSet());
-  return art::oatCompileMethod(compiler, code_item, access_flags, method_idx, class_loader, dex_file);
+  return art::oatCompileMethod(compiler, code_item, access_flags, method_idx,
+                 class_loader, dex_file);
 }
diff --git a/src/compiler/IntermediateRep.cc b/src/compiler/IntermediateRep.cc
index d1ba45c..237f5e0 100644
--- a/src/compiler/IntermediateRep.cc
+++ b/src/compiler/IntermediateRep.cc
@@ -20,40 +20,40 @@
 namespace art {
 
 static const char* gOpKindNames[kOpInvalid + 1] = {
-    "OpMov",
-    "OpMvn",
-    "OpCmp",
-    "OpLsl",
-    "OpLsr",
-    "OpAsr",
-    "OpRor",
-    "OpNot",
-    "OpAnd",
-    "OpOr",
-    "OpXor",
-    "OpNeg",
-    "OpAdd",
-    "OpAdc",
-    "OpSub",
-    "OpSbc",
-    "OpRsub",
-    "OpMul",
-    "OpDiv",
-    "OpRem",
-    "OpBic",
-    "OpCmn",
-    "OpTst",
-    "OpBkpt",
-    "OpBlx",
-    "OpPush",
-    "OpPop",
-    "Op2Char",
-    "Op2Short",
-    "Op2Byte",
-    "OpCondBr",
-    "OpUncondBr",
-    "OpBx",
-    "OpInvalid",
+  "OpMov",
+  "OpMvn",
+  "OpCmp",
+  "OpLsl",
+  "OpLsr",
+  "OpAsr",
+  "OpRor",
+  "OpNot",
+  "OpAnd",
+  "OpOr",
+  "OpXor",
+  "OpNeg",
+  "OpAdd",
+  "OpAdc",
+  "OpSub",
+  "OpSbc",
+  "OpRsub",
+  "OpMul",
+  "OpDiv",
+  "OpRem",
+  "OpBic",
+  "OpCmn",
+  "OpTst",
+  "OpBkpt",
+  "OpBlx",
+  "OpPush",
+  "OpPop",
+  "Op2Char",
+  "Op2Short",
+  "Op2Byte",
+  "OpCondBr",
+  "OpUncondBr",
+  "OpBx",
+  "OpInvalid",
 };
 
 std::ostream& operator<<(std::ostream& os, const OpKind& kind) {
@@ -68,62 +68,62 @@
 /* Allocate a new basic block */
 BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId)
 {
-    BasicBlock* bb = (BasicBlock* )oatNew(cUnit, sizeof(BasicBlock), true,
-                                          kAllocBB);
-    bb->blockType = blockType;
-    bb->id = blockId;
-    bb->predecessors = (GrowableList*) oatNew(cUnit, sizeof(GrowableList),
-                                              false, kAllocPredecessors);
-    oatInitGrowableList(cUnit, bb->predecessors,
-                        (blockType == kExitBlock) ? 2048 : 2,
-                        kListPredecessors);
-    return bb;
+  BasicBlock* bb = (BasicBlock* )oatNew(cUnit, sizeof(BasicBlock), true,
+                                        kAllocBB);
+  bb->blockType = blockType;
+  bb->id = blockId;
+  bb->predecessors = (GrowableList*) oatNew(cUnit, sizeof(GrowableList),
+                                            false, kAllocPredecessors);
+  oatInitGrowableList(cUnit, bb->predecessors,
+                      (blockType == kExitBlock) ? 2048 : 2,
+                      kListPredecessors);
+  return bb;
 }
 
 /* Insert an MIR instruction to the end of a basic block */
 void oatAppendMIR(BasicBlock* bb, MIR* mir)
 {
-    if (bb->firstMIRInsn == NULL) {
-        DCHECK(bb->lastMIRInsn == NULL);
-        bb->lastMIRInsn = bb->firstMIRInsn = mir;
-        mir->prev = mir->next = NULL;
-    } else {
-        bb->lastMIRInsn->next = mir;
-        mir->prev = bb->lastMIRInsn;
-        mir->next = NULL;
-        bb->lastMIRInsn = mir;
-    }
+  if (bb->firstMIRInsn == NULL) {
+    DCHECK(bb->lastMIRInsn == NULL);
+    bb->lastMIRInsn = bb->firstMIRInsn = mir;
+    mir->prev = mir->next = NULL;
+  } else {
+    bb->lastMIRInsn->next = mir;
+    mir->prev = bb->lastMIRInsn;
+    mir->next = NULL;
+    bb->lastMIRInsn = mir;
+  }
 }
 
 /* Insert an MIR instruction to the head of a basic block */
 void oatPrependMIR(BasicBlock* bb, MIR* mir)
 {
-    if (bb->firstMIRInsn == NULL) {
-        DCHECK(bb->lastMIRInsn == NULL);
-        bb->lastMIRInsn = bb->firstMIRInsn = mir;
-        mir->prev = mir->next = NULL;
-    } else {
-        bb->firstMIRInsn->prev = mir;
-        mir->next = bb->firstMIRInsn;
-        mir->prev = NULL;
-        bb->firstMIRInsn = mir;
-    }
+  if (bb->firstMIRInsn == NULL) {
+    DCHECK(bb->lastMIRInsn == NULL);
+    bb->lastMIRInsn = bb->firstMIRInsn = mir;
+    mir->prev = mir->next = NULL;
+  } else {
+    bb->firstMIRInsn->prev = mir;
+    mir->next = bb->firstMIRInsn;
+    mir->prev = NULL;
+    bb->firstMIRInsn = mir;
+  }
 }
 
 /* Insert a MIR instruction after the specified MIR */
 void oatInsertMIRAfter(BasicBlock* bb, MIR* currentMIR, MIR* newMIR)
 {
-    newMIR->prev = currentMIR;
-    newMIR->next = currentMIR->next;
-    currentMIR->next = newMIR;
+  newMIR->prev = currentMIR;
+  newMIR->next = currentMIR->next;
+  currentMIR->next = newMIR;
 
-    if (newMIR->next) {
-        /* Is not the last MIR in the block */
-        newMIR->next->prev = newMIR;
-    } else {
-        /* Is the last MIR in the block */
-        bb->lastMIRInsn = newMIR;
-    }
+  if (newMIR->next) {
+    /* Is not the last MIR in the block */
+    newMIR->next->prev = newMIR;
+  } else {
+    /* Is the last MIR in the block */
+    bb->lastMIRInsn = newMIR;
+  }
 }
 
 /*
@@ -132,16 +132,16 @@
  */
 void oatAppendLIR(CompilationUnit *cUnit, LIR* lir)
 {
-    if (cUnit->firstLIRInsn == NULL) {
-        DCHECK(cUnit->lastLIRInsn == NULL);
-        cUnit->lastLIRInsn = cUnit->firstLIRInsn = lir;
-        lir->prev = lir->next = NULL;
-    } else {
-        cUnit->lastLIRInsn->next = lir;
-        lir->prev = cUnit->lastLIRInsn;
-        lir->next = NULL;
-        cUnit->lastLIRInsn = lir;
-    }
+  if (cUnit->firstLIRInsn == NULL) {
+    DCHECK(cUnit->lastLIRInsn == NULL);
+     cUnit->lastLIRInsn = cUnit->firstLIRInsn = lir;
+    lir->prev = lir->next = NULL;
+  } else {
+    cUnit->lastLIRInsn->next = lir;
+    lir->prev = cUnit->lastLIRInsn;
+    lir->next = NULL;
+    cUnit->lastLIRInsn = lir;
+  }
 }
 
 /*
@@ -152,13 +152,13 @@
  */
 void oatInsertLIRBefore(LIR* currentLIR, LIR* newLIR)
 {
-    DCHECK(currentLIR->prev != NULL);
-    LIR *prevLIR = currentLIR->prev;
+  DCHECK(currentLIR->prev != NULL);
+  LIR *prevLIR = currentLIR->prev;
 
-    prevLIR->next = newLIR;
-    newLIR->prev = prevLIR;
-    newLIR->next = currentLIR;
-    currentLIR->prev = newLIR;
+  prevLIR->next = newLIR;
+  newLIR->prev = prevLIR;
+  newLIR->next = currentLIR;
+  currentLIR->prev = newLIR;
 }
 
 /*
@@ -169,10 +169,10 @@
  */
 void oatInsertLIRAfter(LIR* currentLIR, LIR* newLIR)
 {
-    newLIR->prev = currentLIR;
-    newLIR->next = currentLIR->next;
-    currentLIR->next = newLIR;
-    newLIR->next->prev = newLIR;
+  newLIR->prev = currentLIR;
+  newLIR->next = currentLIR->next;
+  currentLIR->next = newLIR;
+  newLIR->next->prev = newLIR;
 }
 
 }  // namespace art
diff --git a/src/compiler/Ralloc.cc b/src/compiler/Ralloc.cc
index 25acdd5..54728db 100644
--- a/src/compiler/Ralloc.cc
+++ b/src/compiler/Ralloc.cc
@@ -22,63 +22,63 @@
 namespace art {
 
 bool setFp(CompilationUnit* cUnit, int index, bool isFP) {
-    bool change = false;
-    if (cUnit->regLocation[index].highWord) {
-        return change;
-    }
-    if (isFP && !cUnit->regLocation[index].fp) {
-        cUnit->regLocation[index].fp = true;
-        cUnit->regLocation[index].defined = true;
-        change = true;
-    }
+  bool change = false;
+  if (cUnit->regLocation[index].highWord) {
     return change;
+  }
+  if (isFP && !cUnit->regLocation[index].fp) {
+    cUnit->regLocation[index].fp = true;
+    cUnit->regLocation[index].defined = true;
+    change = true;
+  }
+  return change;
 }
 
 bool setCore(CompilationUnit* cUnit, int index, bool isCore) {
-    bool change = false;
-    if (cUnit->regLocation[index].highWord) {
-        return change;
-    }
-    if (isCore && !cUnit->regLocation[index].defined) {
-        cUnit->regLocation[index].core = true;
-        cUnit->regLocation[index].defined = true;
-        change = true;
-    }
+  bool change = false;
+  if (cUnit->regLocation[index].highWord) {
     return change;
+  }
+  if (isCore && !cUnit->regLocation[index].defined) {
+    cUnit->regLocation[index].core = true;
+    cUnit->regLocation[index].defined = true;
+    change = true;
+  }
+  return change;
 }
 
 bool remapNames(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    if (bb->blockType != kDalvikByteCode && bb->blockType != kEntryBlock &&
-        bb->blockType != kExitBlock)
-        return false;
-
-    for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        SSARepresentation *ssaRep = mir->ssaRep;
-        if (ssaRep) {
-            for (int i = 0; i < ssaRep->numUses; i++) {
-                ssaRep->uses[i] = cUnit->phiAliasMap[ssaRep->uses[i]];
-            }
-            for (int i = 0; i < ssaRep->numDefs; i++) {
-                ssaRep->defs[i] = cUnit->phiAliasMap[ssaRep->defs[i]];
-            }
-        }
-    }
+  if (bb->blockType != kDalvikByteCode && bb->blockType != kEntryBlock &&
+      bb->blockType != kExitBlock)
     return false;
+
+  for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    SSARepresentation *ssaRep = mir->ssaRep;
+    if (ssaRep) {
+      for (int i = 0; i < ssaRep->numUses; i++) {
+        ssaRep->uses[i] = cUnit->phiAliasMap[ssaRep->uses[i]];
+      }
+      for (int i = 0; i < ssaRep->numDefs; i++) {
+        ssaRep->defs[i] = cUnit->phiAliasMap[ssaRep->defs[i]];
+      }
+    }
+  }
+  return false;
 }
 
 // Try to find the next move result which might have an FP target
 SSARepresentation* findMoveResult(MIR* mir)
 {
-    SSARepresentation* res = NULL;
-    for (; mir; mir = mir->next) {
-      if ((mir->dalvikInsn.opcode == Instruction::MOVE_RESULT) ||
-          (mir->dalvikInsn.opcode == Instruction::MOVE_RESULT_WIDE)) {
-            res = mir->ssaRep;
-            break;
-        }
+  SSARepresentation* res = NULL;
+  for (; mir; mir = mir->next) {
+    if ((mir->dalvikInsn.opcode == Instruction::MOVE_RESULT) ||
+        (mir->dalvikInsn.opcode == Instruction::MOVE_RESULT_WIDE)) {
+      res = mir->ssaRep;
+      break;
     }
-    return res;
+  }
+  return res;
 }
 
 /*
@@ -88,213 +88,212 @@
  */
 bool inferTypeAndSize(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    MIR *mir;
-    bool changed = false;   // Did anything change?
+  MIR *mir;
+  bool changed = false;   // Did anything change?
 
-    if (bb->dataFlowInfo == NULL) return false;
-    if (bb->blockType != kDalvikByteCode && bb->blockType != kEntryBlock)
-        return false;
+  if (bb->dataFlowInfo == NULL) return false;
+  if (bb->blockType != kDalvikByteCode && bb->blockType != kEntryBlock)
+    return false;
 
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        SSARepresentation *ssaRep = mir->ssaRep;
-        if (ssaRep) {
-            int attrs = oatDataFlowAttributes[mir->dalvikInsn.opcode];
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    SSARepresentation *ssaRep = mir->ssaRep;
+    if (ssaRep) {
+      int attrs = oatDataFlowAttributes[mir->dalvikInsn.opcode];
 
-            // Handle defs
-            if (attrs & (DF_DA | DF_DA_WIDE)) {
-                if (attrs & DF_CORE_A) {
-                    changed |= setCore(cUnit, ssaRep->defs[0], true);
-                }
-                if (attrs & DF_DA_WIDE) {
-                    cUnit->regLocation[ssaRep->defs[0]].wide = true;
-                    cUnit->regLocation[ssaRep->defs[1]].highWord = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, ssaRep->defs[0])+1,
-                              SRegToVReg(cUnit, ssaRep->defs[1]));
-                }
-            }
-
-            // Handles uses
-            int next = 0;
-            if (attrs & (DF_UA | DF_UA_WIDE)) {
-                if (attrs & DF_CORE_A) {
-                    changed |= setCore(cUnit, ssaRep->uses[next], true);
-                }
-                if (attrs & DF_UA_WIDE) {
-                    cUnit->regLocation[ssaRep->uses[next]].wide = true;
-                    cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
-                              SRegToVReg(cUnit, ssaRep->uses[next + 1]));
-                    next += 2;
-                } else {
-                    next++;
-                }
-            }
-            if (attrs & (DF_UB | DF_UB_WIDE)) {
-                if (attrs & DF_CORE_B) {
-                    changed |= setCore(cUnit, ssaRep->uses[next], true);
-                }
-                if (attrs & DF_UB_WIDE) {
-                    cUnit->regLocation[ssaRep->uses[next]].wide = true;
-                    cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
-                              SRegToVReg(cUnit, ssaRep->uses[next + 1]));
-                    next += 2;
-                } else {
-                    next++;
-                }
-            }
-            if (attrs & (DF_UC | DF_UC_WIDE)) {
-                if (attrs & DF_CORE_C) {
-                    changed |= setCore(cUnit, ssaRep->uses[next], true);
-                }
-                if (attrs & DF_UC_WIDE) {
-                    cUnit->regLocation[ssaRep->uses[next]].wide = true;
-                    cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
-                              SRegToVReg(cUnit, ssaRep->uses[next + 1]));
-                }
-            }
-
-            // Special-case handling for format 35c/3rc invokes
-            Instruction::Code opcode = mir->dalvikInsn.opcode;
-            int flags = (static_cast<int>(opcode) >= kNumPackedOpcodes) ? 0 : Instruction::Flags(mir->dalvikInsn.opcode);
-            if ((flags & Instruction::kInvoke) && (attrs & (DF_FORMAT_35C | DF_FORMAT_3RC))) {
-                DCHECK_EQ(next, 0);
-                int target_idx = mir->dalvikInsn.vB;
-                const char* shorty =
-                    oatGetShortyFromTargetIdx(cUnit, target_idx);
-                // Handle result type if floating point
-                if ((shorty[0] == 'F') || (shorty[0] == 'D')) {
-                    // Find move-result that consumes this result
-                    SSARepresentation* tgtRep = findMoveResult(mir->next);
-                    // Might be in next basic block
-                    if (!tgtRep) {
-                        tgtRep = findMoveResult(bb->fallThrough->firstMIRInsn);
-                    }
-                    // Result might not be used at all, so no move-result
-                    if (tgtRep) {
-                        tgtRep->fpDef[0] = true;
-                        changed |= setFp(cUnit, tgtRep->defs[0], true);
-                        if (shorty[0] == 'D') {
-                            tgtRep->fpDef[1] = true;
-                            changed |= setFp(cUnit, tgtRep->defs[1], true);
-                        }
-                    }
-                }
-                int numUses = mir->dalvikInsn.vA;
-                // If this is a non-static invoke, skip implicit "this"
-                if (((mir->dalvikInsn.opcode != Instruction::INVOKE_STATIC) &&
-                    (mir->dalvikInsn.opcode != Instruction::INVOKE_STATIC_RANGE))) {
-                   cUnit->regLocation[ssaRep->uses[next]].defined = true;
-                   cUnit->regLocation[ssaRep->uses[next]].core = true;
-                   next++;
-                }
-                uint32_t cpos = 1;
-                if (strlen(shorty) > 1) {
-                    for (int i = next; i < numUses;) {
-                        DCHECK_LT(cpos, strlen(shorty));
-                        switch (shorty[cpos++]) {
-                            case 'D':
-                                ssaRep->fpUse[i] = true;
-                                ssaRep->fpUse[i+1] = true;
-                                cUnit->regLocation[ssaRep->uses[i]].wide = true;
-                                cUnit->regLocation[ssaRep->uses[i+1]].highWord
-                                    = true;
-                                DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[i])+1,
-                                          SRegToVReg(cUnit, ssaRep->uses[i+1]));
-                                i++;
-                                break;
-                            case 'J':
-                                cUnit->regLocation[ssaRep->uses[i]].wide = true;
-                                cUnit->regLocation[ssaRep->uses[i+1]].highWord
-                                    = true;
-                                DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[i])+1,
-                                          SRegToVReg(cUnit, ssaRep->uses[i+1]));
-                                changed |= setCore(cUnit, ssaRep->uses[i],true);
-                                i++;
-                               break;
-                            case 'F':
-                                ssaRep->fpUse[i] = true;
-                                break;
-                           default:
-                                changed |= setCore(cUnit,ssaRep->uses[i], true);
-                                break;
-                        }
-                        i++;
-                    }
-                }
-            }
-
-            for (int i=0; ssaRep->fpUse && i< ssaRep->numUses; i++) {
-                if (ssaRep->fpUse[i])
-                    changed |= setFp(cUnit, ssaRep->uses[i], true);
-            }
-            for (int i=0; ssaRep->fpDef && i< ssaRep->numDefs; i++) {
-                if (ssaRep->fpDef[i])
-                    changed |= setFp(cUnit, ssaRep->defs[i], true);
-            }
-            // Special-case handling for moves & Phi
-            if (attrs & (DF_IS_MOVE | DF_NULL_TRANSFER_N)) {
-                // If any of our inputs or outputs is defined, set all
-                bool definedFP = false;
-                bool definedCore = false;
-                definedFP |= (cUnit->regLocation[ssaRep->defs[0]].defined &&
-                              cUnit->regLocation[ssaRep->defs[0]].fp);
-                definedCore |= (cUnit->regLocation[ssaRep->defs[0]].defined &&
-                                cUnit->regLocation[ssaRep->defs[0]].core);
-                for (int i = 0; i < ssaRep->numUses; i++) {
-                    definedFP |= (cUnit->regLocation[ssaRep->uses[i]].defined &&
-                                  cUnit->regLocation[ssaRep->uses[i]].fp);
-                    definedCore |= (cUnit->regLocation[ssaRep->uses[i]].defined
-                                  && cUnit->regLocation[ssaRep->uses[i]].core);
-                }
-                /*
-                 * TODO: cleaner fix
-                 * We don't normally expect to see a Dalvik register
-                 * definition used both as a floating point and core
-                 * value.  However, the instruction rewriting that occurs
-                 * during verification can eliminate some type information,
-                 * leaving us confused.  The real fix here is either to
-                 * add explicit type information to Dalvik byte codes,
-                 * or to recognize THROW_VERIFICATION_ERROR as
-                 * an unconditional branch and support dead code elimination.
-                 * As a workaround we can detect this situation and
-                 * disable register promotion (which is the only thing that
-                 * relies on distinctions between core and fp usages.
-                 */
-                if ((definedFP && definedCore) &&
-                    ((cUnit->disableOpt & (1 << kPromoteRegs)) == 0)) {
-                    LOG(WARNING) << PrettyMethod(cUnit->method_idx, *cUnit->dex_file)
-                        << " op at block " << bb->id
-                        << " has both fp and core uses for same def.";
-                    cUnit->disableOpt |= (1 << kPromoteRegs);
-                }
-                changed |= setFp(cUnit, ssaRep->defs[0], definedFP);
-                changed |= setCore(cUnit, ssaRep->defs[0], definedCore);
-                for (int i = 0; i < ssaRep->numUses; i++) {
-                    changed |= setFp(cUnit, ssaRep->uses[i], definedFP);
-                    changed |= setCore(cUnit, ssaRep->uses[i], definedCore);
-                }
-            }
+      // Handle defs
+      if (attrs & (DF_DA | DF_DA_WIDE)) {
+        if (attrs & DF_CORE_A) {
+          changed |= setCore(cUnit, ssaRep->defs[0], true);
         }
+        if (attrs & DF_DA_WIDE) {
+          cUnit->regLocation[ssaRep->defs[0]].wide = true;
+          cUnit->regLocation[ssaRep->defs[1]].highWord = true;
+          DCHECK_EQ(SRegToVReg(cUnit, ssaRep->defs[0])+1,
+          SRegToVReg(cUnit, ssaRep->defs[1]));
+        }
+      }
+
+      // Handles uses
+      int next = 0;
+      if (attrs & (DF_UA | DF_UA_WIDE)) {
+        if (attrs & DF_CORE_A) {
+          changed |= setCore(cUnit, ssaRep->uses[next], true);
+        }
+        if (attrs & DF_UA_WIDE) {
+          cUnit->regLocation[ssaRep->uses[next]].wide = true;
+          cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
+          DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
+          SRegToVReg(cUnit, ssaRep->uses[next + 1]));
+          next += 2;
+        } else {
+          next++;
+        }
+      }
+      if (attrs & (DF_UB | DF_UB_WIDE)) {
+        if (attrs & DF_CORE_B) {
+          changed |= setCore(cUnit, ssaRep->uses[next], true);
+        }
+        if (attrs & DF_UB_WIDE) {
+          cUnit->regLocation[ssaRep->uses[next]].wide = true;
+          cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
+          DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
+                               SRegToVReg(cUnit, ssaRep->uses[next + 1]));
+          next += 2;
+        } else {
+          next++;
+        }
+      }
+      if (attrs & (DF_UC | DF_UC_WIDE)) {
+        if (attrs & DF_CORE_C) {
+          changed |= setCore(cUnit, ssaRep->uses[next], true);
+        }
+        if (attrs & DF_UC_WIDE) {
+          cUnit->regLocation[ssaRep->uses[next]].wide = true;
+          cUnit->regLocation[ssaRep->uses[next + 1]].highWord = true;
+          DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[next])+1,
+          SRegToVReg(cUnit, ssaRep->uses[next + 1]));
+        }
+      }
+
+      // Special-case handling for format 35c/3rc invokes
+      Instruction::Code opcode = mir->dalvikInsn.opcode;
+      int flags = (static_cast<int>(opcode) >= kNumPackedOpcodes)
+          ? 0 : Instruction::Flags(mir->dalvikInsn.opcode);
+      if ((flags & Instruction::kInvoke) &&
+          (attrs & (DF_FORMAT_35C | DF_FORMAT_3RC))) {
+        DCHECK_EQ(next, 0);
+        int target_idx = mir->dalvikInsn.vB;
+        const char* shorty = oatGetShortyFromTargetIdx(cUnit, target_idx);
+        // Handle result type if floating point
+        if ((shorty[0] == 'F') || (shorty[0] == 'D')) {
+          // Find move-result that consumes this result
+          SSARepresentation* tgtRep = findMoveResult(mir->next);
+          // Might be in next basic block
+          if (!tgtRep) {
+            tgtRep = findMoveResult(bb->fallThrough->firstMIRInsn);
+          }
+          // Result might not be used at all, so no move-result
+          if (tgtRep) {
+            tgtRep->fpDef[0] = true;
+            changed |= setFp(cUnit, tgtRep->defs[0], true);
+            if (shorty[0] == 'D') {
+              tgtRep->fpDef[1] = true;
+              changed |= setFp(cUnit, tgtRep->defs[1], true);
+            }
+          }
+        }
+        int numUses = mir->dalvikInsn.vA;
+        // If this is a non-static invoke, skip implicit "this"
+        if (((mir->dalvikInsn.opcode != Instruction::INVOKE_STATIC) &&
+            (mir->dalvikInsn.opcode != Instruction::INVOKE_STATIC_RANGE))) {
+          cUnit->regLocation[ssaRep->uses[next]].defined = true;
+          cUnit->regLocation[ssaRep->uses[next]].core = true;
+          next++;
+        }
+        uint32_t cpos = 1;
+        if (strlen(shorty) > 1) {
+          for (int i = next; i < numUses;) {
+            DCHECK_LT(cpos, strlen(shorty));
+            switch (shorty[cpos++]) {
+              case 'D':
+                ssaRep->fpUse[i] = true;
+                ssaRep->fpUse[i+1] = true;
+                cUnit->regLocation[ssaRep->uses[i]].wide = true;
+                cUnit->regLocation[ssaRep->uses[i+1]].highWord = true;
+                DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[i])+1,
+                                     SRegToVReg(cUnit, ssaRep->uses[i+1]));
+                i++;
+                break;
+              case 'J':
+                cUnit->regLocation[ssaRep->uses[i]].wide = true;
+                cUnit->regLocation[ssaRep->uses[i+1]].highWord = true;
+                DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[i])+1,
+                                     SRegToVReg(cUnit, ssaRep->uses[i+1]));
+                changed |= setCore(cUnit, ssaRep->uses[i],true);
+                i++;
+                break;
+              case 'F':
+                ssaRep->fpUse[i] = true;
+                break;
+              default:
+                changed |= setCore(cUnit,ssaRep->uses[i], true);
+                break;
+            }
+            i++;
+          }
+        }
+      }
+
+      for (int i=0; ssaRep->fpUse && i< ssaRep->numUses; i++) {
+        if (ssaRep->fpUse[i])
+          changed |= setFp(cUnit, ssaRep->uses[i], true);
+        }
+      for (int i=0; ssaRep->fpDef && i< ssaRep->numDefs; i++) {
+        if (ssaRep->fpDef[i])
+          changed |= setFp(cUnit, ssaRep->defs[i], true);
+        }
+      // Special-case handling for moves & Phi
+      if (attrs & (DF_IS_MOVE | DF_NULL_TRANSFER_N)) {
+        // If any of our inputs or outputs is defined, set all
+        bool definedFP = false;
+        bool definedCore = false;
+        definedFP |= (cUnit->regLocation[ssaRep->defs[0]].defined &&
+                      cUnit->regLocation[ssaRep->defs[0]].fp);
+        definedCore |= (cUnit->regLocation[ssaRep->defs[0]].defined &&
+                        cUnit->regLocation[ssaRep->defs[0]].core);
+        for (int i = 0; i < ssaRep->numUses; i++) {
+          definedFP |= (cUnit->regLocation[ssaRep->uses[i]].defined &&
+                        cUnit->regLocation[ssaRep->uses[i]].fp);
+          definedCore |= (cUnit->regLocation[ssaRep->uses[i]].defined
+                          && cUnit->regLocation[ssaRep->uses[i]].core);
+        }
+        /*
+         * TODO: cleaner fix
+         * We don't normally expect to see a Dalvik register
+         * definition used both as a floating point and core
+         * value.  However, the instruction rewriting that occurs
+         * during verification can eliminate some type information,
+         * leaving us confused.  The real fix here is either to
+         * add explicit type information to Dalvik byte codes,
+         * or to recognize THROW_VERIFICATION_ERROR as
+         * an unconditional branch and support dead code elimination.
+         * As a workaround we can detect this situation and
+         * disable register promotion (which is the only thing that
+         * relies on distinctions between core and fp usages.
+         */
+        if ((definedFP && definedCore) &&
+            ((cUnit->disableOpt & (1 << kPromoteRegs)) == 0)) {
+          LOG(WARNING) << PrettyMethod(cUnit->method_idx, *cUnit->dex_file)
+                       << " op at block " << bb->id
+                       << " has both fp and core uses for same def.";
+          cUnit->disableOpt |= (1 << kPromoteRegs);
+        }
+        changed |= setFp(cUnit, ssaRep->defs[0], definedFP);
+        changed |= setCore(cUnit, ssaRep->defs[0], definedCore);
+        for (int i = 0; i < ssaRep->numUses; i++) {
+         changed |= setFp(cUnit, ssaRep->uses[i], definedFP);
+         changed |= setCore(cUnit, ssaRep->uses[i], definedCore);
+        }
+      }
     }
-    return changed;
+  }
+  return changed;
 }
 
 static const char* storageName[] = {" Frame ", "PhysReg", " Spill "};
 
 void oatDumpRegLocTable(RegLocation* table, int count)
 {
-    for (int i = 0; i < count; i++) {
-        LOG(INFO) << StringPrintf("Loc[%02d] : %s, %c %c %c %c %c %c%d %c%d S%d",
-             i, storageName[table[i].location], table[i].wide ? 'W' : 'N',
-             table[i].defined ? 'D' : 'U', table[i].fp ? 'F' : 'C',
-             table[i].highWord ? 'H' : 'L', table[i].home ? 'h' : 't',
-             oatIsFpReg(table[i].lowReg) ? 's' : 'r',
-             table[i].lowReg & oatFpRegMask(),
-             oatIsFpReg(table[i].highReg) ? 's' : 'r',
-             table[i].highReg & oatFpRegMask(), table[i].sRegLow);
-    }
+  for (int i = 0; i < count; i++) {
+    LOG(INFO) << StringPrintf("Loc[%02d] : %s, %c %c %c %c %c %c%d %c%d S%d",
+        i, storageName[table[i].location], table[i].wide ? 'W' : 'N',
+        table[i].defined ? 'D' : 'U', table[i].fp ? 'F' : 'C',
+        table[i].highWord ? 'H' : 'L', table[i].home ? 'h' : 't',
+        oatIsFpReg(table[i].lowReg) ? 's' : 'r',
+        table[i].lowReg & oatFpRegMask(),
+        oatIsFpReg(table[i].highReg) ? 's' : 'r',
+        table[i].highReg & oatFpRegMask(), table[i].sRegLow);
+  }
 }
 
 static const RegLocation freshLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0,
@@ -308,121 +307,119 @@
  */
 void oatSimpleRegAlloc(CompilationUnit* cUnit)
 {
-    int i;
-    RegLocation* loc;
+  int i;
+  RegLocation* loc;
 
-    /* Allocate the location map */
-    loc = (RegLocation*)oatNew(cUnit, cUnit->numSSARegs * sizeof(*loc), true,
-                               kAllocRegAlloc);
-    for (i=0; i< cUnit->numSSARegs; i++) {
-        loc[i] = freshLoc;
-        loc[i].sRegLow = i;
+  /* Allocate the location map */
+  loc = (RegLocation*)oatNew(cUnit, cUnit->numSSARegs * sizeof(*loc), true,
+                             kAllocRegAlloc);
+  for (i=0; i< cUnit->numSSARegs; i++) {
+    loc[i] = freshLoc;
+    loc[i].sRegLow = i;
+  }
+
+  /* Patch up the locations for Method* and the compiler temps */
+  loc[cUnit->methodSReg].location = kLocCompilerTemp;
+  loc[cUnit->methodSReg].defined = true;
+  for (i = 0; i < cUnit->numCompilerTemps; i++) {
+    CompilerTemp* ct = (CompilerTemp*)cUnit->compilerTemps.elemList[i];
+    loc[ct->sReg].location = kLocCompilerTemp;
+    loc[ct->sReg].defined = true;
+  }
+
+  cUnit->regLocation = loc;
+
+  /* Allocation the promotion map */
+  int numRegs = cUnit->numDalvikRegisters;
+  cUnit->promotionMap =
+      (PromotionMap*)oatNew(cUnit, (numRegs + cUnit->numCompilerTemps + 1) *
+                            sizeof(cUnit->promotionMap[0]), true,
+                            kAllocRegAlloc);
+
+  /* Add types of incoming arguments based on signature */
+  int numIns = cUnit->numIns;
+  if (numIns > 0) {
+    int sReg = numRegs - numIns;
+    if ((cUnit->access_flags & kAccStatic) == 0) {
+      // For non-static, skip past "this"
+      cUnit->regLocation[sReg].defined = true;
+      cUnit->regLocation[sReg].core = true;
+      sReg++;
     }
-
-    /* Patch up the locations for Method* and the compiler temps */
-    loc[cUnit->methodSReg].location = kLocCompilerTemp;
-    loc[cUnit->methodSReg].defined = true;
-    for (i = 0; i < cUnit->numCompilerTemps; i++) {
-        CompilerTemp* ct = (CompilerTemp*)cUnit->compilerTemps.elemList[i];
-        loc[ct->sReg].location = kLocCompilerTemp;
-        loc[ct->sReg].defined = true;
-    }
-
-    cUnit->regLocation = loc;
-
-    /* Allocation the promotion map */
-    int numRegs = cUnit->numDalvikRegisters;
-    cUnit->promotionMap =
-        (PromotionMap*)oatNew(cUnit, (numRegs + cUnit->numCompilerTemps + 1) *
-                              sizeof(cUnit->promotionMap[0]), true,
-                              kAllocRegAlloc);
-
-    /* Add types of incoming arguments based on signature */
-    int numIns = cUnit->numIns;
-    if (numIns > 0) {
-        int sReg = numRegs - numIns;
-        if ((cUnit->access_flags & kAccStatic) == 0) {
-            // For non-static, skip past "this"
+    const char* shorty = cUnit->shorty;
+    int shorty_len = strlen(shorty);
+    for (int i = 1; i < shorty_len; i++) {
+      switch (shorty[i]) {
+        case 'D':
+          cUnit->regLocation[sReg].wide = true;
+          cUnit->regLocation[sReg+1].highWord = true;
+          cUnit->regLocation[sReg+1].fp = true;
+          DCHECK_EQ(SRegToVReg(cUnit, sReg)+1, SRegToVReg(cUnit, sReg+1));
+          cUnit->regLocation[sReg].fp = true;
+          cUnit->regLocation[sReg].defined = true;
+          sReg++;
+          break;
+        case 'J':
+          cUnit->regLocation[sReg].wide = true;
+          cUnit->regLocation[sReg+1].highWord = true;
+          DCHECK_EQ(SRegToVReg(cUnit, sReg)+1, SRegToVReg(cUnit, sReg+1));
+          cUnit->regLocation[sReg].core = true;
+          cUnit->regLocation[sReg].defined = true;
+          sReg++;
+            break;
+          case 'F':
+            cUnit->regLocation[sReg].fp = true;
             cUnit->regLocation[sReg].defined = true;
+            break;
+          default:
             cUnit->regLocation[sReg].core = true;
-            sReg++;
+            cUnit->regLocation[sReg].defined = true;
+            break;
         }
-        const char* shorty = cUnit->shorty;
-        int shorty_len = strlen(shorty);
-        for (int i = 1; i < shorty_len; i++) {
-            switch (shorty[i]) {
-                case 'D':
-                    cUnit->regLocation[sReg].wide = true;
-                    cUnit->regLocation[sReg+1].highWord = true;
-                    cUnit->regLocation[sReg+1].fp = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, sReg)+1,
-                              SRegToVReg(cUnit, sReg+1));
-                    cUnit->regLocation[sReg].fp = true;
-                    cUnit->regLocation[sReg].defined = true;
-                    sReg++;
-                    break;
-                case 'J':
-                    cUnit->regLocation[sReg].wide = true;
-                    cUnit->regLocation[sReg+1].highWord = true;
-                    DCHECK_EQ(SRegToVReg(cUnit, sReg)+1,
-                              SRegToVReg(cUnit, sReg+1));
-                    cUnit->regLocation[sReg].core = true;
-                    cUnit->regLocation[sReg].defined = true;
-                    sReg++;
-                    break;
-                case 'F':
-                    cUnit->regLocation[sReg].fp = true;
-                    cUnit->regLocation[sReg].defined = true;
-                    break;
-                default:
-                    cUnit->regLocation[sReg].core = true;
-                    cUnit->regLocation[sReg].defined = true;
-                    break;
-            }
-            sReg++;
-        }
+        sReg++;
+      }
+  }
+
+  /* Remap names */
+  oatDataFlowAnalysisDispatcher(cUnit, remapNames,
+                                kPreOrderDFSTraversal,
+                                false /* isIterative */);
+
+  /* Do type & size inference pass */
+  oatDataFlowAnalysisDispatcher(cUnit, inferTypeAndSize,
+                                kPreOrderDFSTraversal,
+                                true /* isIterative */);
+
+  /*
+   * Set the sRegLow field to refer to the pre-SSA name of the
+   * base Dalvik virtual register.  Once we add a better register
+   * allocator, remove this remapping.
+   */
+  for (i=0; i < cUnit->numSSARegs; i++) {
+    if (cUnit->regLocation[i].location != kLocCompilerTemp) {
+      cUnit->regLocation[i].sRegLow = SRegToVReg(cUnit, loc[i].sRegLow);
     }
+  }
 
-    /* Remap names */
-    oatDataFlowAnalysisDispatcher(cUnit, remapNames,
-                                  kPreOrderDFSTraversal,
-                                  false /* isIterative */);
+  cUnit->coreSpillMask = 0;
+  cUnit->fpSpillMask = 0;
+  cUnit->numCoreSpills = 0;
 
-    /* Do type & size inference pass */
-    oatDataFlowAnalysisDispatcher(cUnit, inferTypeAndSize,
-                                  kPreOrderDFSTraversal,
-                                  true /* isIterative */);
+  oatDoPromotion(cUnit);
 
-    /*
-     * Set the sRegLow field to refer to the pre-SSA name of the
-     * base Dalvik virtual register.  Once we add a better register
-     * allocator, remove this remapping.
-     */
-    for (i=0; i < cUnit->numSSARegs; i++) {
-        if (cUnit->regLocation[i].location != kLocCompilerTemp) {
-            cUnit->regLocation[i].sRegLow = SRegToVReg(cUnit, loc[i].sRegLow);
-        }
-    }
+  if (cUnit->printMe && !(cUnit->disableOpt & (1 << kPromoteRegs))) {
+    LOG(INFO) << "After Promotion";
+    oatDumpRegLocTable(cUnit->regLocation, cUnit->numSSARegs);
+  }
 
-    cUnit->coreSpillMask = 0;
-    cUnit->fpSpillMask = 0;
-    cUnit->numCoreSpills = 0;
-
-    oatDoPromotion(cUnit);
-
-    if (cUnit->printMe && !(cUnit->disableOpt & (1 << kPromoteRegs))) {
-        LOG(INFO) << "After Promotion";
-        oatDumpRegLocTable(cUnit->regLocation, cUnit->numSSARegs);
-    }
-
-    /* Figure out the frame size */
-    static const uint32_t kAlignMask = kStackAlignment - 1;
-    uint32_t size = (cUnit->numCoreSpills + cUnit->numFPSpills +
-                     1 /* filler word */ + cUnit->numRegs + cUnit->numOuts +
-                     cUnit->numCompilerTemps + 1 /* curMethod* */)
-                     * sizeof(uint32_t);
-    /* Align and set */
-    cUnit->frameSize = (size + kAlignMask) & ~(kAlignMask);
+  /* Figure out the frame size */
+  static const uint32_t kAlignMask = kStackAlignment - 1;
+  uint32_t size = (cUnit->numCoreSpills + cUnit->numFPSpills +
+                   1 /* filler word */ + cUnit->numRegs + cUnit->numOuts +
+                   cUnit->numCompilerTemps + 1 /* curMethod* */)
+                   * sizeof(uint32_t);
+  /* Align and set */
+  cUnit->frameSize = (size + kAlignMask) & ~(kAlignMask);
 }
 
 }  // namespace art
diff --git a/src/compiler/SSATransformation.cc b/src/compiler/SSATransformation.cc
index c5a6b8f..ada9351 100644
--- a/src/compiler/SSATransformation.cc
+++ b/src/compiler/SSATransformation.cc
@@ -23,74 +23,73 @@
 void recordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
 {
 
-    if (block->visited || block->hidden) return;
-    block->visited = true;
+  if (block->visited || block->hidden) return;
+  block->visited = true;
 
-    // Can this block be reached only via previous block fallthrough?
-    if ((block->blockType == kDalvikByteCode) &&
-        (block->predecessors->numUsed == 1)) {
-        DCHECK_GE(cUnit->dfsOrder.numUsed, 1U);
-        int prevIdx = cUnit->dfsOrder.numUsed - 1;
-        int prevId = cUnit->dfsOrder.elemList[prevIdx];
-        BasicBlock* predBB = (BasicBlock*)block->predecessors->elemList[0];
-        if (predBB->id == prevId) {
-            block->fallThroughTarget = true;
-        }
+  // Can this block be reached only via previous block fallthrough?
+  if ((block->blockType == kDalvikByteCode) &&
+      (block->predecessors->numUsed == 1)) {
+    DCHECK_GE(cUnit->dfsOrder.numUsed, 1U);
+    int prevIdx = cUnit->dfsOrder.numUsed - 1;
+    int prevId = cUnit->dfsOrder.elemList[prevIdx];
+    BasicBlock* predBB = (BasicBlock*)block->predecessors->elemList[0];
+    if (predBB->id == prevId) {
+      block->fallThroughTarget = true;
     }
+  }
 
-    /* Enqueue the preOrder block id */
-    oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
+  /* Enqueue the preOrder block id */
+  oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
 
-    if (block->fallThrough) {
-        recordDFSOrders(cUnit, block->fallThrough);
+  if (block->fallThrough) {
+    recordDFSOrders(cUnit, block->fallThrough);
+  }
+  if (block->taken) recordDFSOrders(cUnit, block->taken);
+  if (block->successorBlockList.blockListType != kNotUsed) {
+    GrowableListIterator iterator;
+    oatGrowableListIteratorInit(&block->successorBlockList.blocks,
+                                &iterator);
+    while (true) {
+      SuccessorBlockInfo *successorBlockInfo =
+          (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+      if (successorBlockInfo == NULL) break;
+      BasicBlock* succBB = successorBlockInfo->block;
+      recordDFSOrders(cUnit, succBB);
     }
-    if (block->taken) recordDFSOrders(cUnit, block->taken);
-    if (block->successorBlockList.blockListType != kNotUsed) {
-        GrowableListIterator iterator;
-        oatGrowableListIteratorInit(&block->successorBlockList.blocks,
-                                    &iterator);
-        while (true) {
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-            if (successorBlockInfo == NULL) break;
-            BasicBlock* succBB = successorBlockInfo->block;
-            recordDFSOrders(cUnit, succBB);
-        }
-    }
+  }
 
-    /* Record postorder in basic block and enqueue normal id in dfsPostOrder */
-    block->dfsId = cUnit->dfsPostOrder.numUsed;
-    oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
-    return;
+  /* Record postorder in basic block and enqueue normal id in dfsPostOrder */
+  block->dfsId = cUnit->dfsPostOrder.numUsed;
+  oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
+  return;
 }
 
 /* Sort the blocks by the Depth-First-Search */
 void computeDFSOrders(CompilationUnit* cUnit)
 {
-    /* Initialize or reset the DFS preOrder list */
-    if (cUnit->dfsOrder.elemList == NULL) {
-        oatInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
-                            kListDfsOrder);
-    } else {
-        /* Just reset the used length on the counter */
-        cUnit->dfsOrder.numUsed = 0;
-    }
+  /* Initialize or reset the DFS preOrder list */
+  if (cUnit->dfsOrder.elemList == NULL) {
+    oatInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
+                        kListDfsOrder);
+  } else {
+    /* Just reset the used length on the counter */
+    cUnit->dfsOrder.numUsed = 0;
+  }
 
-    /* Initialize or reset the DFS postOrder list */
-    if (cUnit->dfsPostOrder.elemList == NULL) {
-        oatInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
-                            kListDfsPostOrder);
-    } else {
-        /* Just reset the used length on the counter */
-        cUnit->dfsPostOrder.numUsed = 0;
-    }
+  /* Initialize or reset the DFS postOrder list */
+  if (cUnit->dfsPostOrder.elemList == NULL) {
+    oatInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
+                        kListDfsPostOrder);
+  } else {
+    /* Just reset the used length on the counter */
+    cUnit->dfsPostOrder.numUsed = 0;
+  }
 
-    oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
-                                          kAllNodes,
-                                          false /* isIterative */);
+  oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+                                kAllNodes, false /* isIterative */);
 
-    recordDFSOrders(cUnit, cUnit->entryBlock);
-    cUnit->numReachableBlocks = cUnit->dfsOrder.numUsed;
+  recordDFSOrders(cUnit, cUnit->entryBlock);
+  cUnit->numReachableBlocks = cUnit->dfsOrder.numUsed;
 }
 
 /*
@@ -99,165 +98,163 @@
  */
 bool fillDefBlockMatrix(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    if (bb->dataFlowInfo == NULL) return false;
+  if (bb->dataFlowInfo == NULL) return false;
 
-    ArenaBitVectorIterator iterator;
+  ArenaBitVectorIterator iterator;
 
-    oatBitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
-    while (true) {
-        int idx = oatBitVectorIteratorNext(&iterator);
-        if (idx == -1) break;
-        /* Block bb defines register idx */
-        oatSetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
-    }
-    return true;
+  oatBitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
+  while (true) {
+    int idx = oatBitVectorIteratorNext(&iterator);
+    if (idx == -1) break;
+    /* Block bb defines register idx */
+    oatSetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
+  }
+  return true;
 }
 
 void computeDefBlockMatrix(CompilationUnit* cUnit)
 {
-    int numRegisters = cUnit->numDalvikRegisters;
-    /* Allocate numDalvikRegisters bit vector pointers */
-    cUnit->defBlockMatrix = (ArenaBitVector **)
-        oatNew(cUnit, sizeof(ArenaBitVector *) * numRegisters, true,
-               kAllocDFInfo);
-    int i;
+  int numRegisters = cUnit->numDalvikRegisters;
+  /* Allocate numDalvikRegisters bit vector pointers */
+  cUnit->defBlockMatrix = (ArenaBitVector **)
+      oatNew(cUnit, sizeof(ArenaBitVector *) * numRegisters, true,
+             kAllocDFInfo);
+  int i;
 
-    /* Initialize numRegister vectors with numBlocks bits each */
-    for (i = 0; i < numRegisters; i++) {
-        cUnit->defBlockMatrix[i] = oatAllocBitVector(cUnit, cUnit->numBlocks,
-                                                     false, kBitMapBMatrix);
-    }
-    oatDataFlowAnalysisDispatcher(cUnit, oatFindLocalLiveIn,
-                                          kAllNodes,
-                                          false /* isIterative */);
-    oatDataFlowAnalysisDispatcher(cUnit, fillDefBlockMatrix,
-                                          kAllNodes,
-                                          false /* isIterative */);
+  /* Initialize numRegister vectors with numBlocks bits each */
+  for (i = 0; i < numRegisters; i++) {
+    cUnit->defBlockMatrix[i] = oatAllocBitVector(cUnit, cUnit->numBlocks,
+                                                 false, kBitMapBMatrix);
+  }
+  oatDataFlowAnalysisDispatcher(cUnit, oatFindLocalLiveIn,
+                                kAllNodes, false /* isIterative */);
+  oatDataFlowAnalysisDispatcher(cUnit, fillDefBlockMatrix,
+                                kAllNodes, false /* isIterative */);
 
-    /*
-     * Also set the incoming parameters as defs in the entry block.
-     * Only need to handle the parameters for the outer method.
-     */
-    int numRegs = cUnit->numDalvikRegisters;
-    int inReg = numRegs - cUnit->numIns;
-    for (; inReg < numRegs; inReg++) {
-        oatSetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
-    }
+  /*
+   * Also set the incoming parameters as defs in the entry block.
+   * Only need to handle the parameters for the outer method.
+   */
+  int numRegs = cUnit->numDalvikRegisters;
+  int inReg = numRegs - cUnit->numIns;
+  for (; inReg < numRegs; inReg++) {
+    oatSetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
+  }
 }
 
 /* Compute the post-order traversal of the CFG */
 void computeDomPostOrderTraversal(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    ArenaBitVectorIterator bvIterator;
-    oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
-    GrowableList* blockList = &cUnit->blockList;
+  ArenaBitVectorIterator bvIterator;
+  oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+  GrowableList* blockList = &cUnit->blockList;
 
-    /* Iterate through the dominated blocks first */
-    while (true) {
-        //TUNING: hot call to oatBitVectorIteratorNext
-        int bbIdx = oatBitVectorIteratorNext(&bvIterator);
-        if (bbIdx == -1) break;
-        BasicBlock* dominatedBB =
-            (BasicBlock* ) oatGrowableListGetElement(blockList, bbIdx);
-        computeDomPostOrderTraversal(cUnit, dominatedBB);
-    }
+  /* Iterate through the dominated blocks first */
+  while (true) {
+    //TUNING: hot call to oatBitVectorIteratorNext
+    int bbIdx = oatBitVectorIteratorNext(&bvIterator);
+    if (bbIdx == -1) break;
+    BasicBlock* dominatedBB =
+        (BasicBlock* ) oatGrowableListGetElement(blockList, bbIdx);
+    computeDomPostOrderTraversal(cUnit, dominatedBB);
+  }
 
-    /* Enter the current block id */
-    oatInsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
+  /* Enter the current block id */
+  oatInsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
 
-    /* hacky loop detection */
-    if (bb->taken && oatIsBitSet(bb->dominators, bb->taken->id)) {
-        cUnit->hasLoop = true;
-    }
+  /* hacky loop detection */
+  if (bb->taken && oatIsBitSet(bb->dominators, bb->taken->id)) {
+    cUnit->hasLoop = true;
+  }
 }
 
 void checkForDominanceFrontier(CompilationUnit* cUnit, BasicBlock* domBB,
-                               const BasicBlock* succBB)
+                             const BasicBlock* succBB)
 {
-    /*
-     * TODO - evaluate whether phi will ever need to be inserted into exit
-     * blocks.
-     */
-    if (succBB->iDom != domBB &&
-        succBB->blockType == kDalvikByteCode &&
-        succBB->hidden == false) {
-        oatSetBit(cUnit, domBB->domFrontier, succBB->id);
-    }
+  /*
+   * TODO - evaluate whether phi will ever need to be inserted into exit
+   * blocks.
+   */
+  if (succBB->iDom != domBB &&
+    succBB->blockType == kDalvikByteCode &&
+    succBB->hidden == false) {
+    oatSetBit(cUnit, domBB->domFrontier, succBB->id);
+  }
 }
 
 /* Worker function to compute the dominance frontier */
 bool computeDominanceFrontier(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableList* blockList = &cUnit->blockList;
+  GrowableList* blockList = &cUnit->blockList;
 
-    /* Calculate DF_local */
-    if (bb->taken) {
-        checkForDominanceFrontier(cUnit, bb, bb->taken);
-    }
-    if (bb->fallThrough) {
-        checkForDominanceFrontier(cUnit, bb, bb->fallThrough);
-    }
-    if (bb->successorBlockList.blockListType != kNotUsed) {
-        GrowableListIterator iterator;
-        oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
-                                    &iterator);
-        while (true) {
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-            if (successorBlockInfo == NULL) break;
-            BasicBlock* succBB = successorBlockInfo->block;
-            checkForDominanceFrontier(cUnit, bb, succBB);
-        }
-    }
+  /* Calculate DF_local */
+  if (bb->taken) {
+    checkForDominanceFrontier(cUnit, bb, bb->taken);
+  }
+  if (bb->fallThrough) {
+    checkForDominanceFrontier(cUnit, bb, bb->fallThrough);
+  }
+  if (bb->successorBlockList.blockListType != kNotUsed) {
+    GrowableListIterator iterator;
+    oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+                                  &iterator);
+      while (true) {
+        SuccessorBlockInfo *successorBlockInfo =
+            (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+        if (successorBlockInfo == NULL) break;
+        BasicBlock* succBB = successorBlockInfo->block;
+        checkForDominanceFrontier(cUnit, bb, succBB);
+      }
+  }
 
-    /* Calculate DF_up */
-    ArenaBitVectorIterator bvIterator;
-    oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+  /* Calculate DF_up */
+  ArenaBitVectorIterator bvIterator;
+  oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+  while (true) {
+    //TUNING: hot call to oatBitVectorIteratorNext
+    int dominatedIdx = oatBitVectorIteratorNext(&bvIterator);
+    if (dominatedIdx == -1) break;
+    BasicBlock* dominatedBB = (BasicBlock* )
+        oatGrowableListGetElement(blockList, dominatedIdx);
+    ArenaBitVectorIterator dfIterator;
+    oatBitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
     while (true) {
-        //TUNING: hot call to oatBitVectorIteratorNext
-        int dominatedIdx = oatBitVectorIteratorNext(&bvIterator);
-        if (dominatedIdx == -1) break;
-        BasicBlock* dominatedBB = (BasicBlock* )
-            oatGrowableListGetElement(blockList, dominatedIdx);
-        ArenaBitVectorIterator dfIterator;
-        oatBitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
-        while (true) {
-            //TUNING: hot call to oatBitVectorIteratorNext
-            int dfUpIdx = oatBitVectorIteratorNext(&dfIterator);
-            if (dfUpIdx == -1) break;
-            BasicBlock* dfUpBlock = (BasicBlock* )
-                oatGrowableListGetElement(blockList, dfUpIdx);
-            checkForDominanceFrontier(cUnit, bb, dfUpBlock);
-        }
+      //TUNING: hot call to oatBitVectorIteratorNext
+      int dfUpIdx = oatBitVectorIteratorNext(&dfIterator);
+      if (dfUpIdx == -1) break;
+      BasicBlock* dfUpBlock = (BasicBlock* )
+          oatGrowableListGetElement(blockList, dfUpIdx);
+      checkForDominanceFrontier(cUnit, bb, dfUpBlock);
     }
+  }
 
-    return true;
+  return true;
 }
 
 /* Worker function for initializing domination-related data structures */
 bool initializeDominationInfo(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    int numTotalBlocks = cUnit->blockList.numUsed;
+  int numTotalBlocks = cUnit->blockList.numUsed;
 
-    if (bb->dominators == NULL ) {
-        bb->dominators = oatAllocBitVector(cUnit, numTotalBlocks,
-                                           false /* expandable */,
-                                           kBitMapDominators);
-        bb->iDominated = oatAllocBitVector(cUnit, numTotalBlocks,
-                                           false /* expandable */,
-                                           kBitMapIDominated);
-        bb->domFrontier = oatAllocBitVector(cUnit, numTotalBlocks,
-                                            false /* expandable */,
-                                            kBitMapDomFrontier);
-    } else {
-        oatClearAllBits(bb->dominators);
-        oatClearAllBits(bb->iDominated);
-        oatClearAllBits(bb->domFrontier);
-    }
-    /* Set all bits in the dominator vector */
-    oatSetInitialBits(bb->dominators, numTotalBlocks);
+  if (bb->dominators == NULL ) {
+    bb->dominators = oatAllocBitVector(cUnit, numTotalBlocks,
+                                       false /* expandable */,
+                                       kBitMapDominators);
+    bb->iDominated = oatAllocBitVector(cUnit, numTotalBlocks,
+                                       false /* expandable */,
+                                       kBitMapIDominated);
+    bb->domFrontier = oatAllocBitVector(cUnit, numTotalBlocks,
+                                        false /* expandable */,
+                                        kBitMapDomFrontier);
+  } else {
+    oatClearAllBits(bb->dominators);
+    oatClearAllBits(bb->iDominated);
+    oatClearAllBits(bb->domFrontier);
+  }
+  /* Set all bits in the dominator vector */
+  oatSetInitialBits(bb->dominators, numTotalBlocks);
 
-    return true;
+  return true;
 }
 
 /*
@@ -267,35 +264,35 @@
  */
 bool slowComputeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableList* blockList = &cUnit->blockList;
-    int numTotalBlocks = blockList->numUsed;
-    ArenaBitVector* tempBlockV = cUnit->tempBlockV;
-    GrowableListIterator iter;
+  GrowableList* blockList = &cUnit->blockList;
+  int numTotalBlocks = blockList->numUsed;
+  ArenaBitVector* tempBlockV = cUnit->tempBlockV;
+  GrowableListIterator iter;
 
-    /*
-     * The dominator of the entry block has been preset to itself and we need
-     * to skip the calculation here.
-     */
-    if (bb == cUnit->entryBlock) return false;
+  /*
+   * The dominator of the entry block has been preset to itself and we need
+   * to skip the calculation here.
+   */
+  if (bb == cUnit->entryBlock) return false;
 
-    oatSetInitialBits(tempBlockV, numTotalBlocks);
+  oatSetInitialBits(tempBlockV, numTotalBlocks);
 
-    /* Iterate through the predecessors */
-    oatGrowableListIteratorInit(bb->predecessors, &iter);
-    while (true) {
-        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-        if (!predBB) break;
-        /* tempBlockV = tempBlockV ^ dominators */
-        if (predBB->dominators != NULL) {
-            oatIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
-        }
+  /* Iterate through the predecessors */
+  oatGrowableListIteratorInit(bb->predecessors, &iter);
+  while (true) {
+    BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+    if (!predBB) break;
+    /* tempBlockV = tempBlockV ^ dominators */
+    if (predBB->dominators != NULL) {
+      oatIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
     }
-    oatSetBit(cUnit, tempBlockV, bb->id);
-    if (oatCompareBitVectors(tempBlockV, bb->dominators)) {
-        oatCopyBitVector(bb->dominators, tempBlockV);
-        return true;
-    }
-    return false;
+  }
+  oatSetBit(cUnit, tempBlockV, bb->id);
+  if (oatCompareBitVectors(tempBlockV, bb->dominators)) {
+    oatCopyBitVector(bb->dominators, tempBlockV);
+    return true;
+  }
+  return false;
 }
 
 /*
@@ -305,44 +302,45 @@
  */
 bool slowComputeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableList* blockList = &cUnit->blockList;
-    ArenaBitVector* tempBlockV = cUnit->tempBlockV;
-    ArenaBitVectorIterator bvIterator;
-    BasicBlock* iDom;
+  GrowableList* blockList = &cUnit->blockList;
+  ArenaBitVector* tempBlockV = cUnit->tempBlockV;
+  ArenaBitVectorIterator bvIterator;
+  BasicBlock* iDom;
 
-    if (bb == cUnit->entryBlock) return false;
+  if (bb == cUnit->entryBlock) return false;
 
-    oatCopyBitVector(tempBlockV, bb->dominators);
-    oatClearBit(tempBlockV, bb->id);
-    oatBitVectorIteratorInit(tempBlockV, &bvIterator);
+  oatCopyBitVector(tempBlockV, bb->dominators);
+  oatClearBit(tempBlockV, bb->id);
+  oatBitVectorIteratorInit(tempBlockV, &bvIterator);
 
-    /* Should not see any dead block */
-    DCHECK_NE(oatCountSetBits(tempBlockV),  0);
-    if (oatCountSetBits(tempBlockV) == 1) {
-        iDom = (BasicBlock* ) oatGrowableListGetElement(
-                       blockList, oatBitVectorIteratorNext(&bvIterator));
-        bb->iDom = iDom;
-    } else {
-        int iDomIdx = oatBitVectorIteratorNext(&bvIterator);
-        DCHECK_NE(iDomIdx, -1);
-        while (true) {
-            int nextDom = oatBitVectorIteratorNext(&bvIterator);
-            if (nextDom == -1) break;
-            BasicBlock* nextDomBB = (BasicBlock* )
-                oatGrowableListGetElement(blockList, nextDom);
-            /* iDom dominates nextDom - set new iDom */
-            if (oatIsBitSet(nextDomBB->dominators, iDomIdx)) {
-                iDomIdx = nextDom;
-            }
+  /* Should not see any dead block */
+  DCHECK_NE(oatCountSetBits(tempBlockV),  0);
+  if (oatCountSetBits(tempBlockV) == 1) {
+    iDom = (BasicBlock* )
+        oatGrowableListGetElement(blockList,
+                                  oatBitVectorIteratorNext(&bvIterator));
+    bb->iDom = iDom;
+  } else {
+    int iDomIdx = oatBitVectorIteratorNext(&bvIterator);
+    DCHECK_NE(iDomIdx, -1);
+    while (true) {
+      int nextDom = oatBitVectorIteratorNext(&bvIterator);
+      if (nextDom == -1) break;
+      BasicBlock* nextDomBB = (BasicBlock* )
+          oatGrowableListGetElement(blockList, nextDom);
+      /* iDom dominates nextDom - set new iDom */
+      if (oatIsBitSet(nextDomBB->dominators, iDomIdx)) {
+          iDomIdx = nextDom;
+      }
 
-        }
-        iDom = (BasicBlock* ) oatGrowableListGetElement(blockList, iDomIdx);
-        /* Set the immediate dominator block for bb */
-        bb->iDom = iDom;
     }
-    /* Add bb to the iDominated set of the immediate dominator block */
-    oatSetBit(cUnit, iDom->iDominated, bb->id);
-    return true;
+    iDom = (BasicBlock* ) oatGrowableListGetElement(blockList, iDomIdx);
+    /* Set the immediate dominator block for bb */
+    bb->iDom = iDom;
+  }
+  /* Add bb to the iDominated set of the immediate dominator block */
+  oatSetBit(cUnit, iDom->iDominated, bb->id);
+  return true;
 }
 
 /*
@@ -352,175 +350,174 @@
   */
 int findCommonParent(CompilationUnit *cUnit, int block1, int block2)
 {
-    while (block1 != block2) {
-        while (block1 < block2) {
-            block1 = cUnit->iDomList[block1];
-            DCHECK_NE(block1, NOTVISITED);
-        }
-        while (block2 < block1) {
-            block2 = cUnit->iDomList[block2];
-            DCHECK_NE(block2, NOTVISITED);
-        }
+  while (block1 != block2) {
+    while (block1 < block2) {
+      block1 = cUnit->iDomList[block1];
+      DCHECK_NE(block1, NOTVISITED);
     }
-    return block1;
+    while (block2 < block1) {
+      block2 = cUnit->iDomList[block2];
+      DCHECK_NE(block2, NOTVISITED);
+    }
+  }
+  return block1;
 }
 
 /* Worker function to compute each block's immediate dominator */
 bool computeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableListIterator iter;
-    int idom = -1;
+  GrowableListIterator iter;
+  int idom = -1;
 
-    /* Special-case entry block */
-    if (bb == cUnit->entryBlock) {
-        return false;
-    }
-
-    /* Iterate through the predecessors */
-    oatGrowableListIteratorInit(bb->predecessors, &iter);
-
-    /* Find the first processed predecessor */
-    while (true) {
-        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-        CHECK(predBB != NULL);
-        if (cUnit->iDomList[predBB->dfsId] != NOTVISITED) {
-            idom = predBB->dfsId;
-            break;
-        }
-    }
-
-    /* Scan the rest of the predecessors */
-    while (true) {
-        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
-        if (!predBB) break;
-        if (cUnit->iDomList[predBB->dfsId] == NOTVISITED) {
-            continue;
-        } else {
-            idom = findCommonParent(cUnit, predBB->dfsId, idom);
-        }
-    }
-
-    DCHECK_NE(idom, NOTVISITED);
-
-    /* Did something change? */
-    if (cUnit->iDomList[bb->dfsId] != idom) {
-        cUnit->iDomList[bb->dfsId] = idom;
-        return true;
-    }
+  /* Special-case entry block */
+  if (bb == cUnit->entryBlock) {
     return false;
+  }
+
+  /* Iterate through the predecessors */
+  oatGrowableListIteratorInit(bb->predecessors, &iter);
+
+  /* Find the first processed predecessor */
+  while (true) {
+    BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+    CHECK(predBB != NULL);
+    if (cUnit->iDomList[predBB->dfsId] != NOTVISITED) {
+      idom = predBB->dfsId;
+      break;
+    }
+  }
+
+  /* Scan the rest of the predecessors */
+  while (true) {
+      BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+      if (!predBB) break;
+      if (cUnit->iDomList[predBB->dfsId] == NOTVISITED) {
+        continue;
+      } else {
+        idom = findCommonParent(cUnit, predBB->dfsId, idom);
+      }
+  }
+
+  DCHECK_NE(idom, NOTVISITED);
+
+  /* Did something change? */
+  if (cUnit->iDomList[bb->dfsId] != idom) {
+    cUnit->iDomList[bb->dfsId] = idom;
+    return true;
+  }
+  return false;
 }
 
 /* Worker function to compute each block's domintors */
 bool computeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    if (bb == cUnit->entryBlock) {
-        oatClearAllBits(bb->dominators);
-    } else {
-        oatCopyBitVector(bb->dominators, bb->iDom->dominators);
-    }
-    oatSetBit(cUnit, bb->dominators, bb->id);
-    return false;
+  if (bb == cUnit->entryBlock) {
+    oatClearAllBits(bb->dominators);
+  } else {
+    oatCopyBitVector(bb->dominators, bb->iDom->dominators);
+  }
+  oatSetBit(cUnit, bb->dominators, bb->id);
+  return false;
 }
 
 bool setDominators(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    if (bb != cUnit->entryBlock) {
-        int iDomDFSIdx = cUnit->iDomList[bb->dfsId];
-        DCHECK_NE(iDomDFSIdx, NOTVISITED);
-        int iDomIdx = cUnit->dfsPostOrder.elemList[iDomDFSIdx];
-        BasicBlock* iDom = (BasicBlock*)
-              oatGrowableListGetElement(&cUnit->blockList, iDomIdx);
-        if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
-            DCHECK_EQ(bb->iDom->id, iDom->id);
-        }
-        bb->iDom = iDom;
-        /* Add bb to the iDominated set of the immediate dominator block */
-        oatSetBit(cUnit, iDom->iDominated, bb->id);
+  if (bb != cUnit->entryBlock) {
+    int iDomDFSIdx = cUnit->iDomList[bb->dfsId];
+    DCHECK_NE(iDomDFSIdx, NOTVISITED);
+    int iDomIdx = cUnit->dfsPostOrder.elemList[iDomDFSIdx];
+    BasicBlock* iDom = (BasicBlock*)
+          oatGrowableListGetElement(&cUnit->blockList, iDomIdx);
+    if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
+      DCHECK_EQ(bb->iDom->id, iDom->id);
     }
-    return false;
+    bb->iDom = iDom;
+    /* Add bb to the iDominated set of the immediate dominator block */
+    oatSetBit(cUnit, iDom->iDominated, bb->id);
+  }
+  return false;
 }
 
 /* Compute dominators, immediate dominator, and dominance fronter */
 void computeDominators(CompilationUnit* cUnit)
 {
-    int numReachableBlocks = cUnit->numReachableBlocks;
-    int numTotalBlocks = cUnit->blockList.numUsed;
+  int numReachableBlocks = cUnit->numReachableBlocks;
+  int numTotalBlocks = cUnit->blockList.numUsed;
 
-    /* Initialize domination-related data structures */
-    oatDataFlowAnalysisDispatcher(cUnit, initializeDominationInfo,
-                                          kReachableNodes,
-                                          false /* isIterative */);
+  /* Initialize domination-related data structures */
+  oatDataFlowAnalysisDispatcher(cUnit, initializeDominationInfo,
+                                kReachableNodes, false /* isIterative */);
 
-    /* Initalize & Clear iDomList */
-    if (cUnit->iDomList == NULL) {
-        cUnit->iDomList = (int*)oatNew(cUnit, sizeof(int) * numReachableBlocks,
-                                       false, kAllocDFInfo);
-    }
-    for (int i = 0; i < numReachableBlocks; i++) {
-        cUnit->iDomList[i] = NOTVISITED;
-    }
+  /* Initalize & Clear iDomList */
+  if (cUnit->iDomList == NULL) {
+    cUnit->iDomList = (int*)oatNew(cUnit, sizeof(int) * numReachableBlocks,
+                                   false, kAllocDFInfo);
+  }
+  for (int i = 0; i < numReachableBlocks; i++) {
+    cUnit->iDomList[i] = NOTVISITED;
+  }
 
-    /* For post-order, last block is entry block.  Set its iDom to istelf */
-    DCHECK_EQ(cUnit->entryBlock->dfsId, numReachableBlocks-1);
-    cUnit->iDomList[cUnit->entryBlock->dfsId] = cUnit->entryBlock->dfsId;
+  /* For post-order, last block is entry block.  Set its iDom to istelf */
+  DCHECK_EQ(cUnit->entryBlock->dfsId, numReachableBlocks-1);
+  cUnit->iDomList[cUnit->entryBlock->dfsId] = cUnit->entryBlock->dfsId;
 
-    /* Compute the immediate dominators */
-    oatDataFlowAnalysisDispatcher(cUnit, computeBlockIDom,
-                                  kReversePostOrderTraversal,
+  /* Compute the immediate dominators */
+  oatDataFlowAnalysisDispatcher(cUnit, computeBlockIDom,
+                                kReversePostOrderTraversal,
+                                true /* isIterative */);
+
+  /* Set the dominator for the root node */
+  oatClearAllBits(cUnit->entryBlock->dominators);
+  oatSetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
+
+  if (cUnit->tempBlockV == NULL) {
+    cUnit->tempBlockV = oatAllocBitVector(cUnit, numTotalBlocks,
+                                          false /* expandable */,
+                                          kBitMapTmpBlockV);
+  } else {
+    oatClearAllBits(cUnit->tempBlockV);
+  }
+  cUnit->entryBlock->iDom = NULL;
+
+  /* For testing, compute sets using alternate mechanism */
+  if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
+    // Use alternate mechanism to compute dominators for comparison
+    oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockDominators,
+                                  kPreOrderDFSTraversal,
                                   true /* isIterative */);
 
-    /* Set the dominator for the root node */
-    oatClearAllBits(cUnit->entryBlock->dominators);
-    oatSetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
+   oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockIDom,
+                                 kReachableNodes,
+                                 false /* isIterative */);
+  }
 
-    if (cUnit->tempBlockV == NULL) {
-        cUnit->tempBlockV = oatAllocBitVector(cUnit, numTotalBlocks,
-                                              false /* expandable */,
-                                              kBitMapTmpBlockV);
-    } else {
-        oatClearAllBits(cUnit->tempBlockV);
-    }
-    cUnit->entryBlock->iDom = NULL;
+  oatDataFlowAnalysisDispatcher(cUnit, setDominators,
+                                kReachableNodes,
+                                false /* isIterative */);
 
-    /* For testing, compute sets using alternate mechanism */
-    if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
-        // Use alternate mechanism to compute dominators for comparison
-        oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockDominators,
-                                      kPreOrderDFSTraversal,
-                                      true /* isIterative */);
+  oatDataFlowAnalysisDispatcher(cUnit, computeBlockDominators,
+                                kReversePostOrderTraversal,
+                                false /* isIterative */);
 
-       oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockIDom,
-                                     kReachableNodes,
-                                     false /* isIterative */);
-    }
+  /*
+   * Now go ahead and compute the post order traversal based on the
+   * iDominated sets.
+   */
+  if (cUnit->domPostOrderTraversal.elemList == NULL) {
+    oatInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
+                        numReachableBlocks, kListDomPostOrderTraversal);
+  } else {
+    cUnit->domPostOrderTraversal.numUsed = 0;
+  }
 
-    oatDataFlowAnalysisDispatcher(cUnit, setDominators,
-                                  kReachableNodes,
-                                  false /* isIterative */);
+  computeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
+  DCHECK_EQ(cUnit->domPostOrderTraversal.numUsed,
+         (unsigned) cUnit->numReachableBlocks);
 
-    oatDataFlowAnalysisDispatcher(cUnit, computeBlockDominators,
-                                  kReversePostOrderTraversal,
-                                  false /* isIterative */);
-
-    /*
-     * Now go ahead and compute the post order traversal based on the
-     * iDominated sets.
-     */
-    if (cUnit->domPostOrderTraversal.elemList == NULL) {
-        oatInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
-                            numReachableBlocks, kListDomPostOrderTraversal);
-    } else {
-        cUnit->domPostOrderTraversal.numUsed = 0;
-    }
-
-    computeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
-    DCHECK_EQ(cUnit->domPostOrderTraversal.numUsed,
-           (unsigned) cUnit->numReachableBlocks);
-
-    /* Now compute the dominance frontier for each block */
-    oatDataFlowAnalysisDispatcher(cUnit, computeDominanceFrontier,
-                                          kPostOrderDOMTraversal,
-                                          false /* isIterative */);
+  /* Now compute the dominance frontier for each block */
+  oatDataFlowAnalysisDispatcher(cUnit, computeDominanceFrontier,
+                                        kPostOrderDOMTraversal,
+                                        false /* isIterative */);
 }
 
 /*
@@ -528,20 +525,20 @@
  * This is probably not general enough to be placed in BitVector.[ch].
  */
 void computeSuccLiveIn(ArenaBitVector* dest,
-                              const ArenaBitVector* src1,
-                              const ArenaBitVector* src2)
+                            const ArenaBitVector* src1,
+                            const ArenaBitVector* src2)
 {
-    if (dest->storageSize != src1->storageSize ||
-        dest->storageSize != src2->storageSize ||
-        dest->expandable != src1->expandable ||
-        dest->expandable != src2->expandable) {
-        LOG(FATAL) << "Incompatible set properties";
-    }
+  if (dest->storageSize != src1->storageSize ||
+    dest->storageSize != src2->storageSize ||
+    dest->expandable != src1->expandable ||
+    dest->expandable != src2->expandable) {
+    LOG(FATAL) << "Incompatible set properties";
+  }
 
-    unsigned int idx;
-    for (idx = 0; idx < dest->storageSize; idx++) {
-        dest->storage[idx] |= src1->storage[idx] & ~src2->storage[idx];
-    }
+  unsigned int idx;
+  for (idx = 0; idx < dest->storageSize; idx++) {
+    dest->storage[idx] |= src1->storage[idx] & ~src2->storage[idx];
+  }
 }
 
 /*
@@ -551,121 +548,120 @@
  */
 bool computeBlockLiveIns(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    ArenaBitVector* tempDalvikRegisterV = cUnit->tempDalvikRegisterV;
+  ArenaBitVector* tempDalvikRegisterV = cUnit->tempDalvikRegisterV;
 
-    if (bb->dataFlowInfo == NULL) return false;
-    oatCopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
-    if (bb->taken && bb->taken->dataFlowInfo)
-        computeSuccLiveIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
-                          bb->dataFlowInfo->defV);
-    if (bb->fallThrough && bb->fallThrough->dataFlowInfo)
+  if (bb->dataFlowInfo == NULL) return false;
+  oatCopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
+  if (bb->taken && bb->taken->dataFlowInfo)
+    computeSuccLiveIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
+                      bb->dataFlowInfo->defV);
+  if (bb->fallThrough && bb->fallThrough->dataFlowInfo)
+    computeSuccLiveIn(tempDalvikRegisterV,
+                      bb->fallThrough->dataFlowInfo->liveInV,
+                      bb->dataFlowInfo->defV);
+  if (bb->successorBlockList.blockListType != kNotUsed) {
+    GrowableListIterator iterator;
+    oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+                                &iterator);
+    while (true) {
+      SuccessorBlockInfo *successorBlockInfo =
+          (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+      if (successorBlockInfo == NULL) break;
+      BasicBlock* succBB = successorBlockInfo->block;
+      if (succBB->dataFlowInfo) {
         computeSuccLiveIn(tempDalvikRegisterV,
-                          bb->fallThrough->dataFlowInfo->liveInV,
+                          succBB->dataFlowInfo->liveInV,
                           bb->dataFlowInfo->defV);
-    if (bb->successorBlockList.blockListType != kNotUsed) {
-        GrowableListIterator iterator;
-        oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
-                                    &iterator);
-        while (true) {
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-            if (successorBlockInfo == NULL) break;
-            BasicBlock* succBB = successorBlockInfo->block;
-            if (succBB->dataFlowInfo) {
-                computeSuccLiveIn(tempDalvikRegisterV,
-                                  succBB->dataFlowInfo->liveInV,
-                                  bb->dataFlowInfo->defV);
-            }
-        }
+      }
     }
-    if (oatCompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
-        oatCopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
-        return true;
-    }
-    return false;
+  }
+  if (oatCompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
+    oatCopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
+    return true;
+  }
+  return false;
 }
 
 /* Insert phi nodes to for each variable to the dominance frontiers */
 void insertPhiNodes(CompilationUnit* cUnit)
 {
-    int dalvikReg;
-    const GrowableList* blockList = &cUnit->blockList;
-    ArenaBitVector* phiBlocks =
-        oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
-    ArenaBitVector* tmpBlocks =
-        oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
-    ArenaBitVector* inputBlocks =
-        oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
+  int dalvikReg;
+  const GrowableList* blockList = &cUnit->blockList;
+  ArenaBitVector* phiBlocks =
+      oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
+  ArenaBitVector* tmpBlocks =
+      oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
+  ArenaBitVector* inputBlocks =
+      oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
 
-    cUnit->tempDalvikRegisterV =
-        oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
-                          kBitMapRegisterV);
+  cUnit->tempDalvikRegisterV =
+      oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
+                        kBitMapRegisterV);
 
-    oatDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
-                                          kPostOrderDFSTraversal,
-                                          true /* isIterative */);
+  oatDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
+                                kPostOrderDFSTraversal, true /* isIterative */);
 
-    /* Iterate through each Dalvik register */
-    for (dalvikReg = 0; dalvikReg < cUnit->numDalvikRegisters; dalvikReg++) {
-        bool change;
-        ArenaBitVectorIterator iterator;
+  /* Iterate through each Dalvik register */
+  for (dalvikReg = 0; dalvikReg < cUnit->numDalvikRegisters; dalvikReg++) {
+    bool change;
+    ArenaBitVectorIterator iterator;
 
-        oatCopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
-        oatClearAllBits(phiBlocks);
+    oatCopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
+    oatClearAllBits(phiBlocks);
 
-        /* Calculate the phi blocks for each Dalvik register */
-        do {
-            change = false;
-            oatClearAllBits(tmpBlocks);
-            oatBitVectorIteratorInit(inputBlocks, &iterator);
+    /* Calculate the phi blocks for each Dalvik register */
+    do {
+      change = false;
+      oatClearAllBits(tmpBlocks);
+      oatBitVectorIteratorInit(inputBlocks, &iterator);
 
-            while (true) {
-                int idx = oatBitVectorIteratorNext(&iterator);
-                if (idx == -1) break;
-                BasicBlock* defBB =
-                    (BasicBlock* ) oatGrowableListGetElement(blockList, idx);
+      while (true) {
+        int idx = oatBitVectorIteratorNext(&iterator);
+        if (idx == -1) break;
+          BasicBlock* defBB =
+              (BasicBlock* ) oatGrowableListGetElement(blockList, idx);
 
-                /* Merge the dominance frontier to tmpBlocks */
-                //TUNING: hot call to oatUnifyBitVectors
-                if (defBB->domFrontier != NULL) {
-                    oatUnifyBitVectors(tmpBlocks, tmpBlocks, defBB->domFrontier);
-                }
-            }
-            if (oatCompareBitVectors(phiBlocks, tmpBlocks)) {
-                change = true;
-                oatCopyBitVector(phiBlocks, tmpBlocks);
-
-                /*
-                 * Iterate through the original blocks plus the new ones in
-                 * the dominance frontier.
-                 */
-                oatCopyBitVector(inputBlocks, phiBlocks);
-                oatUnifyBitVectors(inputBlocks, inputBlocks,
-                                   cUnit->defBlockMatrix[dalvikReg]);
-            }
-        } while (change);
-
-        /*
-         * Insert a phi node for dalvikReg in the phiBlocks if the Dalvik
-         * register is in the live-in set.
-         */
-        oatBitVectorIteratorInit(phiBlocks, &iterator);
-        while (true) {
-            int idx = oatBitVectorIteratorNext(&iterator);
-            if (idx == -1) break;
-            BasicBlock* phiBB =
-                (BasicBlock* ) oatGrowableListGetElement(blockList, idx);
-            /* Variable will be clobbered before being used - no need for phi */
-            if (!oatIsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
-            MIR *phi = (MIR *) oatNew(cUnit, sizeof(MIR), true, kAllocDFInfo);
-            phi->dalvikInsn.opcode = (Instruction::Code)kMirOpPhi;
-            phi->dalvikInsn.vA = dalvikReg;
-            phi->offset = phiBB->startOffset;
-            phi->meta.phiNext = cUnit->phiList;
-            cUnit->phiList = phi;
-            oatPrependMIR(phiBB, phi);
+          /* Merge the dominance frontier to tmpBlocks */
+          //TUNING: hot call to oatUnifyBitVectors
+          if (defBB->domFrontier != NULL) {
+            oatUnifyBitVectors(tmpBlocks, tmpBlocks, defBB->domFrontier);
+          }
         }
+        if (oatCompareBitVectors(phiBlocks, tmpBlocks)) {
+          change = true;
+          oatCopyBitVector(phiBlocks, tmpBlocks);
+
+          /*
+           * Iterate through the original blocks plus the new ones in
+           * the dominance frontier.
+           */
+          oatCopyBitVector(inputBlocks, phiBlocks);
+          oatUnifyBitVectors(inputBlocks, inputBlocks,
+                             cUnit->defBlockMatrix[dalvikReg]);
+      }
+    } while (change);
+
+    /*
+     * Insert a phi node for dalvikReg in the phiBlocks if the Dalvik
+     * register is in the live-in set.
+     */
+    oatBitVectorIteratorInit(phiBlocks, &iterator);
+    while (true) {
+      int idx = oatBitVectorIteratorNext(&iterator);
+      if (idx == -1) break;
+      BasicBlock* phiBB =
+          (BasicBlock* ) oatGrowableListGetElement(blockList, idx);
+      /* Variable will be clobbered before being used - no need for phi */
+      if (!oatIsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
+      MIR *phi = (MIR *) oatNew(cUnit, sizeof(MIR), true, kAllocDFInfo);
+      phi->dalvikInsn.opcode = (Instruction::Code)kMirOpPhi;
+      phi->dalvikInsn.vA = dalvikReg;
+      phi->offset = phiBB->startOffset;
+      phi->meta.phiNext = cUnit->phiList;
+      cUnit->phiList = phi;
+      oatPrependMIR(phiBB, phi);
     }
+  }
 }
 
 /*
@@ -674,139 +670,136 @@
  */
 bool insertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    ArenaBitVector* ssaRegV = cUnit->tempSSARegisterV;
-    GrowableListIterator iter;
-    MIR *mir;
+  ArenaBitVector* ssaRegV = cUnit->tempSSARegisterV;
+  GrowableListIterator iter;
+  MIR *mir;
 
-    /* Phi nodes are at the beginning of each block */
-    for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        if (mir->dalvikInsn.opcode != (Instruction::Code)kMirOpPhi)
-            return true;
-        int ssaReg = mir->ssaRep->defs[0];
-        DCHECK_GE(ssaReg, 0);   // Shouldn't see compiler temps here
-        int vReg = SRegToVReg(cUnit, ssaReg);
+  /* Phi nodes are at the beginning of each block */
+  for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
+    if (mir->dalvikInsn.opcode != (Instruction::Code)kMirOpPhi)
+      return true;
+    int ssaReg = mir->ssaRep->defs[0];
+    DCHECK_GE(ssaReg, 0);   // Shouldn't see compiler temps here
+    int vReg = SRegToVReg(cUnit, ssaReg);
 
-        oatClearAllBits(ssaRegV);
+    oatClearAllBits(ssaRegV);
 
-        /* Iterate through the predecessors */
-        oatGrowableListIteratorInit(bb->predecessors, &iter);
-        while (true) {
-            BasicBlock* predBB =
-               (BasicBlock*)oatGrowableListIteratorNext(&iter);
-            if (!predBB) break;
-            int ssaReg =
-                predBB->dataFlowInfo->vRegToSSAMap[vReg];
-            oatSetBit(cUnit, ssaRegV, ssaReg);
-        }
-
-        /* Count the number of SSA registers for a Dalvik register */
-        int numUses = oatCountSetBits(ssaRegV);
-        mir->ssaRep->numUses = numUses;
-        mir->ssaRep->uses =
-            (int *) oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo);
-        mir->ssaRep->fpUse =
-            (bool *) oatNew(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo);
-
-        ArenaBitVectorIterator phiIterator;
-
-        oatBitVectorIteratorInit(ssaRegV, &phiIterator);
-        int *usePtr = mir->ssaRep->uses;
-
-        /* Set the uses array for the phi node */
-        while (true) {
-            int ssaRegIdx = oatBitVectorIteratorNext(&phiIterator);
-            if (ssaRegIdx == -1) break;
-            *usePtr++ = ssaRegIdx;
-        }
+    /* Iterate through the predecessors */
+    oatGrowableListIteratorInit(bb->predecessors, &iter);
+    while (true) {
+      BasicBlock* predBB =
+         (BasicBlock*)oatGrowableListIteratorNext(&iter);
+      if (!predBB) break;
+      int ssaReg = predBB->dataFlowInfo->vRegToSSAMap[vReg];
+      oatSetBit(cUnit, ssaRegV, ssaReg);
     }
 
-    return true;
+    /* Count the number of SSA registers for a Dalvik register */
+    int numUses = oatCountSetBits(ssaRegV);
+    mir->ssaRep->numUses = numUses;
+    mir->ssaRep->uses =
+        (int *) oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo);
+    mir->ssaRep->fpUse =
+        (bool *) oatNew(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo);
+
+    ArenaBitVectorIterator phiIterator;
+
+    oatBitVectorIteratorInit(ssaRegV, &phiIterator);
+    int *usePtr = mir->ssaRep->uses;
+
+    /* Set the uses array for the phi node */
+    while (true) {
+      int ssaRegIdx = oatBitVectorIteratorNext(&phiIterator);
+      if (ssaRegIdx == -1) break;
+        *usePtr++ = ssaRegIdx;
+    }
+  }
+
+  return true;
 }
 
 void doDFSPreOrderSSARename(CompilationUnit* cUnit, BasicBlock* block)
 {
 
-    if (block->visited || block->hidden) return;
-    block->visited = true;
+  if (block->visited || block->hidden) return;
+  block->visited = true;
 
-    /* Process this block */
-    oatDoSSAConversion(cUnit, block);
-    int mapSize = sizeof(int) * cUnit->numDalvikRegisters;
+  /* Process this block */
+  oatDoSSAConversion(cUnit, block);
+  int mapSize = sizeof(int) * cUnit->numDalvikRegisters;
 
-    /* Save SSA map snapshot */
-    int* savedSSAMap = (int*)oatNew(cUnit, mapSize, false,
-                                    kAllocDalvikToSSAMap);
-    memcpy(savedSSAMap, cUnit->vRegToSSAMap, mapSize);
+  /* Save SSA map snapshot */
+  int* savedSSAMap = (int*)oatNew(cUnit, mapSize, false,
+                                  kAllocDalvikToSSAMap);
+  memcpy(savedSSAMap, cUnit->vRegToSSAMap, mapSize);
 
-    if (block->fallThrough) {
-        doDFSPreOrderSSARename(cUnit, block->fallThrough);
-        /* Restore SSA map snapshot */
-        memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
+  if (block->fallThrough) {
+    doDFSPreOrderSSARename(cUnit, block->fallThrough);
+    /* Restore SSA map snapshot */
+    memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
+  }
+  if (block->taken) {
+    doDFSPreOrderSSARename(cUnit, block->taken);
+    /* Restore SSA map snapshot */
+    memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
+  }
+  if (block->successorBlockList.blockListType != kNotUsed) {
+    GrowableListIterator iterator;
+    oatGrowableListIteratorInit(&block->successorBlockList.blocks,
+                                &iterator);
+    while (true) {
+      SuccessorBlockInfo *successorBlockInfo =
+          (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+      if (successorBlockInfo == NULL) break;
+      BasicBlock* succBB = successorBlockInfo->block;
+      doDFSPreOrderSSARename(cUnit, succBB);
+      /* Restore SSA map snapshot */
+      memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
     }
-    if (block->taken) {
-        doDFSPreOrderSSARename(cUnit, block->taken);
-        /* Restore SSA map snapshot */
-        memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
-    }
-    if (block->successorBlockList.blockListType != kNotUsed) {
-        GrowableListIterator iterator;
-        oatGrowableListIteratorInit(&block->successorBlockList.blocks,
-                                    &iterator);
-        while (true) {
-            SuccessorBlockInfo *successorBlockInfo =
-                (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
-            if (successorBlockInfo == NULL) break;
-            BasicBlock* succBB = successorBlockInfo->block;
-            doDFSPreOrderSSARename(cUnit, succBB);
-            /* Restore SSA map snapshot */
-            memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
-        }
-    }
-    cUnit->vRegToSSAMap = savedSSAMap;
-    return;
+  }
+  cUnit->vRegToSSAMap = savedSSAMap;
+  return;
 }
 
 /* Perform SSA transformation for the whole method */
 void oatMethodSSATransformation(CompilationUnit* cUnit)
 {
-    /* Compute the DFS order */
-    computeDFSOrders(cUnit);
+  /* Compute the DFS order */
+  computeDFSOrders(cUnit);
 
-    if (!cUnit->disableDataflow) {
-        /* Compute the dominator info */
-        computeDominators(cUnit);
-    }
+  if (!cUnit->disableDataflow) {
+    /* Compute the dominator info */
+    computeDominators(cUnit);
+  }
 
-    /* Allocate data structures in preparation for SSA conversion */
-    oatInitializeSSAConversion(cUnit);
+  /* Allocate data structures in preparation for SSA conversion */
+  oatInitializeSSAConversion(cUnit);
 
-    if (!cUnit->disableDataflow) {
-        /* Find out the "Dalvik reg def x block" relation */
-        computeDefBlockMatrix(cUnit);
+  if (!cUnit->disableDataflow) {
+    /* Find out the "Dalvik reg def x block" relation */
+    computeDefBlockMatrix(cUnit);
 
-        /* Insert phi nodes to dominance frontiers for all variables */
-        insertPhiNodes(cUnit);
-    }
+    /* Insert phi nodes to dominance frontiers for all variables */
+    insertPhiNodes(cUnit);
+  }
 
-    /* Rename register names by local defs and phi nodes */
-    oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
-                                          kAllNodes,
-                                          false /* isIterative */);
-    doDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
+  /* Rename register names by local defs and phi nodes */
+  oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+                                kAllNodes, false /* isIterative */);
+  doDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
 
-    if (!cUnit->disableDataflow) {
-        /*
-         * Shared temp bit vector used by each block to count the number of defs
-         * from all the predecessor blocks.
-         */
-        cUnit->tempSSARegisterV = oatAllocBitVector(cUnit, cUnit->numSSARegs,
-             false, kBitMapTempSSARegisterV);
+  if (!cUnit->disableDataflow) {
+    /*
+     * Shared temp bit vector used by each block to count the number of defs
+     * from all the predecessor blocks.
+     */
+    cUnit->tempSSARegisterV = oatAllocBitVector(cUnit, cUnit->numSSARegs,
+         false, kBitMapTempSSARegisterV);
 
-        /* Insert phi-operands with latest SSA names from predecessor blocks */
-        oatDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
-                                      kReachableNodes,
-                                      false /* isIterative */);
-    }
+    /* Insert phi-operands with latest SSA names from predecessor blocks */
+    oatDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
+                                  kReachableNodes, false /* isIterative */);
+  }
 }
 
 }  // namespace art
diff --git a/src/compiler/Utility.cc b/src/compiler/Utility.cc
index f5b478c..571208f 100644
--- a/src/compiler/Utility.cc
+++ b/src/compiler/Utility.cc
@@ -21,64 +21,64 @@
 
 #ifdef WITH_MEMSTATS
 struct Memstats {
-    u4 allocStats[kNumAllocKinds];
-    int listSizes[kNumListKinds];
-    int listWasted[kNumListKinds];
-    int listGrows[kNumListKinds];
-    int listMaxElems[kNumListKinds];
-    int bitMapSizes[kNumBitMapKinds];
-    int bitMapWasted[kNumBitMapKinds];
-    int bitMapGrows[kNumBitMapKinds];
+  u4 allocStats[kNumAllocKinds];
+  int listSizes[kNumListKinds];
+  int listWasted[kNumListKinds];
+  int listGrows[kNumListKinds];
+  int listMaxElems[kNumListKinds];
+  int bitMapSizes[kNumBitMapKinds];
+  int bitMapWasted[kNumBitMapKinds];
+  int bitMapGrows[kNumBitMapKinds];
 };
 
 const char* allocNames[kNumAllocKinds] = {
-    "Misc       ",
-    "BasicBlock ",
-    "LIR        ",
-    "MIR        ",
-    "DataFlow   ",
-    "GrowList   ",
-    "GrowBitMap ",
-    "Dalvik2SSA ",
-    "DebugInfo  ",
-    "Successor  ",
-    "RegAlloc   ",
-    "Data       ",
-    "Preds      ",
+  "Misc       ",
+  "BasicBlock ",
+  "LIR        ",
+  "MIR        ",
+  "DataFlow   ",
+  "GrowList   ",
+  "GrowBitMap ",
+  "Dalvik2SSA ",
+  "DebugInfo  ",
+  "Successor  ",
+  "RegAlloc   ",
+  "Data       ",
+  "Preds      ",
 };
 
 const char* listNames[kNumListKinds] = {
-    "Misc                  ",
-    "blockList             ",
-    "SSAtoDalvik           ",
-    "dfsOrder              ",
-    "dfsPostOrder          ",
-    "domPostOrderTraversal ",
-    "throwLaunchPads       ",
-    "suspendLaunchPads     ",
-    "switchTables          ",
-    "fillArrayData         ",
-    "SuccessorBlocks       ",
-    "Predecessors          ",
+  "Misc                  ",
+  "blockList             ",
+  "SSAtoDalvik           ",
+  "dfsOrder              ",
+  "dfsPostOrder          ",
+  "domPostOrderTraversal ",
+  "throwLaunchPads       ",
+  "suspendLaunchPads     ",
+  "switchTables          ",
+  "fillArrayData         ",
+  "SuccessorBlocks       ",
+  "Predecessors          ",
 };
 
 const char* bitMapNames[kNumBitMapKinds] = {
-    "Misc                  ",
-    "Use                   ",
-    "Def                   ",
-    "LiveIn                ",
-    "BlockMatrix           ",
-    "Dominators            ",
-    "IDominated            ",
-    "DomFrontier           ",
-    "Phi                   ",
-    "TmpBlocks             ",
-    "InputBlocks           ",
-    "RegisterV             ",
-    "TempSSARegisterV      ",
-    "Null Check            ",
-    "TmpBlockV             ",
-    "Predecessors          ",
+  "Misc                  ",
+  "Use                   ",
+  "Def                   ",
+  "LiveIn                ",
+  "BlockMatrix           ",
+  "Dominators            ",
+  "IDominated            ",
+  "DomFrontier           ",
+  "Phi                   ",
+  "TmpBlocks             ",
+  "InputBlocks           ",
+  "RegisterV             ",
+  "TempSSARegisterV      ",
+  "Null Check            ",
+  "TmpBlockV             ",
+  "Predecessors          ",
 };
 #endif
 
@@ -87,266 +87,265 @@
 /* Allocate the initial memory block for arena-based allocation */
 bool oatHeapInit(CompilationUnit* cUnit)
 {
-    DCHECK(cUnit->arenaHead == NULL);
-    cUnit->arenaHead =
-        (ArenaMemBlock *) malloc(sizeof(ArenaMemBlock) + ARENA_DEFAULT_SIZE);
-    if (cUnit->arenaHead == NULL) {
-        LOG(FATAL) << "No memory left to create compiler heap memory";
-    }
-    cUnit->arenaHead->blockSize = ARENA_DEFAULT_SIZE;
-    cUnit->currentArena = cUnit->arenaHead;
-    cUnit->currentArena->bytesAllocated = 0;
-    cUnit->currentArena->next = NULL;
-    cUnit->numArenaBlocks = 1;
+  DCHECK(cUnit->arenaHead == NULL);
+  cUnit->arenaHead =
+      (ArenaMemBlock *) malloc(sizeof(ArenaMemBlock) + ARENA_DEFAULT_SIZE);
+  if (cUnit->arenaHead == NULL) {
+    LOG(FATAL) << "No memory left to create compiler heap memory";
+  }
+  cUnit->arenaHead->blockSize = ARENA_DEFAULT_SIZE;
+  cUnit->currentArena = cUnit->arenaHead;
+  cUnit->currentArena->bytesAllocated = 0;
+  cUnit->currentArena->next = NULL;
+  cUnit->numArenaBlocks = 1;
 #ifdef WITH_MEMSTATS
-    cUnit->mstats = (Memstats*) oatNew(cUnit, sizeof(Memstats), true,
-                     kAllocDebugInfo);
+  cUnit->mstats = (Memstats*) oatNew(cUnit, sizeof(Memstats), true,
+                   kAllocDebugInfo);
 #endif
-    return true;
+  return true;
 }
 
 /* Arena-based malloc for compilation tasks */
 void* oatNew(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind)
 {
-    size = (size + 3) & ~3;
+  size = (size + 3) & ~3;
 #ifdef WITH_MEMSTATS
-    if (cUnit->mstats != NULL) {
-        cUnit->mstats->allocStats[kind] += size;
-    }
+  if (cUnit->mstats != NULL) {
+    cUnit->mstats->allocStats[kind] += size;
+  }
 #endif
 retry:
-    /* Normal case - space is available in the current page */
-    if (size + cUnit->currentArena->bytesAllocated <=
-        cUnit->currentArena->blockSize) {
-        void *ptr;
-        ptr = &cUnit->currentArena->ptr[cUnit->currentArena->bytesAllocated];
-        cUnit->currentArena->bytesAllocated += size;
-        if (zero) {
-            memset(ptr, 0, size);
-        }
-        return ptr;
-    } else {
-        /*
-         * See if there are previously allocated arena blocks before the last
-         * reset
-         */
-        if (cUnit->currentArena->next) {
-            cUnit->currentArena = cUnit->currentArena->next;
-            cUnit->currentArena->bytesAllocated = 0;
-            goto retry;
-        }
-
-        size_t blockSize = (size < ARENA_DEFAULT_SIZE) ?
-                          ARENA_DEFAULT_SIZE : size;
-        /* Time to allocate a new arena */
-        ArenaMemBlock *newArena = (ArenaMemBlock *)
-            malloc(sizeof(ArenaMemBlock) + blockSize);
-        if (newArena == NULL) {
-            LOG(FATAL) << "Arena allocation failure";
-        }
-        newArena->blockSize = blockSize;
-        newArena->bytesAllocated = 0;
-        newArena->next = NULL;
-        cUnit->currentArena->next = newArena;
-        cUnit->currentArena = newArena;
-        cUnit->numArenaBlocks++;
-        if (cUnit->numArenaBlocks > 20000) {
-            LOG(INFO) << "Total arena pages: " << cUnit->numArenaBlocks;
-        }
+  /* Normal case - space is available in the current page */
+  if (size + cUnit->currentArena->bytesAllocated <=
+    cUnit->currentArena->blockSize) {
+    void *ptr;
+    ptr = &cUnit->currentArena->ptr[cUnit->currentArena->bytesAllocated];
+    cUnit->currentArena->bytesAllocated += size;
+    if (zero) {
+      memset(ptr, 0, size);
+    }
+    return ptr;
+  } else {
+    /*
+     * See if there are previously allocated arena blocks before the last
+     * reset
+     */
+    if (cUnit->currentArena->next) {
+        cUnit->currentArena = cUnit->currentArena->next;
+        cUnit->currentArena->bytesAllocated = 0;
         goto retry;
     }
+
+    size_t blockSize = (size < ARENA_DEFAULT_SIZE) ?  ARENA_DEFAULT_SIZE : size;
+    /* Time to allocate a new arena */
+    ArenaMemBlock *newArena = (ArenaMemBlock *)
+        malloc(sizeof(ArenaMemBlock) + blockSize);
+    if (newArena == NULL) {
+      LOG(FATAL) << "Arena allocation failure";
+    }
+    newArena->blockSize = blockSize;
+    newArena->bytesAllocated = 0;
+    newArena->next = NULL;
+    cUnit->currentArena->next = newArena;
+    cUnit->currentArena = newArena;
+    cUnit->numArenaBlocks++;
+    if (cUnit->numArenaBlocks > 20000) {
+      LOG(INFO) << "Total arena pages: " << cUnit->numArenaBlocks;
+    }
+    goto retry;
+  }
 }
 
 /* Reclaim all the arena blocks allocated so far */
 void oatArenaReset(CompilationUnit* cUnit)
 {
-    ArenaMemBlock* head = cUnit->arenaHead;
-    while (head != NULL) {
-        ArenaMemBlock* p = head;
-        head = head->next;
-        free(p);
-    }
-    cUnit->arenaHead = NULL;
-    cUnit->currentArena = NULL;
+  ArenaMemBlock* head = cUnit->arenaHead;
+  while (head != NULL) {
+    ArenaMemBlock* p = head;
+    head = head->next;
+    free(p);
+  }
+  cUnit->arenaHead = NULL;
+  cUnit->currentArena = NULL;
 }
 
 /* Growable List initialization */
 void oatInitGrowableList(CompilationUnit* cUnit, GrowableList* gList,
-                         size_t initLength, oatListKind kind)
+                       size_t initLength, oatListKind kind)
 {
-    gList->numAllocated = initLength;
-    gList->numUsed = 0;
-    gList->elemList = (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * initLength,
-                                          true, kAllocGrowableList);
+  gList->numAllocated = initLength;
+  gList->numUsed = 0;
+  gList->elemList = (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * initLength,
+                                        true, kAllocGrowableList);
 #ifdef WITH_MEMSTATS
-    cUnit->mstats->listSizes[kind] += sizeof(intptr_t) * initLength;
-    gList->kind = kind;
-    if ((int)initLength > cUnit->mstats->listMaxElems[kind]) {
-        cUnit->mstats->listMaxElems[kind] = initLength;
-    }
+  cUnit->mstats->listSizes[kind] += sizeof(intptr_t) * initLength;
+  gList->kind = kind;
+  if ((int)initLength > cUnit->mstats->listMaxElems[kind]) {
+    cUnit->mstats->listMaxElems[kind] = initLength;
+  }
 #endif
 }
 
 /* Expand the capacity of a growable list */
 void expandGrowableList(CompilationUnit* cUnit, GrowableList* gList)
 {
-    int newLength = gList->numAllocated;
-    if (newLength < 128) {
-        newLength <<= 1;
-    } else {
-        newLength += 128;
-    }
-    intptr_t *newArray =
-        (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * newLength, true,
-                            kAllocGrowableList);
-    memcpy(newArray, gList->elemList, sizeof(intptr_t) * gList->numAllocated);
+  int newLength = gList->numAllocated;
+  if (newLength < 128) {
+    newLength <<= 1;
+  } else {
+    newLength += 128;
+  }
+  intptr_t *newArray =
+      (intptr_t *) oatNew(cUnit, sizeof(intptr_t) * newLength, true,
+                          kAllocGrowableList);
+  memcpy(newArray, gList->elemList, sizeof(intptr_t) * gList->numAllocated);
 #ifdef WITH_MEMSTATS
-    cUnit->mstats->listSizes[gList->kind] += sizeof(intptr_t) * newLength;
-    cUnit->mstats->listWasted[gList->kind] +=
-        sizeof(intptr_t) * gList->numAllocated;
-    cUnit->mstats->listGrows[gList->kind]++;
-    if (newLength > cUnit->mstats->listMaxElems[gList->kind]) {
-        cUnit->mstats->listMaxElems[gList->kind] = newLength;
-    }
+  cUnit->mstats->listSizes[gList->kind] += sizeof(intptr_t) * newLength;
+  cUnit->mstats->listWasted[gList->kind] +=
+      sizeof(intptr_t) * gList->numAllocated;
+  cUnit->mstats->listGrows[gList->kind]++;
+  if (newLength > cUnit->mstats->listMaxElems[gList->kind]) {
+    cUnit->mstats->listMaxElems[gList->kind] = newLength;
+  }
 #endif
-    gList->numAllocated = newLength;
-    gList->elemList = newArray;
+  gList->numAllocated = newLength;
+  gList->elemList = newArray;
 }
 
 /* Insert a new element into the growable list */
 void oatInsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
-                           intptr_t elem)
+                         intptr_t elem)
 {
-    DCHECK_NE(gList->numAllocated, 0U);
-    if (gList->numUsed == gList->numAllocated) {
-        expandGrowableList(cUnit, gList);
-    }
-    gList->elemList[gList->numUsed++] = elem;
+  DCHECK_NE(gList->numAllocated, 0U);
+  if (gList->numUsed == gList->numAllocated) {
+    expandGrowableList(cUnit, gList);
+  }
+  gList->elemList[gList->numUsed++] = elem;
 }
 
 /* Delete an element from a growable list. Element must be present */
 void oatDeleteGrowableList(GrowableList* gList, intptr_t elem)
 {
-    bool found = false;
-    for (unsigned int i = 0; i < gList->numUsed; i++) {
-        if (!found && gList->elemList[i] == elem) {
-            found = true;
-        }
-        if (found) {
-            gList->elemList[i] = gList->elemList[i+1];
-        }
+  bool found = false;
+  for (unsigned int i = 0; i < gList->numUsed; i++) {
+    if (!found && gList->elemList[i] == elem) {
+      found = true;
     }
-    DCHECK_EQ(found, true);
-    gList->numUsed--;
+    if (found) {
+      gList->elemList[i] = gList->elemList[i+1];
+    }
+  }
+  DCHECK_EQ(found, true);
+  gList->numUsed--;
 }
 
 void oatGrowableListIteratorInit(GrowableList* gList,
-                                 GrowableListIterator* iterator)
+                               GrowableListIterator* iterator)
 {
-    iterator->list = gList;
-    iterator->idx = 0;
-    iterator->size = gList->numUsed;
+  iterator->list = gList;
+  iterator->idx = 0;
+  iterator->size = gList->numUsed;
 }
 
 intptr_t oatGrowableListIteratorNext(GrowableListIterator* iterator)
 {
-    DCHECK_EQ(iterator->size, iterator->list->numUsed);
-    if (iterator->idx == iterator->size) return 0;
-    return iterator->list->elemList[iterator->idx++];
+  DCHECK_EQ(iterator->size, iterator->list->numUsed);
+  if (iterator->idx == iterator->size) return 0;
+  return iterator->list->elemList[iterator->idx++];
 }
 
 intptr_t oatGrowableListGetElement(const GrowableList* gList, size_t idx)
 {
-    DCHECK_LT(idx, gList->numUsed);
-    return gList->elemList[idx];
+  DCHECK_LT(idx, gList->numUsed);
+  return gList->elemList[idx];
 }
 
 #ifdef WITH_MEMSTATS
 /* Dump memory usage stats */
 void oatDumpMemStats(CompilationUnit* cUnit)
 {
-    u4 total = 0;
-    for (int i = 0; i < kNumAllocKinds; i++) {
-        total += cUnit->mstats->allocStats[i];
+  u4 total = 0;
+  for (int i = 0; i < kNumAllocKinds; i++) {
+    total += cUnit->mstats->allocStats[i];
+  }
+  if (total > (10 * 1024 * 1024)) {
+    LOG(INFO) << "MEMUSAGE: " << total << " : "
+        << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
+    LOG(INFO) << "insnsSize: " << cUnit->insnsSize;
+    if (cUnit->disableDataflow) {
+        LOG(INFO) << " ** Dataflow disabled ** ";
     }
-    if (total > (10 * 1024 * 1024)) {
-        LOG(INFO) << "MEMUSAGE: " << total << " : "
-            << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
-        LOG(INFO) << "insnsSize: " << cUnit->insnsSize;
-        if (cUnit->disableDataflow) {
-            LOG(INFO) << " ** Dataflow disabled ** ";
-        }
-        LOG(INFO) << "===== Overall allocations";
-        for (int i = 0; i < kNumAllocKinds; i++) {
-            LOG(INFO) << allocNames[i] << std::setw(10) <<
-            cUnit->mstats->allocStats[i];
-        }
-        LOG(INFO) << "===== GrowableList allocations";
-        for (int i = 0; i < kNumListKinds; i++) {
-            LOG(INFO) << listNames[i]
+    LOG(INFO) << "===== Overall allocations";
+    for (int i = 0; i < kNumAllocKinds; i++) {
+        LOG(INFO) << allocNames[i] << std::setw(10) <<
+        cUnit->mstats->allocStats[i];
+    }
+    LOG(INFO) << "===== GrowableList allocations";
+    for (int i = 0; i < kNumListKinds; i++) {
+      LOG(INFO) << listNames[i]
                 << " S:" << cUnit->mstats->listSizes[i]
                 << ", W:" << cUnit->mstats->listWasted[i]
                 << ", G:" << cUnit->mstats->listGrows[i]
                 << ", E:" << cUnit->mstats->listMaxElems[i];
-        }
-        LOG(INFO) << "===== GrowableBitMap allocations";
-        for (int i = 0; i < kNumBitMapKinds; i++) {
-            LOG(INFO) << bitMapNames[i]
+    }
+    LOG(INFO) << "===== GrowableBitMap allocations";
+    for (int i = 0; i < kNumBitMapKinds; i++) {
+      LOG(INFO) << bitMapNames[i]
                 << " S:" << cUnit->mstats->bitMapSizes[i]
                 << ", W:" << cUnit->mstats->bitMapWasted[i]
                 << ", G:" << cUnit->mstats->bitMapGrows[i];
-        }
     }
+  }
 }
 #endif
 
 /* Debug Utility - dump a compilation unit */
 void oatDumpCompilationUnit(CompilationUnit* cUnit)
 {
-    BasicBlock* bb;
-    const char* blockTypeNames[] = {
-        "Entry Block",
-        "Code Block",
-        "Exit Block",
-        "Exception Handling",
-        "Catch Block"
-    };
+  BasicBlock* bb;
+  const char* blockTypeNames[] = {
+    "Entry Block",
+    "Code Block",
+    "Exit Block",
+    "Exception Handling",
+    "Catch Block"
+  };
 
-    LOG(INFO) << "Compiling " << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
-    LOG(INFO) << cUnit->insns << " insns";
-    LOG(INFO) << cUnit->numBlocks << " blocks in total";
-    GrowableListIterator iterator;
+  LOG(INFO) << "Compiling " << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
+  LOG(INFO) << cUnit->insns << " insns";
+  LOG(INFO) << cUnit->numBlocks << " blocks in total";
+  GrowableListIterator iterator;
 
-    oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+  oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
 
-    while (true) {
-        bb = (BasicBlock *) oatGrowableListIteratorNext(&iterator);
-        if (bb == NULL) break;
-        LOG(INFO) << StringPrintf("Block %d (%s) (insn %04x - %04x%s)",
-             bb->id,
-             blockTypeNames[bb->blockType],
-             bb->startOffset,
-             bb->lastMIRInsn ? bb->lastMIRInsn->offset : bb->startOffset,
-             bb->lastMIRInsn ? "" : " empty");
-        if (bb->taken) {
-            LOG(INFO) << "  Taken branch: block " << bb->taken->id <<
-                 "(0x" << std::hex << bb->taken->startOffset << ")";
-        }
-        if (bb->fallThrough) {
-            LOG(INFO) << "  Fallthrough : block " << bb->fallThrough->id <<
-                 " (0x" << std::hex << bb->fallThrough->startOffset << ")";
-        }
+  while (true) {
+    bb = (BasicBlock *) oatGrowableListIteratorNext(&iterator);
+    if (bb == NULL) break;
+    LOG(INFO) << StringPrintf("Block %d (%s) (insn %04x - %04x%s)",
+        bb->id,
+        blockTypeNames[bb->blockType],
+        bb->startOffset,
+        bb->lastMIRInsn ? bb->lastMIRInsn->offset : bb->startOffset,
+        bb->lastMIRInsn ? "" : " empty");
+    if (bb->taken) {
+      LOG(INFO) << "  Taken branch: block " << bb->taken->id
+                << "(0x" << std::hex << bb->taken->startOffset << ")";
     }
+    if (bb->fallThrough) {
+      LOG(INFO) << "  Fallthrough : block " << bb->fallThrough->id
+                << " (0x" << std::hex << bb->fallThrough->startOffset << ")";
+    }
+  }
 }
 
 static uint32_t checkMasks[32] = {
-    0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010,
-    0x00000020, 0x00000040, 0x00000080, 0x00000100, 0x00000200,
-    0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000,
-    0x00008000, 0x00010000, 0x00020000, 0x00040000, 0x00080000,
-    0x00100000, 0x00200000, 0x00400000, 0x00800000, 0x01000000,
-    0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000,
-    0x40000000, 0x80000000 };
+  0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010,
+  0x00000020, 0x00000040, 0x00000080, 0x00000100, 0x00000200,
+  0x00000400, 0x00000800, 0x00001000, 0x00002000, 0x00004000,
+  0x00008000, 0x00010000, 0x00020000, 0x00040000, 0x00080000,
+  0x00100000, 0x00200000, 0x00400000, 0x00800000, 0x01000000,
+  0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000,
+  0x40000000, 0x80000000 };
 
 /*
  * Allocate a bit vector with enough space to hold at least the specified
@@ -355,28 +354,28 @@
  * NOTE: memory is allocated from the compiler arena.
  */
 ArenaBitVector* oatAllocBitVector(CompilationUnit* cUnit,
-                                  unsigned int startBits, bool expandable,
-                                  oatBitMapKind kind)
+                                unsigned int startBits, bool expandable,
+                                oatBitMapKind kind)
 {
-    ArenaBitVector* bv;
-    unsigned int count;
+  ArenaBitVector* bv;
+  unsigned int count;
 
-    DCHECK_EQ(sizeof(bv->storage[0]), 4U);        /* assuming 32-bit units */
+  DCHECK_EQ(sizeof(bv->storage[0]), 4U);        /* assuming 32-bit units */
 
-    bv = (ArenaBitVector*) oatNew(cUnit, sizeof(ArenaBitVector), false,
-                                  kAllocGrowableBitMap);
+  bv = (ArenaBitVector*) oatNew(cUnit, sizeof(ArenaBitVector), false,
+                                kAllocGrowableBitMap);
 
-    count = (startBits + 31) >> 5;
+  count = (startBits + 31) >> 5;
 
-    bv->storageSize = count;
-    bv->expandable = expandable;
-    bv->storage = (u4*) oatNew(cUnit, count * sizeof(u4), true,
-                               kAllocGrowableBitMap);
+  bv->storageSize = count;
+  bv->expandable = expandable;
+  bv->storage = (u4*) oatNew(cUnit, count * sizeof(u4), true,
+                             kAllocGrowableBitMap);
 #ifdef WITH_MEMSTATS
-    bv->kind = kind;
-    cUnit->mstats->bitMapSizes[kind] += count * sizeof(u4);
+  bv->kind = kind;
+  cUnit->mstats->bitMapSizes[kind] += count * sizeof(u4);
 #endif
-    return bv;
+  return bv;
 }
 
 /*
@@ -384,10 +383,10 @@
  */
 bool oatIsBitSet(const ArenaBitVector* pBits, unsigned int num)
 {
-    DCHECK_LT(num, pBits->storageSize * sizeof(u4) * 8);
+  DCHECK_LT(num, pBits->storageSize * sizeof(u4) * 8);
 
-    unsigned int val = pBits->storage[num >> 5] & checkMasks[num & 0x1f];
-    return (val != 0);
+  unsigned int val = pBits->storage[num >> 5] & checkMasks[num & 0x1f];
+  return (val != 0);
 }
 
 /*
@@ -395,8 +394,8 @@
  */
 void oatClearAllBits(ArenaBitVector* pBits)
 {
-    unsigned int count = pBits->storageSize;
-    memset(pBits->storage, 0, count * sizeof(u4));
+  unsigned int count = pBits->storageSize;
+  memset(pBits->storage, 0, count * sizeof(u4));
 }
 
 /*
@@ -409,31 +408,31 @@
  */
 bool oatSetBit(CompilationUnit* cUnit, ArenaBitVector* pBits, unsigned int num)
 {
-    if (num >= pBits->storageSize * sizeof(u4) * 8) {
-        if (!pBits->expandable) {
-            LOG(FATAL) << "Can't expand";
-        }
-
-        /* Round up to word boundaries for "num+1" bits */
-        unsigned int newSize = (num + 1 + 31) >> 5;
-        DCHECK_GT(newSize, pBits->storageSize);
-        u4 *newStorage = (u4*)oatNew(cUnit, newSize * sizeof(u4), false,
-                                     kAllocGrowableBitMap);
-        memcpy(newStorage, pBits->storage, pBits->storageSize * sizeof(u4));
-        memset(&newStorage[pBits->storageSize], 0,
-               (newSize - pBits->storageSize) * sizeof(u4));
-#ifdef WITH_MEMSTATS
-        cUnit->mstats->bitMapWasted[pBits->kind] +=
-            pBits->storageSize * sizeof(u4);
-        cUnit->mstats->bitMapSizes[pBits->kind] += newSize * sizeof(u4);
-        cUnit->mstats->bitMapGrows[pBits->kind]++;
-#endif
-        pBits->storage = newStorage;
-        pBits->storageSize = newSize;
+  if (num >= pBits->storageSize * sizeof(u4) * 8) {
+    if (!pBits->expandable) {
+      LOG(FATAL) << "Can't expand";
     }
 
-    pBits->storage[num >> 5] |= checkMasks[num & 0x1f];
-    return true;
+    /* Round up to word boundaries for "num+1" bits */
+    unsigned int newSize = (num + 1 + 31) >> 5;
+    DCHECK_GT(newSize, pBits->storageSize);
+    u4 *newStorage = (u4*)oatNew(cUnit, newSize * sizeof(u4), false,
+                                 kAllocGrowableBitMap);
+    memcpy(newStorage, pBits->storage, pBits->storageSize * sizeof(u4));
+    memset(&newStorage[pBits->storageSize], 0,
+           (newSize - pBits->storageSize) * sizeof(u4));
+#ifdef WITH_MEMSTATS
+    cUnit->mstats->bitMapWasted[pBits->kind] +=
+        pBits->storageSize * sizeof(u4);
+    cUnit->mstats->bitMapSizes[pBits->kind] += newSize * sizeof(u4);
+    cUnit->mstats->bitMapGrows[pBits->kind]++;
+#endif
+    pBits->storage = newStorage;
+    pBits->storageSize = newSize;
+  }
+
+  pBits->storage[num >> 5] |= checkMasks[num & 0x1f];
+  return true;
 }
 
 /*
@@ -446,12 +445,12 @@
  */
 bool oatClearBit(ArenaBitVector* pBits, unsigned int num)
 {
-    if (num >= pBits->storageSize * sizeof(u4) * 8) {
-        LOG(FATAL) << "Attempt to clear a bit not set in the vector yet";;
-    }
+  if (num >= pBits->storageSize * sizeof(u4) * 8) {
+    LOG(FATAL) << "Attempt to clear a bit not set in the vector yet";;
+  }
 
-    pBits->storage[num >> 5] &= ~checkMasks[num & 0x1f];
-    return true;
+  pBits->storage[num >> 5] &= ~checkMasks[num & 0x1f];
+  return true;
 }
 
 /*
@@ -459,50 +458,49 @@
  */
 void oatMarkAllBits(ArenaBitVector* pBits, bool set)
 {
-    int value = set ? -1 : 0;
-    memset(pBits->storage, value, pBits->storageSize * (int)sizeof(u4));
+  int value = set ? -1 : 0;
+  memset(pBits->storage, value, pBits->storageSize * (int)sizeof(u4));
 }
 
 void oatDebugBitVector(char* msg, const ArenaBitVector* bv, int length)
 {
-    int i;
+  int i;
 
-    LOG(INFO) <<  msg;
-    for (i = 0; i < length; i++) {
-        if (oatIsBitSet(bv, i)) {
-            LOG(INFO) << "    Bit " << i << " is set";
-        }
+  LOG(INFO) <<  msg;
+  for (i = 0; i < length; i++) {
+    if (oatIsBitSet(bv, i)) {
+      LOG(INFO) << "    Bit " << i << " is set";
     }
+  }
 }
 
 void oatAbort(CompilationUnit* cUnit)
 {
-    LOG(FATAL) << "Compiler aborting";
+  LOG(FATAL) << "Compiler aborting";
 }
 
 void oatDumpBlockBitVector(const GrowableList* blocks, char* msg,
-                           const ArenaBitVector* bv, int length)
+                         const ArenaBitVector* bv, int length)
 {
-    int i;
+  int i;
 
-    LOG(INFO) <<  msg;
-    for (i = 0; i < length; i++) {
-        if (oatIsBitSet(bv, i)) {
-            BasicBlock *bb =
-                (BasicBlock *) oatGrowableListGetElement(blocks, i);
-            char blockName[BLOCK_NAME_LEN];
-            oatGetBlockName(bb, blockName);
-            LOG(INFO) << "Bit " << i << " / " << blockName << " is set";
-        }
+  LOG(INFO) <<  msg;
+  for (i = 0; i < length; i++) {
+    if (oatIsBitSet(bv, i)) {
+      BasicBlock *bb = (BasicBlock *) oatGrowableListGetElement(blocks, i);
+      char blockName[BLOCK_NAME_LEN];
+      oatGetBlockName(bb, blockName);
+      LOG(INFO) << "Bit " << i << " / " << blockName << " is set";
     }
+  }
 }
 /* Initialize the iterator structure */
 void oatBitVectorIteratorInit(ArenaBitVector* pBits,
-                              ArenaBitVectorIterator* iterator)
+                            ArenaBitVectorIterator* iterator)
 {
-    iterator->pBits = pBits;
-    iterator->bitSize = pBits->storageSize * sizeof(u4) * 8;
-    iterator->idx = 0;
+  iterator->pBits = pBits;
+  iterator->bitSize = pBits->storageSize * sizeof(u4) * 8;
+  iterator->idx = 0;
 }
 
 /*
@@ -510,10 +508,10 @@
  */
 void checkSizes(const ArenaBitVector* bv1, const ArenaBitVector* bv2)
 {
-    if (bv1->storageSize != bv2->storageSize) {
-        LOG(FATAL) << "Mismatched vector sizes (" << bv1->storageSize <<
-            ", " << bv2->storageSize << ")";
-    }
+  if (bv1->storageSize != bv2->storageSize) {
+    LOG(FATAL) << "Mismatched vector sizes (" << bv1->storageSize
+               << ", " << bv2->storageSize << ")";
+  }
 }
 
 /*
@@ -522,10 +520,10 @@
  */
 void oatCopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src)
 {
-    /* if dest is expandable and < src, we could expand dest to match */
-    checkSizes(dest, src);
+  /* if dest is expandable and < src, we could expand dest to match */
+  checkSizes(dest, src);
 
-    memcpy(dest->storage, src->storage, sizeof(u4) * dest->storageSize);
+  memcpy(dest->storage, src->storage, sizeof(u4) * dest->storageSize);
 }
 
 /*
@@ -533,72 +531,72 @@
  */
 
 bool oatIntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
-                            const ArenaBitVector* src2)
+                          const ArenaBitVector* src2)
 {
-    DCHECK(src1 != NULL);
-    DCHECK(src2 != NULL);
-    if (dest->storageSize != src1->storageSize ||
-        dest->storageSize != src2->storageSize ||
-        dest->expandable != src1->expandable ||
-        dest->expandable != src2->expandable)
-        return false;
+  DCHECK(src1 != NULL);
+  DCHECK(src2 != NULL);
+  if (dest->storageSize != src1->storageSize ||
+      dest->storageSize != src2->storageSize ||
+      dest->expandable != src1->expandable ||
+      dest->expandable != src2->expandable)
+    return false;
 
-    unsigned int idx;
-    for (idx = 0; idx < dest->storageSize; idx++) {
-        dest->storage[idx] = src1->storage[idx] & src2->storage[idx];
-    }
-    return true;
+  unsigned int idx;
+  for (idx = 0; idx < dest->storageSize; idx++) {
+    dest->storage[idx] = src1->storage[idx] & src2->storage[idx];
+  }
+  return true;
 }
 
 /*
  * Unify two bit vectors and store the result to the dest vector.
  */
 bool oatUnifyBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
-                        const ArenaBitVector* src2)
+                      const ArenaBitVector* src2)
 {
-    DCHECK(src1 != NULL);
-    DCHECK(src2 != NULL);
-    if (dest->storageSize != src1->storageSize ||
-        dest->storageSize != src2->storageSize ||
-        dest->expandable != src1->expandable ||
-        dest->expandable != src2->expandable)
-        return false;
+  DCHECK(src1 != NULL);
+  DCHECK(src2 != NULL);
+  if (dest->storageSize != src1->storageSize ||
+      dest->storageSize != src2->storageSize ||
+      dest->expandable != src1->expandable ||
+      dest->expandable != src2->expandable)
+    return false;
 
-    unsigned int idx;
-    for (idx = 0; idx < dest->storageSize; idx++) {
-        dest->storage[idx] = src1->storage[idx] | src2->storage[idx];
-    }
-    return true;
+  unsigned int idx;
+  for (idx = 0; idx < dest->storageSize; idx++) {
+    dest->storage[idx] = src1->storage[idx] | src2->storage[idx];
+  }
+  return true;
 }
 
 /*
  * Return true if any bits collide.  Vectors must be same size.
  */
 bool oatTestBitVectors(const ArenaBitVector* src1,
-                       const ArenaBitVector* src2)
+                     const ArenaBitVector* src2)
 {
-    DCHECK_EQ(src1->storageSize, src2->storageSize);
-    for (uint32_t idx = 0; idx < src1->storageSize; idx++) {
-        if (src1->storage[idx] & src2->storage[idx]) return true;
-    }
-    return false;
+  DCHECK_EQ(src1->storageSize, src2->storageSize);
+  for (uint32_t idx = 0; idx < src1->storageSize; idx++) {
+    if (src1->storage[idx] & src2->storage[idx]) return true;
+  }
+  return false;
 }
 
 /*
  * Compare two bit vectors and return true if difference is seen.
  */
 bool oatCompareBitVectors(const ArenaBitVector* src1,
-                          const ArenaBitVector* src2)
+                        const ArenaBitVector* src2)
 {
-    if (src1->storageSize != src2->storageSize ||
-        src1->expandable != src2->expandable)
-        return true;
+  if (src1->storageSize != src2->storageSize ||
+      src1->expandable != src2->expandable)
+    return true;
 
-    unsigned int idx;
-    for (idx = 0; idx < src1->storageSize; idx++) {
-        if (src1->storage[idx] != src2->storage[idx]) return true;
-    }
-    return false;
+  unsigned int idx;
+  for (idx = 0; idx < src1->storageSize; idx++) {
+    if (src1->storage[idx] != src2->storage[idx]) return true;
+  }
+  return false;
 }
 
 /*
@@ -606,65 +604,65 @@
  */
 int oatCountSetBits(const ArenaBitVector* pBits)
 {
-    unsigned int word;
-    unsigned int count = 0;
+  unsigned int word;
+  unsigned int count = 0;
 
-    for (word = 0; word < pBits->storageSize; word++) {
-        u4 val = pBits->storage[word];
+  for (word = 0; word < pBits->storageSize; word++) {
+    u4 val = pBits->storage[word];
 
-        if (val != 0) {
-            if (val == 0xffffffff) {
-                count += 32;
-            } else {
-                /* count the number of '1' bits */
-                while (val != 0) {
-                    val &= val - 1;
-                    count++;
-                }
-            }
+    if (val != 0) {
+      if (val == 0xffffffff) {
+        count += 32;
+      } else {
+        /* count the number of '1' bits */
+        while (val != 0) {
+          val &= val - 1;
+          count++;
         }
+      }
     }
+  }
 
-    return count;
+  return count;
 }
 
 /* Return the next position set to 1. -1 means end-of-element reached */
 int oatBitVectorIteratorNext(ArenaBitVectorIterator* iterator)
 {
-    ArenaBitVector* pBits = iterator->pBits;
-    u4 bitIndex = iterator->idx;
-    u4 bitSize = iterator->bitSize;
+  ArenaBitVector* pBits = iterator->pBits;
+  u4 bitIndex = iterator->idx;
+  u4 bitSize = iterator->bitSize;
 
-    DCHECK_EQ(bitSize, pBits->storageSize * sizeof(u4) * 8);
+  DCHECK_EQ(bitSize, pBits->storageSize * sizeof(u4) * 8);
 
-    if (bitIndex >= bitSize) return -1;
+  if (bitIndex >= bitSize) return -1;
 
-    u4 wordIndex = bitIndex >> 5;
-    u4 endWordIndex = bitSize >> 5;
-    u4* storage = pBits->storage;
-    u4 word = storage[wordIndex++];
+  u4 wordIndex = bitIndex >> 5;
+  u4 endWordIndex = bitSize >> 5;
+  u4* storage = pBits->storage;
+  u4 word = storage[wordIndex++];
 
-    // Mask out any bits in the first word we've already considered
-    word &= ~((1 << (bitIndex & 0x1f))-1);
+  // Mask out any bits in the first word we've already considered
+  word &= ~((1 << (bitIndex & 0x1f))-1);
 
-    for (; wordIndex <= endWordIndex;) {
-        u4 bitPos = bitIndex & 0x1f;
-        if (word == 0) {
-            bitIndex += (32 - bitPos);
-            word = storage[wordIndex++];
-            continue;
-        }
-        for (; bitPos < 32; bitPos++) {
-            if (word & (1 << bitPos)) {
-                iterator->idx = bitIndex + 1;
-                return bitIndex;
-            }
-            bitIndex++;
-        }
-        word = storage[wordIndex++];
+  for (; wordIndex <= endWordIndex;) {
+    u4 bitPos = bitIndex & 0x1f;
+    if (word == 0) {
+      bitIndex += (32 - bitPos);
+      word = storage[wordIndex++];
+      continue;
     }
-    iterator->idx = iterator->bitSize;
-    return -1;
+    for (; bitPos < 32; bitPos++) {
+      if (word & (1 << bitPos)) {
+        iterator->idx = bitIndex + 1;
+        return bitIndex;
+      }
+      bitIndex++;
+    }
+    word = storage[wordIndex++];
+  }
+  iterator->idx = iterator->bitSize;
+  return -1;
 }
 
 /*
@@ -674,42 +672,42 @@
  */
 void oatSetInitialBits(ArenaBitVector* pBits, unsigned int numBits)
 {
-    unsigned int idx;
-    DCHECK_LE(((numBits + 31) >> 5), pBits->storageSize);
-    for (idx = 0; idx < (numBits >> 5); idx++) {
-        pBits->storage[idx] = -1;
-    }
-    unsigned int remNumBits = numBits & 0x1f;
-    if (remNumBits) {
-        pBits->storage[idx] = (1 << remNumBits) - 1;
-    }
+  unsigned int idx;
+  DCHECK_LE(((numBits + 31) >> 5), pBits->storageSize);
+  for (idx = 0; idx < (numBits >> 5); idx++) {
+    pBits->storage[idx] = -1;
+  }
+  unsigned int remNumBits = numBits & 0x1f;
+  if (remNumBits) {
+    pBits->storage[idx] = (1 << remNumBits) - 1;
+  }
 }
 
 void oatGetBlockName(BasicBlock* bb, char* name)
 {
-    switch (bb->blockType) {
-        case kEntryBlock:
-            snprintf(name, BLOCK_NAME_LEN, "entry");
-            break;
-        case kExitBlock:
-            snprintf(name, BLOCK_NAME_LEN, "exit");
-            break;
-        case kDalvikByteCode:
-            snprintf(name, BLOCK_NAME_LEN, "block%04x", bb->startOffset);
-            break;
-        case kExceptionHandling:
-            snprintf(name, BLOCK_NAME_LEN, "exception%04x", bb->startOffset);
-            break;
-        default:
-            snprintf(name, BLOCK_NAME_LEN, "??");
-            break;
-    }
+  switch (bb->blockType) {
+    case kEntryBlock:
+      snprintf(name, BLOCK_NAME_LEN, "entry");
+      break;
+    case kExitBlock:
+      snprintf(name, BLOCK_NAME_LEN, "exit");
+      break;
+    case kDalvikByteCode:
+      snprintf(name, BLOCK_NAME_LEN, "block%04x", bb->startOffset);
+      break;
+    case kExceptionHandling:
+      snprintf(name, BLOCK_NAME_LEN, "exception%04x", bb->startOffset);
+      break;
+    default:
+      snprintf(name, BLOCK_NAME_LEN, "??");
+      break;
+  }
 }
 
 const char* oatGetShortyFromTargetIdx(CompilationUnit *cUnit, int targetIdx)
 {
-    const DexFile::MethodId& methodId = cUnit->dex_file->GetMethodId(targetIdx);
-    return cUnit->dex_file->GetShorty(methodId.proto_idx_);
+  const DexFile::MethodId& methodId = cUnit->dex_file->GetMethodId(targetIdx);
+  return cUnit->dex_file->GetShorty(methodId.proto_idx_);
 }
 
 }  // namespace art
diff --git a/src/compiler/codegen/CodegenFactory.cc b/src/compiler/codegen/CodegenFactory.cc
index 1b64af2..3a7cb82 100644
--- a/src/compiler/codegen/CodegenFactory.cc
+++ b/src/compiler/codegen/CodegenFactory.cc
@@ -33,25 +33,25 @@
  */
 LIR* loadConstant(CompilationUnit* cUnit, int rDest, int value)
 {
-    if (oatIsTemp(cUnit, rDest)) {
-        oatClobber(cUnit, rDest);
-        oatMarkInUse(cUnit, rDest);
-    }
-    return loadConstantNoClobber(cUnit, rDest, value);
+  if (oatIsTemp(cUnit, rDest)) {
+    oatClobber(cUnit, rDest);
+    oatMarkInUse(cUnit, rDest);
+  }
+  return loadConstantNoClobber(cUnit, rDest, value);
 }
 
 /* Load a word at base + displacement.  Displacement must be word multiple */
 LIR* loadWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
                   int rDest)
 {
-    return loadBaseDisp(cUnit, NULL, rBase, displacement, rDest, kWord,
-                        INVALID_SREG);
+  return loadBaseDisp(cUnit, NULL, rBase, displacement, rDest, kWord,
+                      INVALID_SREG);
 }
 
 LIR* storeWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
                    int rSrc)
 {
-    return storeBaseDisp(cUnit, rBase, displacement, rSrc, kWord);
+  return storeBaseDisp(cUnit, rBase, displacement, rSrc, kWord);
 }
 
 /*
@@ -61,14 +61,14 @@
  */
 void loadValueDirect(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
 {
-    rlSrc = oatUpdateLoc(cUnit, rlSrc);
-    if (rlSrc.location == kLocPhysReg) {
-        opRegCopy(cUnit, rDest, rlSrc.lowReg);
-    } else {
-        DCHECK((rlSrc.location == kLocDalvikFrame) ||
-               (rlSrc.location == kLocCompilerTemp));
-        loadWordDisp(cUnit, rSP, oatSRegOffset(cUnit, rlSrc.sRegLow), rDest);
-    }
+  rlSrc = oatUpdateLoc(cUnit, rlSrc);
+  if (rlSrc.location == kLocPhysReg) {
+    opRegCopy(cUnit, rDest, rlSrc.lowReg);
+  } else {
+    DCHECK((rlSrc.location == kLocDalvikFrame) ||
+           (rlSrc.location == kLocCompilerTemp));
+    loadWordDisp(cUnit, rSP, oatSRegOffset(cUnit, rlSrc.sRegLow), rDest);
+  }
 }
 
 /*
@@ -78,9 +78,9 @@
  */
 void loadValueDirectFixed(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
 {
-    oatClobber(cUnit, rDest);
-    oatMarkInUse(cUnit, rDest);
-    loadValueDirect(cUnit, rlSrc, rDest);
+  oatClobber(cUnit, rDest);
+  oatMarkInUse(cUnit, rDest);
+  loadValueDirect(cUnit, rlSrc, rDest);
 }
 
 /*
@@ -89,18 +89,17 @@
  * register liveness.  That is the responsibility of the caller.
  */
 void loadValueDirectWide(CompilationUnit* cUnit, RegLocation rlSrc, int regLo,
-                         int regHi)
+             int regHi)
 {
-    rlSrc = oatUpdateLocWide(cUnit, rlSrc);
-    if (rlSrc.location == kLocPhysReg) {
-        opRegCopyWide(cUnit, regLo, regHi, rlSrc.lowReg, rlSrc.highReg);
-    } else {
-        DCHECK((rlSrc.location == kLocDalvikFrame) ||
-               (rlSrc.location == kLocCompilerTemp));
-        loadBaseDispWide(cUnit, NULL, rSP,
-                         oatSRegOffset(cUnit, rlSrc.sRegLow),
-                         regLo, regHi, INVALID_SREG);
-    }
+  rlSrc = oatUpdateLocWide(cUnit, rlSrc);
+  if (rlSrc.location == kLocPhysReg) {
+    opRegCopyWide(cUnit, regLo, regHi, rlSrc.lowReg, rlSrc.highReg);
+  } else {
+    DCHECK((rlSrc.location == kLocDalvikFrame) ||
+           (rlSrc.location == kLocCompilerTemp));
+    loadBaseDispWide(cUnit, NULL, rSP, oatSRegOffset(cUnit, rlSrc.sRegLow),
+                     regLo, regHi, INVALID_SREG);
+  }
 }
 
 /*
@@ -111,161 +110,159 @@
 void loadValueDirectWideFixed(CompilationUnit* cUnit, RegLocation rlSrc,
                               int regLo, int regHi)
 {
-    oatClobber(cUnit, regLo);
-    oatClobber(cUnit, regHi);
-    oatMarkInUse(cUnit, regLo);
-    oatMarkInUse(cUnit, regHi);
-    loadValueDirectWide(cUnit, rlSrc, regLo, regHi);
+  oatClobber(cUnit, regLo);
+  oatClobber(cUnit, regHi);
+  oatMarkInUse(cUnit, regLo);
+  oatMarkInUse(cUnit, regHi);
+  loadValueDirectWide(cUnit, rlSrc, regLo, regHi);
 }
 
 RegLocation loadValue(CompilationUnit* cUnit, RegLocation rlSrc,
                       RegisterClass opKind)
 {
-    rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
-    if (rlSrc.location != kLocPhysReg) {
-        DCHECK((rlSrc.location == kLocDalvikFrame) ||
-               (rlSrc.location == kLocCompilerTemp));
-        loadValueDirect(cUnit, rlSrc, rlSrc.lowReg);
-        rlSrc.location = kLocPhysReg;
-        oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
-    }
-    return rlSrc;
+  rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
+  if (rlSrc.location != kLocPhysReg) {
+    DCHECK((rlSrc.location == kLocDalvikFrame) ||
+           (rlSrc.location == kLocCompilerTemp));
+    loadValueDirect(cUnit, rlSrc, rlSrc.lowReg);
+    rlSrc.location = kLocPhysReg;
+    oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
+  }
+  return rlSrc;
 }
 
 void storeValue(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
 {
 #ifndef NDEBUG
-    /*
-     * Sanity checking - should never try to store to the same
-     * ssa name during the compilation of a single instruction
-     * without an intervening oatClobberSReg().
-     */
-    DCHECK((cUnit->liveSReg == INVALID_SREG) ||
-           (rlDest.sRegLow != cUnit->liveSReg));
-    cUnit->liveSReg = rlDest.sRegLow;
+  /*
+   * Sanity checking - should never try to store to the same
+   * ssa name during the compilation of a single instruction
+   * without an intervening oatClobberSReg().
+   */
+  DCHECK((cUnit->liveSReg == INVALID_SREG) ||
+         (rlDest.sRegLow != cUnit->liveSReg));
+  cUnit->liveSReg = rlDest.sRegLow;
 #endif
-    LIR* defStart;
-    LIR* defEnd;
-    DCHECK(!rlDest.wide);
-    DCHECK(!rlSrc.wide);
-    rlSrc = oatUpdateLoc(cUnit, rlSrc);
-    rlDest = oatUpdateLoc(cUnit, rlDest);
-    if (rlSrc.location == kLocPhysReg) {
-        if (oatIsLive(cUnit, rlSrc.lowReg) ||
-            oatIsPromoted(cUnit, rlSrc.lowReg) ||
-            (rlDest.location == kLocPhysReg)) {
-            // Src is live/promoted or Dest has assigned reg.
-            rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
-            opRegCopy(cUnit, rlDest.lowReg, rlSrc.lowReg);
-        } else {
-            // Just re-assign the registers.  Dest gets Src's regs
-            rlDest.lowReg = rlSrc.lowReg;
-            oatClobber(cUnit, rlSrc.lowReg);
-        }
+  LIR* defStart;
+  LIR* defEnd;
+  DCHECK(!rlDest.wide);
+  DCHECK(!rlSrc.wide);
+  rlSrc = oatUpdateLoc(cUnit, rlSrc);
+  rlDest = oatUpdateLoc(cUnit, rlDest);
+  if (rlSrc.location == kLocPhysReg) {
+    if (oatIsLive(cUnit, rlSrc.lowReg) ||
+      oatIsPromoted(cUnit, rlSrc.lowReg) ||
+      (rlDest.location == kLocPhysReg)) {
+      // Src is live/promoted or Dest has assigned reg.
+      rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
+      opRegCopy(cUnit, rlDest.lowReg, rlSrc.lowReg);
     } else {
-        // Load Src either into promoted Dest or temps allocated for Dest
-        rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
-        loadValueDirect(cUnit, rlSrc, rlDest.lowReg);
+      // Just re-assign the registers.  Dest gets Src's regs
+      rlDest.lowReg = rlSrc.lowReg;
+      oatClobber(cUnit, rlSrc.lowReg);
     }
+  } else {
+    // Load Src either into promoted Dest or temps allocated for Dest
+    rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
+    loadValueDirect(cUnit, rlSrc, rlDest.lowReg);
+  }
 
-    // Dest is now live and dirty (until/if we flush it to home location)
-    oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
-    oatMarkDirty(cUnit, rlDest);
+  // Dest is now live and dirty (until/if we flush it to home location)
+  oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
+  oatMarkDirty(cUnit, rlDest);
 
 
-    oatResetDefLoc(cUnit, rlDest);
-    if (oatIsDirty(cUnit, rlDest.lowReg) &&
-        oatLiveOut(cUnit, rlDest.sRegLow)) {
-        defStart = (LIR* )cUnit->lastLIRInsn;
-        storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, rlDest.sRegLow),
-                      rlDest.lowReg, kWord);
-        oatMarkClean(cUnit, rlDest);
-        defEnd = (LIR* )cUnit->lastLIRInsn;
-        oatMarkDef(cUnit, rlDest, defStart, defEnd);
-    }
+  oatResetDefLoc(cUnit, rlDest);
+  if (oatIsDirty(cUnit, rlDest.lowReg) &&
+      oatLiveOut(cUnit, rlDest.sRegLow)) {
+    defStart = (LIR* )cUnit->lastLIRInsn;
+    storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, rlDest.sRegLow),
+                  rlDest.lowReg, kWord);
+    oatMarkClean(cUnit, rlDest);
+    defEnd = (LIR* )cUnit->lastLIRInsn;
+    oatMarkDef(cUnit, rlDest, defStart, defEnd);
+  }
 }
 
 RegLocation loadValueWide(CompilationUnit* cUnit, RegLocation rlSrc,
-                          RegisterClass opKind)
+              RegisterClass opKind)
 {
-    DCHECK(rlSrc.wide);
-    rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
-    if (rlSrc.location != kLocPhysReg) {
-        DCHECK((rlSrc.location == kLocDalvikFrame) ||
-               (rlSrc.location == kLocCompilerTemp));
-        loadValueDirectWide(cUnit, rlSrc, rlSrc.lowReg, rlSrc.highReg);
-        rlSrc.location = kLocPhysReg;
-        oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
-        oatMarkLive(cUnit, rlSrc.highReg,
-                            oatSRegHi(rlSrc.sRegLow));
-    }
-    return rlSrc;
+  DCHECK(rlSrc.wide);
+  rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
+  if (rlSrc.location != kLocPhysReg) {
+    DCHECK((rlSrc.location == kLocDalvikFrame) ||
+        (rlSrc.location == kLocCompilerTemp));
+    loadValueDirectWide(cUnit, rlSrc, rlSrc.lowReg, rlSrc.highReg);
+    rlSrc.location = kLocPhysReg;
+    oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
+    oatMarkLive(cUnit, rlSrc.highReg,
+                oatSRegHi(rlSrc.sRegLow));
+  }
+  return rlSrc;
 }
 
 void storeValueWide(CompilationUnit* cUnit, RegLocation rlDest,
-                    RegLocation rlSrc)
+          RegLocation rlSrc)
 {
 #ifndef NDEBUG
-    /*
-     * Sanity checking - should never try to store to the same
-     * ssa name during the compilation of a single instruction
-     * without an intervening oatClobberSReg().
-     */
-    DCHECK((cUnit->liveSReg == INVALID_SREG) ||
-           (rlDest.sRegLow != cUnit->liveSReg));
-    cUnit->liveSReg = rlDest.sRegLow;
+  /*
+   * Sanity checking - should never try to store to the same
+   * ssa name during the compilation of a single instruction
+   * without an intervening oatClobberSReg().
+   */
+  DCHECK((cUnit->liveSReg == INVALID_SREG) ||
+      (rlDest.sRegLow != cUnit->liveSReg));
+  cUnit->liveSReg = rlDest.sRegLow;
 #endif
-    LIR* defStart;
-    LIR* defEnd;
-    DCHECK_EQ(FPREG(rlSrc.lowReg), FPREG(rlSrc.highReg));
-    DCHECK(rlDest.wide);
-    DCHECK(rlSrc.wide);
-    if (rlSrc.location == kLocPhysReg) {
-        if (oatIsLive(cUnit, rlSrc.lowReg) ||
-            oatIsLive(cUnit, rlSrc.highReg) ||
-            oatIsPromoted(cUnit, rlSrc.lowReg) ||
-            oatIsPromoted(cUnit, rlSrc.highReg) ||
-            (rlDest.location == kLocPhysReg)) {
-            // Src is live or promoted or Dest has assigned reg.
-            rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
-            opRegCopyWide(cUnit, rlDest.lowReg, rlDest.highReg,
-                           rlSrc.lowReg, rlSrc.highReg);
-        } else {
-            // Just re-assign the registers.  Dest gets Src's regs
-            rlDest.lowReg = rlSrc.lowReg;
-            rlDest.highReg = rlSrc.highReg;
-            oatClobber(cUnit, rlSrc.lowReg);
-            oatClobber(cUnit, rlSrc.highReg);
-        }
+  LIR* defStart;
+  LIR* defEnd;
+  DCHECK_EQ(FPREG(rlSrc.lowReg), FPREG(rlSrc.highReg));
+  DCHECK(rlDest.wide);
+  DCHECK(rlSrc.wide);
+  if (rlSrc.location == kLocPhysReg) {
+    if (oatIsLive(cUnit, rlSrc.lowReg) ||
+        oatIsLive(cUnit, rlSrc.highReg) ||
+        oatIsPromoted(cUnit, rlSrc.lowReg) ||
+        oatIsPromoted(cUnit, rlSrc.highReg) ||
+        (rlDest.location == kLocPhysReg)) {
+      // Src is live or promoted or Dest has assigned reg.
+      rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
+      opRegCopyWide(cUnit, rlDest.lowReg, rlDest.highReg,
+                    rlSrc.lowReg, rlSrc.highReg);
     } else {
-        // Load Src either into promoted Dest or temps allocated for Dest
-        rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
-        loadValueDirectWide(cUnit, rlSrc, rlDest.lowReg,
-                            rlDest.highReg);
+      // Just re-assign the registers.  Dest gets Src's regs
+      rlDest.lowReg = rlSrc.lowReg;
+      rlDest.highReg = rlSrc.highReg;
+      oatClobber(cUnit, rlSrc.lowReg);
+      oatClobber(cUnit, rlSrc.highReg);
     }
+  } else {
+    // Load Src either into promoted Dest or temps allocated for Dest
+    rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
+    loadValueDirectWide(cUnit, rlSrc, rlDest.lowReg, rlDest.highReg);
+  }
 
-    // Dest is now live and dirty (until/if we flush it to home location)
-    oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
-    oatMarkLive(cUnit, rlDest.highReg,
-                        oatSRegHi(rlDest.sRegLow));
-    oatMarkDirty(cUnit, rlDest);
-    oatMarkPair(cUnit, rlDest.lowReg, rlDest.highReg);
+  // Dest is now live and dirty (until/if we flush it to home location)
+  oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
+  oatMarkLive(cUnit, rlDest.highReg, oatSRegHi(rlDest.sRegLow));
+  oatMarkDirty(cUnit, rlDest);
+  oatMarkPair(cUnit, rlDest.lowReg, rlDest.highReg);
 
 
-    oatResetDefLocWide(cUnit, rlDest);
-    if ((oatIsDirty(cUnit, rlDest.lowReg) ||
-        oatIsDirty(cUnit, rlDest.highReg)) &&
-        (oatLiveOut(cUnit, rlDest.sRegLow) ||
-        oatLiveOut(cUnit, oatSRegHi(rlDest.sRegLow)))) {
-        defStart = (LIR*)cUnit->lastLIRInsn;
-        DCHECK_EQ((SRegToVReg(cUnit, rlDest.sRegLow)+1),
-                   SRegToVReg(cUnit, oatSRegHi(rlDest.sRegLow)));
-        storeBaseDispWide(cUnit, rSP, oatSRegOffset(cUnit, rlDest.sRegLow),
-                          rlDest.lowReg, rlDest.highReg);
-        oatMarkClean(cUnit, rlDest);
-        defEnd = (LIR*)cUnit->lastLIRInsn;
-        oatMarkDefWide(cUnit, rlDest, defStart, defEnd);
-    }
+  oatResetDefLocWide(cUnit, rlDest);
+  if ((oatIsDirty(cUnit, rlDest.lowReg) ||
+      oatIsDirty(cUnit, rlDest.highReg)) &&
+      (oatLiveOut(cUnit, rlDest.sRegLow) ||
+      oatLiveOut(cUnit, oatSRegHi(rlDest.sRegLow)))) {
+    defStart = (LIR*)cUnit->lastLIRInsn;
+    DCHECK_EQ((SRegToVReg(cUnit, rlDest.sRegLow)+1),
+              SRegToVReg(cUnit, oatSRegHi(rlDest.sRegLow)));
+    storeBaseDispWide(cUnit, rSP, oatSRegOffset(cUnit, rlDest.sRegLow),
+                      rlDest.lowReg, rlDest.highReg);
+    oatMarkClean(cUnit, rlDest);
+    defEnd = (LIR*)cUnit->lastLIRInsn;
+    oatMarkDefWide(cUnit, rlDest, defStart, defEnd);
+  }
 }
 
 /*
@@ -273,39 +270,39 @@
  */
 void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
 {
-    int regCardBase = oatAllocTemp(cUnit);
-    int regCardNo = oatAllocTemp(cUnit);
-    LIR* branchOver = opCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
+  int regCardBase = oatAllocTemp(cUnit);
+  int regCardNo = oatAllocTemp(cUnit);
+  LIR* branchOver = opCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
 #if !defined(TARGET_X86)
-    loadWordDisp(cUnit, rSELF, Thread::CardTableOffset().Int32Value(),
-                 regCardBase);
+  loadWordDisp(cUnit, rSELF, Thread::CardTableOffset().Int32Value(),
+               regCardBase);
 #else
-    newLIR2(cUnit, kX86Mov32RT, regCardBase,
-            Thread::CardTableOffset().Int32Value());
+  newLIR2(cUnit, kX86Mov32RT, regCardBase,
+          Thread::CardTableOffset().Int32Value());
 #endif
-    opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, GC_CARD_SHIFT);
-    storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
-                     kUnsignedByte);
-    LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
-    branchOver->target = (LIR*)target;
-    oatFreeTemp(cUnit, regCardBase);
-    oatFreeTemp(cUnit, regCardNo);
+  opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, GC_CARD_SHIFT);
+  storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
+                   kUnsignedByte);
+  LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+  branchOver->target = (LIR*)target;
+  oatFreeTemp(cUnit, regCardBase);
+  oatFreeTemp(cUnit, regCardNo);
 }
 
 /* Utilities to load the current Method* */
 void loadCurrMethodDirect(CompilationUnit *cUnit, int rTgt)
 {
-    loadValueDirectFixed(cUnit, cUnit->regLocation[cUnit->methodSReg], rTgt);
+  loadValueDirectFixed(cUnit, cUnit->regLocation[cUnit->methodSReg], rTgt);
 }
 
 RegLocation loadCurrMethod(CompilationUnit *cUnit)
 {
-    return loadValue(cUnit, cUnit->regLocation[cUnit->methodSReg], kCoreReg);
+  return loadValue(cUnit, cUnit->regLocation[cUnit->methodSReg], kCoreReg);
 }
 
 bool methodStarInReg(CompilationUnit* cUnit)
 {
-     return (cUnit->regLocation[cUnit->methodSReg].location == kLocPhysReg);
+   return (cUnit->regLocation[cUnit->methodSReg].location == kLocPhysReg);
 }
 
 
diff --git a/src/compiler/codegen/CodegenUtil.cc b/src/compiler/codegen/CodegenUtil.cc
index 777cf57..11982ba 100644
--- a/src/compiler/codegen/CodegenUtil.cc
+++ b/src/compiler/codegen/CodegenUtil.cc
@@ -18,36 +18,36 @@
 
 void setMemRefType(LIR* lir, bool isLoad, int memType)
 {
-    u8 *maskPtr;
-    u8 mask = ENCODE_MEM;;
-    DCHECK(EncodingMap[lir->opcode].flags & (IS_LOAD | IS_STORE));
-    if (isLoad) {
-        maskPtr = &lir->useMask;
-    } else {
-        maskPtr = &lir->defMask;
-    }
-    /* Clear out the memref flags */
-    *maskPtr &= ~mask;
-    /* ..and then add back the one we need */
-    switch (memType) {
-        case kLiteral:
-            DCHECK(isLoad);
-            *maskPtr |= ENCODE_LITERAL;
-            break;
-        case kDalvikReg:
-            *maskPtr |= ENCODE_DALVIK_REG;
-            break;
-        case kHeapRef:
-            *maskPtr |= ENCODE_HEAP_REF;
-            break;
-        case kMustNotAlias:
-            /* Currently only loads can be marked as kMustNotAlias */
-            DCHECK(!(EncodingMap[lir->opcode].flags & IS_STORE));
-            *maskPtr |= ENCODE_MUST_NOT_ALIAS;
-            break;
-        default:
-            LOG(FATAL) << "Oat: invalid memref kind - " << memType;
-    }
+  u8 *maskPtr;
+  u8 mask = ENCODE_MEM;;
+  DCHECK(EncodingMap[lir->opcode].flags & (IS_LOAD | IS_STORE));
+  if (isLoad) {
+    maskPtr = &lir->useMask;
+  } else {
+    maskPtr = &lir->defMask;
+  }
+  /* Clear out the memref flags */
+  *maskPtr &= ~mask;
+  /* ..and then add back the one we need */
+  switch (memType) {
+    case kLiteral:
+      DCHECK(isLoad);
+      *maskPtr |= ENCODE_LITERAL;
+      break;
+    case kDalvikReg:
+      *maskPtr |= ENCODE_DALVIK_REG;
+      break;
+    case kHeapRef:
+      *maskPtr |= ENCODE_HEAP_REF;
+      break;
+    case kMustNotAlias:
+      /* Currently only loads can be marked as kMustNotAlias */
+      DCHECK(!(EncodingMap[lir->opcode].flags & IS_STORE));
+      *maskPtr |= ENCODE_MUST_NOT_ALIAS;
+      break;
+    default:
+      LOG(FATAL) << "Oat: invalid memref kind - " << memType;
+  }
 }
 
 /*
@@ -55,16 +55,16 @@
  */
 void annotateDalvikRegAccess(LIR* lir, int regId, bool isLoad, bool is64bit)
 {
-    setMemRefType(lir, isLoad, kDalvikReg);
+  setMemRefType(lir, isLoad, kDalvikReg);
 
-    /*
-     * Store the Dalvik register id in aliasInfo. Mark the MSB if it is a 64-bit
-     * access.
-     */
-    lir->aliasInfo = regId;
-    if (is64bit) {
-        lir->aliasInfo |= 0x80000000;
-    }
+  /*
+   * Store the Dalvik register id in aliasInfo. Mark the MSB if it is a 64-bit
+   * access.
+   */
+  lir->aliasInfo = regId;
+  if (is64bit) {
+    lir->aliasInfo |= 0x80000000;
+  }
 }
 
 /*
@@ -72,19 +72,19 @@
  */
 inline u8 getRegMaskCommon(int reg)
 {
-    u8 seed;
-    int shift;
-    int regId = reg & 0x1f;
+  u8 seed;
+  int shift;
+  int regId = reg & 0x1f;
 
-    /*
-     * Each double register is equal to a pair of single-precision FP registers
-     */
-    seed = DOUBLEREG(reg) ? 3 : 1;
-    /* FP register starts at bit position 16 */
-    shift = FPREG(reg) ? kFPReg0 : 0;
-    /* Expand the double register id into single offset */
-    shift += regId;
-    return (seed << shift);
+  /*
+   * Each double register is equal to a pair of single-precision FP registers
+   */
+  seed = DOUBLEREG(reg) ? 3 : 1;
+  /* FP register starts at bit position 16 */
+  shift = FPREG(reg) ? kFPReg0 : 0;
+  /* Expand the double register id into single offset */
+  shift += regId;
+  return (seed << shift);
 }
 
 /*
@@ -92,7 +92,7 @@
  */
 inline void setupRegMask(u8* mask, int reg)
 {
-    *mask |= getRegMaskCommon(reg);
+  *mask |= getRegMaskCommon(reg);
 }
 
 /*
@@ -100,143 +100,143 @@
  */
 void setupResourceMasks(LIR* lir)
 {
-    int opcode = lir->opcode;
-    int flags;
+  int opcode = lir->opcode;
+  int flags;
 
-    if (opcode <= 0) {
-        lir->useMask = lir->defMask = 0;
-        return;
-    }
+  if (opcode <= 0) {
+    lir->useMask = lir->defMask = 0;
+    return;
+  }
 
-    flags = EncodingMap[lir->opcode].flags;
+  flags = EncodingMap[lir->opcode].flags;
 
-    if (flags & NEEDS_FIXUP) {
-        lir->flags.pcRelFixup = true;
-    }
+  if (flags & NEEDS_FIXUP) {
+    lir->flags.pcRelFixup = true;
+  }
 
-    /* Get the starting size of the instruction's template */
-    lir->flags.size = oatGetInsnSize(lir);
+  /* Get the starting size of the instruction's template */
+  lir->flags.size = oatGetInsnSize(lir);
 
-    /* Set up the mask for resources that are updated */
-    if (flags & (IS_LOAD | IS_STORE)) {
-        /* Default to heap - will catch specialized classes later */
-        setMemRefType(lir, flags & IS_LOAD, kHeapRef);
-    }
+  /* Set up the mask for resources that are updated */
+  if (flags & (IS_LOAD | IS_STORE)) {
+    /* Default to heap - will catch specialized classes later */
+    setMemRefType(lir, flags & IS_LOAD, kHeapRef);
+  }
 
-    /*
-     * Conservatively assume the branch here will call out a function that in
-     * turn will trash everything.
-     */
-    if (flags & IS_BRANCH) {
-        lir->defMask = lir->useMask = ENCODE_ALL;
-        return;
-    }
+  /*
+   * Conservatively assume the branch here will call out a function that in
+   * turn will trash everything.
+   */
+  if (flags & IS_BRANCH) {
+    lir->defMask = lir->useMask = ENCODE_ALL;
+    return;
+  }
 
-    if (flags & REG_DEF0) {
-        setupRegMask(&lir->defMask, lir->operands[0]);
-    }
+  if (flags & REG_DEF0) {
+    setupRegMask(&lir->defMask, lir->operands[0]);
+  }
 
-    if (flags & REG_DEF1) {
-        setupRegMask(&lir->defMask, lir->operands[1]);
-    }
+  if (flags & REG_DEF1) {
+    setupRegMask(&lir->defMask, lir->operands[1]);
+  }
 
-    if (flags & REG_DEF_SP) {
-        lir->defMask |= ENCODE_REG_SP;
-    }
+  if (flags & REG_DEF_SP) {
+    lir->defMask |= ENCODE_REG_SP;
+  }
 
 #if !defined(TARGET_X86)
-    if (flags & REG_DEF_LR) {
-        lir->defMask |= ENCODE_REG_LR;
-    }
+  if (flags & REG_DEF_LR) {
+    lir->defMask |= ENCODE_REG_LR;
+  }
 #endif
 
-    if (flags & REG_DEF_LIST0) {
-        lir->defMask |= ENCODE_REG_LIST(lir->operands[0]);
-    }
+  if (flags & REG_DEF_LIST0) {
+    lir->defMask |= ENCODE_REG_LIST(lir->operands[0]);
+  }
 
-    if (flags & REG_DEF_LIST1) {
-        lir->defMask |= ENCODE_REG_LIST(lir->operands[1]);
-    }
+  if (flags & REG_DEF_LIST1) {
+    lir->defMask |= ENCODE_REG_LIST(lir->operands[1]);
+  }
 
 #if defined(TARGET_ARM)
-    if (flags & REG_DEF_FPCS_LIST0) {
-        lir->defMask |= ENCODE_REG_FPCS_LIST(lir->operands[0]);
-    }
+  if (flags & REG_DEF_FPCS_LIST0) {
+    lir->defMask |= ENCODE_REG_FPCS_LIST(lir->operands[0]);
+  }
 
-    if (flags & REG_DEF_FPCS_LIST2) {
-        for (int i = 0; i < lir->operands[2]; i++) {
-            setupRegMask(&lir->defMask, lir->operands[1] + i);
-        }
+  if (flags & REG_DEF_FPCS_LIST2) {
+    for (int i = 0; i < lir->operands[2]; i++) {
+      setupRegMask(&lir->defMask, lir->operands[1] + i);
     }
+  }
 #endif
 
-    if (flags & SETS_CCODES) {
-        lir->defMask |= ENCODE_CCODE;
-    }
+  if (flags & SETS_CCODES) {
+    lir->defMask |= ENCODE_CCODE;
+  }
 
 #if defined(TARGET_ARM)
-    /* Conservatively treat the IT block */
-    if (flags & IS_IT) {
-        lir->defMask = ENCODE_ALL;
-    }
+  /* Conservatively treat the IT block */
+  if (flags & IS_IT) {
+    lir->defMask = ENCODE_ALL;
+  }
 #endif
 
-    if (flags & (REG_USE0 | REG_USE1 | REG_USE2 | REG_USE3)) {
-        int i;
+  if (flags & (REG_USE0 | REG_USE1 | REG_USE2 | REG_USE3)) {
+    int i;
 
-        for (i = 0; i < 4; i++) {
-            if (flags & (1 << (kRegUse0 + i))) {
-                setupRegMask(&lir->useMask, lir->operands[i]);
-            }
-        }
+    for (i = 0; i < 4; i++) {
+      if (flags & (1 << (kRegUse0 + i))) {
+        setupRegMask(&lir->useMask, lir->operands[i]);
+      }
     }
+  }
 
 #if defined(TARGET_ARM)
-    if (flags & REG_USE_PC) {
-        lir->useMask |= ENCODE_REG_PC;
-    }
+  if (flags & REG_USE_PC) {
+    lir->useMask |= ENCODE_REG_PC;
+  }
 #endif
 
-    if (flags & REG_USE_SP) {
-        lir->useMask |= ENCODE_REG_SP;
-    }
+  if (flags & REG_USE_SP) {
+    lir->useMask |= ENCODE_REG_SP;
+  }
 
-    if (flags & REG_USE_LIST0) {
-        lir->useMask |= ENCODE_REG_LIST(lir->operands[0]);
-    }
+  if (flags & REG_USE_LIST0) {
+    lir->useMask |= ENCODE_REG_LIST(lir->operands[0]);
+  }
 
-    if (flags & REG_USE_LIST1) {
-        lir->useMask |= ENCODE_REG_LIST(lir->operands[1]);
-    }
+  if (flags & REG_USE_LIST1) {
+    lir->useMask |= ENCODE_REG_LIST(lir->operands[1]);
+  }
 
 #if defined(TARGET_ARM)
-    if (flags & REG_USE_FPCS_LIST0) {
-        lir->useMask |= ENCODE_REG_FPCS_LIST(lir->operands[0]);
-    }
+  if (flags & REG_USE_FPCS_LIST0) {
+    lir->useMask |= ENCODE_REG_FPCS_LIST(lir->operands[0]);
+  }
 
-    if (flags & REG_USE_FPCS_LIST2) {
-        for (int i = 0; i < lir->operands[2]; i++) {
-            setupRegMask(&lir->useMask, lir->operands[1] + i);
-        }
+  if (flags & REG_USE_FPCS_LIST2) {
+    for (int i = 0; i < lir->operands[2]; i++) {
+      setupRegMask(&lir->useMask, lir->operands[1] + i);
     }
+  }
 #endif
 
-    if (flags & USES_CCODES) {
-        lir->useMask |= ENCODE_CCODE;
-    }
+  if (flags & USES_CCODES) {
+    lir->useMask |= ENCODE_CCODE;
+  }
 
 #if defined(TARGET_ARM)
-    /* Fixup for kThumbPush/lr and kThumbPop/pc */
-    if (opcode == kThumbPush || opcode == kThumbPop) {
-        u8 r8Mask = getRegMaskCommon(r8);
-        if ((opcode == kThumbPush) && (lir->useMask & r8Mask)) {
-            lir->useMask &= ~r8Mask;
-            lir->useMask |= ENCODE_REG_LR;
-        } else if ((opcode == kThumbPop) && (lir->defMask & r8Mask)) {
-            lir->defMask &= ~r8Mask;
-            lir->defMask |= ENCODE_REG_PC;
-        }
+  /* Fixup for kThumbPush/lr and kThumbPop/pc */
+  if (opcode == kThumbPush || opcode == kThumbPop) {
+    u8 r8Mask = getRegMaskCommon(r8);
+    if ((opcode == kThumbPush) && (lir->useMask & r8Mask)) {
+      lir->useMask &= ~r8Mask;
+      lir->useMask |= ENCODE_REG_LR;
+    } else if ((opcode == kThumbPop) && (lir->defMask & r8Mask)) {
+      lir->defMask &= ~r8Mask;
+      lir->defMask |= ENCODE_REG_PC;
     }
+  }
 #endif
 }
 
@@ -249,189 +249,196 @@
 /* Pretty-print a LIR instruction */
 void oatDumpLIRInsn(CompilationUnit* cUnit, LIR* arg, unsigned char* baseAddr)
 {
-    LIR* lir = (LIR*) arg;
-    int offset = lir->offset;
-    int dest = lir->operands[0];
-    const bool dumpNop = (cUnit->enableDebug & (1 << kDebugShowNops));
+  LIR* lir = (LIR*) arg;
+  int offset = lir->offset;
+  int dest = lir->operands[0];
+  const bool dumpNop = (cUnit->enableDebug & (1 << kDebugShowNops));
 
-    /* Handle pseudo-ops individually, and all regular insns as a group */
-    switch (lir->opcode) {
-        case kPseudoMethodEntry:
-            LOG(INFO) << "-------- method entry " <<
-                PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
-            break;
-        case kPseudoMethodExit:
-            LOG(INFO) << "-------- Method_Exit";
-            break;
-        case kPseudoBarrier:
-            LOG(INFO) << "-------- BARRIER";
-            break;
-        case kPseudoExtended:
-            LOG(INFO) << "-------- " << (char* ) dest;
-            break;
-        case kPseudoSSARep:
-            DUMP_SSA_REP(LOG(INFO) << "-------- kMirOpPhi: " <<  (char* ) dest);
-            break;
-        case kPseudoEntryBlock:
-            LOG(INFO) << "-------- entry offset: 0x" << std::hex << dest;
-            break;
-        case kPseudoDalvikByteCodeBoundary:
-            LOG(INFO) << "-------- dalvik offset: 0x" << std::hex <<
-                 lir->dalvikOffset << " @ " << (char* )lir->operands[0];
-            break;
-        case kPseudoExitBlock:
-            LOG(INFO) << "-------- exit offset: 0x" << std::hex << dest;
-            break;
-        case kPseudoPseudoAlign4:
-            LOG(INFO) << (intptr_t)baseAddr + offset << " (0x" << std::hex <<
-                offset << "): .align4";
-            break;
-        case kPseudoEHBlockLabel:
-            LOG(INFO) << "Exception_Handling:";
-            break;
-        case kPseudoTargetLabel:
-        case kPseudoNormalBlockLabel:
-            LOG(INFO) << "L" << (void*)lir << ":";
-            break;
-        case kPseudoThrowTarget:
-            LOG(INFO) << "LT" << (void*)lir << ":";
-            break;
-        case kPseudoIntrinsicRetry:
-            LOG(INFO) << "IR" << (void*)lir << ":";
-            break;
-        case kPseudoSuspendTarget:
-            LOG(INFO) << "LS" << (void*)lir << ":";
-            break;
-        case kPseudoCaseLabel:
-            LOG(INFO) << "LC" << (void*)lir << ": Case target 0x" <<
-                std::hex << lir->operands[0] << "|" << std::dec <<
-                lir->operands[0];
-            break;
-        default:
-            if (lir->flags.isNop && !dumpNop) {
-                break;
-            } else {
-                std::string op_name(buildInsnString(EncodingMap[lir->opcode].name, lir, baseAddr));
-                std::string op_operands(buildInsnString(EncodingMap[lir->opcode].fmt, lir, baseAddr));
-                LOG(INFO) << StringPrintf("%05x: %-9s%s%s", (unsigned int)(baseAddr + offset),
-                    op_name.c_str(), op_operands.c_str(), lir->flags.isNop ? "(nop)" : "");
-            }
-            break;
-    }
+  /* Handle pseudo-ops individually, and all regular insns as a group */
+  switch (lir->opcode) {
+    case kPseudoMethodEntry:
+      LOG(INFO) << "-------- method entry "
+                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
+      break;
+    case kPseudoMethodExit:
+      LOG(INFO) << "-------- Method_Exit";
+      break;
+    case kPseudoBarrier:
+      LOG(INFO) << "-------- BARRIER";
+      break;
+    case kPseudoExtended:
+      LOG(INFO) << "-------- " << (char* ) dest;
+      break;
+    case kPseudoSSARep:
+      DUMP_SSA_REP(LOG(INFO) << "-------- kMirOpPhi: " <<  (char* ) dest);
+      break;
+    case kPseudoEntryBlock:
+      LOG(INFO) << "-------- entry offset: 0x" << std::hex << dest;
+      break;
+    case kPseudoDalvikByteCodeBoundary:
+      LOG(INFO) << "-------- dalvik offset: 0x" << std::hex
+                << lir->dalvikOffset << " @ " << (char* )lir->operands[0];
+      break;
+    case kPseudoExitBlock:
+      LOG(INFO) << "-------- exit offset: 0x" << std::hex << dest;
+      break;
+    case kPseudoPseudoAlign4:
+      LOG(INFO) << (intptr_t)baseAddr + offset << " (0x" << std::hex
+                << offset << "): .align4";
+      break;
+    case kPseudoEHBlockLabel:
+      LOG(INFO) << "Exception_Handling:";
+      break;
+    case kPseudoTargetLabel:
+    case kPseudoNormalBlockLabel:
+      LOG(INFO) << "L" << (void*)lir << ":";
+      break;
+    case kPseudoThrowTarget:
+      LOG(INFO) << "LT" << (void*)lir << ":";
+      break;
+    case kPseudoIntrinsicRetry:
+      LOG(INFO) << "IR" << (void*)lir << ":";
+      break;
+    case kPseudoSuspendTarget:
+      LOG(INFO) << "LS" << (void*)lir << ":";
+      break;
+    case kPseudoCaseLabel:
+      LOG(INFO) << "LC" << (void*)lir << ": Case target 0x"
+                << std::hex << lir->operands[0] << "|" << std::dec <<
+        lir->operands[0];
+      break;
+    default:
+      if (lir->flags.isNop && !dumpNop) {
+        break;
+      } else {
+        std::string op_name(buildInsnString(EncodingMap[lir->opcode].name,
+                                            lir, baseAddr));
+        std::string op_operands(buildInsnString(EncodingMap[lir->opcode].fmt
+                                              , lir, baseAddr));
+        LOG(INFO) << StringPrintf("%05x: %-9s%s%s",
+                                  (unsigned int)(baseAddr + offset),
+                                  op_name.c_str(), op_operands.c_str(),
+                                  lir->flags.isNop ? "(nop)" : "");
+      }
+      break;
+  }
 
-    if (lir->useMask && (!lir->flags.isNop || dumpNop)) {
-        DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir,
-                                               lir->useMask, "use"));
-    }
-    if (lir->defMask && (!lir->flags.isNop || dumpNop)) {
-        DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir,
-                                               lir->defMask, "def"));
-    }
+  if (lir->useMask && (!lir->flags.isNop || dumpNop)) {
+    DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir, lir->useMask, "use"));
+  }
+  if (lir->defMask && (!lir->flags.isNop || dumpNop)) {
+    DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir, lir->defMask, "def"));
+  }
 }
 
 void oatDumpPromotionMap(CompilationUnit *cUnit)
 {
-    int numRegs = cUnit->numDalvikRegisters + cUnit->numCompilerTemps + 1;
-    for (int i = 0; i < numRegs; i++) {
-        PromotionMap vRegMap = cUnit->promotionMap[i];
-        std::string buf;
-        if (vRegMap.fpLocation == kLocPhysReg) {
-            StringAppendF(&buf, " : s%d", vRegMap.fpReg & FP_REG_MASK);
-        }
-
-        std::string buf3;
-        if (i < cUnit->numDalvikRegisters) {
-            StringAppendF(&buf3, "%02d", i);
-        } else if (i == cUnit->methodSReg) {
-            buf3 = "Method*";
-        } else {
-            StringAppendF(&buf3, "ct%d", i - cUnit->numDalvikRegisters);
-        }
-
-        LOG(INFO) << StringPrintf("V[%s] -> %s%d%s", buf3.c_str(),
-                 vRegMap.coreLocation == kLocPhysReg ?
-                 "r" : "SP+", vRegMap.coreLocation == kLocPhysReg ?
-                 vRegMap.coreReg : oatSRegOffset(cUnit, i), buf.c_str());
+  int numRegs = cUnit->numDalvikRegisters + cUnit->numCompilerTemps + 1;
+  for (int i = 0; i < numRegs; i++) {
+    PromotionMap vRegMap = cUnit->promotionMap[i];
+    std::string buf;
+    if (vRegMap.fpLocation == kLocPhysReg) {
+      StringAppendF(&buf, " : s%d", vRegMap.fpReg & FP_REG_MASK);
     }
+
+    std::string buf3;
+    if (i < cUnit->numDalvikRegisters) {
+      StringAppendF(&buf3, "%02d", i);
+    } else if (i == cUnit->methodSReg) {
+      buf3 = "Method*";
+    } else {
+      StringAppendF(&buf3, "ct%d", i - cUnit->numDalvikRegisters);
+    }
+
+    LOG(INFO) << StringPrintf("V[%s] -> %s%d%s", buf3.c_str(),
+                              vRegMap.coreLocation == kLocPhysReg ?
+                              "r" : "SP+", vRegMap.coreLocation == kLocPhysReg ?
+                              vRegMap.coreReg : oatSRegOffset(cUnit, i),
+                              buf.c_str());
+  }
 }
 
 /* Dump instructions and constant pool contents */
 void oatCodegenDump(CompilationUnit* cUnit)
 {
-    LOG(INFO) << "/*";
-    LOG(INFO) << "Dumping LIR insns for "
-        << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
-    LIR* lirInsn;
-    LIR* thisLIR;
-    int insnsSize = cUnit->insnsSize;
+  LOG(INFO) << "/*";
+  LOG(INFO) << "Dumping LIR insns for "
+            << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
+  LIR* lirInsn;
+  LIR* thisLIR;
+  int insnsSize = cUnit->insnsSize;
 
-    LOG(INFO) << "Regs (excluding ins) : " << cUnit->numRegs;
-    LOG(INFO) << "Ins                  : " << cUnit->numIns;
-    LOG(INFO) << "Outs                 : " << cUnit->numOuts;
-    LOG(INFO) << "CoreSpills           : " << cUnit->numCoreSpills;
-    LOG(INFO) << "FPSpills             : " << cUnit->numFPSpills;
-    LOG(INFO) << "CompilerTemps        : " << cUnit->numCompilerTemps;
-    LOG(INFO) << "Frame size           : " << cUnit->frameSize;
-    LOG(INFO) << "code size is " << cUnit->totalSize <<
-        " bytes, Dalvik size is " << insnsSize * 2;
-    LOG(INFO) << "expansion factor: " <<
-         (float)cUnit->totalSize / (float)(insnsSize * 2);
-    oatDumpPromotionMap(cUnit);
-    for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
-        oatDumpLIRInsn(cUnit, lirInsn, 0);
-    }
-    for (lirInsn = cUnit->classPointerList; lirInsn; lirInsn = lirInsn->next) {
-        thisLIR = (LIR*) lirInsn;
-        LOG(INFO) << StringPrintf("%x (%04x): .class (%s)",
-            thisLIR->offset, thisLIR->offset,
-            ((CallsiteInfo *) thisLIR->operands[0])->classDescriptor);
-    }
-    for (lirInsn = cUnit->literalList; lirInsn; lirInsn = lirInsn->next) {
-        thisLIR = (LIR*) lirInsn;
-        LOG(INFO) << StringPrintf("%x (%04x): .word (%#x)",
-            thisLIR->offset, thisLIR->offset, thisLIR->operands[0]);
-    }
+  LOG(INFO) << "Regs (excluding ins) : " << cUnit->numRegs;
+  LOG(INFO) << "Ins          : " << cUnit->numIns;
+  LOG(INFO) << "Outs         : " << cUnit->numOuts;
+  LOG(INFO) << "CoreSpills       : " << cUnit->numCoreSpills;
+  LOG(INFO) << "FPSpills       : " << cUnit->numFPSpills;
+  LOG(INFO) << "CompilerTemps    : " << cUnit->numCompilerTemps;
+  LOG(INFO) << "Frame size       : " << cUnit->frameSize;
+  LOG(INFO) << "code size is " << cUnit->totalSize <<
+    " bytes, Dalvik size is " << insnsSize * 2;
+  LOG(INFO) << "expansion factor: "
+            << (float)cUnit->totalSize / (float)(insnsSize * 2);
+  oatDumpPromotionMap(cUnit);
+  for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
+    oatDumpLIRInsn(cUnit, lirInsn, 0);
+  }
+  for (lirInsn = cUnit->classPointerList; lirInsn; lirInsn = lirInsn->next) {
+    thisLIR = (LIR*) lirInsn;
+    LOG(INFO) << StringPrintf("%x (%04x): .class (%s)",
+                              thisLIR->offset, thisLIR->offset,
+                              ((CallsiteInfo *)
+                              thisLIR->operands[0])->classDescriptor);
+  }
+  for (lirInsn = cUnit->literalList; lirInsn; lirInsn = lirInsn->next) {
+    thisLIR = (LIR*) lirInsn;
+    LOG(INFO) << StringPrintf("%x (%04x): .word (%#x)",
+                              thisLIR->offset, thisLIR->offset,
+                              thisLIR->operands[0]);
+  }
 
-    const DexFile::MethodId& method_id =
-        cUnit->dex_file->GetMethodId(cUnit->method_idx);
-    std::string signature(cUnit->dex_file->GetMethodSignature(method_id));
-    std::string name(cUnit->dex_file->GetMethodName(method_id));
-    std::string descriptor(cUnit->dex_file->GetMethodDeclaringClassDescriptor(method_id));
+  const DexFile::MethodId& method_id =
+      cUnit->dex_file->GetMethodId(cUnit->method_idx);
+  std::string signature(cUnit->dex_file->GetMethodSignature(method_id));
+  std::string name(cUnit->dex_file->GetMethodName(method_id));
+  std::string descriptor(cUnit->dex_file->GetMethodDeclaringClassDescriptor(method_id));
 
-    // Dump mapping table
-    if (cUnit->mappingTable.size() > 0) {
-        std::string line(StringPrintf("\n    MappingTable %s%s_%s_mappingTable[%zu] = {",
-            descriptor.c_str(), name.c_str(), signature.c_str(), cUnit->mappingTable.size()));
-        std::replace(line.begin(), line.end(), ';', '_');
-        LOG(INFO) << line;
-        for (uint32_t i = 0; i < cUnit->mappingTable.size(); i+=2) {
-            line = StringPrintf("        {0x%05x, 0x%04x},",
-                cUnit->mappingTable[i], cUnit->mappingTable[i+1]);
-            LOG(INFO) << line;
-        }
-        LOG(INFO) <<"    };\n\n";
+  // Dump mapping table
+  if (cUnit->mappingTable.size() > 0) {
+    std::string
+        line(StringPrintf("\n  MappingTable %s%s_%s_mappingTable[%zu] = {",
+                          descriptor.c_str(), name.c_str(), signature.c_str(),
+                          cUnit->mappingTable.size()));
+    std::replace(line.begin(), line.end(), ';', '_');
+    LOG(INFO) << line;
+    for (uint32_t i = 0; i < cUnit->mappingTable.size(); i+=2) {
+      line = StringPrintf("    {0x%05x, 0x%04x},",
+                          cUnit->mappingTable[i], cUnit->mappingTable[i+1]);
+      LOG(INFO) << line;
     }
+    LOG(INFO) <<"  };\n\n";
+  }
 }
 
 
 LIR* rawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0,
-            int op1, int op2, int op3, int op4, LIR* target)
+      int op1, int op2, int op3, int op4, LIR* target)
 {
-    LIR* insn = (LIR* ) oatNew(cUnit, sizeof(LIR), true, kAllocLIR);
-    insn->dalvikOffset = dalvikOffset;
-    insn->opcode = opcode;
-    insn->operands[0] = op0;
-    insn->operands[1] = op1;
-    insn->operands[2] = op2;
-    insn->operands[3] = op3;
-    insn->operands[4] = op4;
-    insn->target = target;
-    oatSetupResourceMasks(insn);
-    if (opcode == kPseudoTargetLabel) {
-        // Always make labels scheduling barriers
-        insn->defMask = ENCODE_ALL;
-    }
-    return insn;
+  LIR* insn = (LIR* ) oatNew(cUnit, sizeof(LIR), true, kAllocLIR);
+  insn->dalvikOffset = dalvikOffset;
+  insn->opcode = opcode;
+  insn->operands[0] = op0;
+  insn->operands[1] = op1;
+  insn->operands[2] = op2;
+  insn->operands[3] = op3;
+  insn->operands[4] = op4;
+  insn->target = target;
+  oatSetupResourceMasks(insn);
+  if (opcode == kPseudoTargetLabel) {
+    // Always make labels scheduling barriers
+    insn->defMask = ENCODE_ALL;
+  }
+  return insn;
 }
 
 /*
@@ -440,76 +447,76 @@
  */
 LIR* newLIR0(CompilationUnit* cUnit, int opcode)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & NO_OPERAND))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & NO_OPERAND))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 LIR* newLIR1(CompilationUnit* cUnit, int opcode,
-                           int dest)
+               int dest)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_UNARY_OP))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_UNARY_OP))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 LIR* newLIR2(CompilationUnit* cUnit, int opcode,
-                           int dest, int src1)
+               int dest, int src1)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_BINARY_OP))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_BINARY_OP))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 LIR* newLIR3(CompilationUnit* cUnit, int opcode,
-                           int dest, int src1, int src2)
+               int dest, int src1, int src2)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_TERTIARY_OP))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
-                       src2);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_TERTIARY_OP))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
+                     src2);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 LIR* newLIR4(CompilationUnit* cUnit, int opcode,
-            int dest, int src1, int src2, int info)
+      int dest, int src1, int src2, int info)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_QUAD_OP))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
-                       src2, info);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_QUAD_OP))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
+                     src2, info);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 LIR* newLIR5(CompilationUnit* cUnit, int opcode,
-             int dest, int src1, int src2, int info1, int info2)
+       int dest, int src1, int src2, int info1, int info2)
 {
-    DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_QUIN_OP))
-                << EncodingMap[opcode].name << " " << (int)opcode << " "
-                << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
-                << cUnit->currentDalvikOffset;
-    LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
-                       src2, info1, info2);
-    oatAppendLIR(cUnit, (LIR*) insn);
-    return insn;
+  DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_QUIN_OP))
+      << EncodingMap[opcode].name << " " << (int)opcode << " "
+      << PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
+      << cUnit->currentDalvikOffset;
+  LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1,
+                     src2, info1, info2);
+  oatAppendLIR(cUnit, (LIR*) insn);
+  return insn;
 }
 
 /*
@@ -518,32 +525,31 @@
  */
 LIR* scanLiteralPool(LIR* dataTarget, int value, unsigned int delta)
 {
-    while (dataTarget) {
-        if (((unsigned) (value - ((LIR* ) dataTarget)->operands[0])) <=
-            delta)
-            return (LIR* ) dataTarget;
-        dataTarget = dataTarget->next;
-    }
-    return NULL;
+  while (dataTarget) {
+    if (((unsigned) (value - ((LIR* ) dataTarget)->operands[0])) <= delta)
+      return (LIR* ) dataTarget;
+    dataTarget = dataTarget->next;
+  }
+  return NULL;
 }
 
 /* Search the existing constants in the literal pool for an exact wide match */
 LIR* scanLiteralPoolWide(LIR* dataTarget, int valLo, int valHi)
 {
-    bool loMatch = false;
-    LIR* loTarget = NULL;
-    while (dataTarget) {
-        if (loMatch && (((LIR*)dataTarget)->operands[0] == valHi)) {
-            return (LIR*)loTarget;
-        }
-        loMatch = false;
-        if (((LIR*)dataTarget)->operands[0] == valLo) {
-            loMatch = true;
-            loTarget = dataTarget;
-        }
-        dataTarget = dataTarget->next;
+  bool loMatch = false;
+  LIR* loTarget = NULL;
+  while (dataTarget) {
+    if (loMatch && (((LIR*)dataTarget)->operands[0] == valHi)) {
+      return (LIR*)loTarget;
     }
-    return NULL;
+    loMatch = false;
+    if (((LIR*)dataTarget)->operands[0] == valLo) {
+      loMatch = true;
+      loTarget = dataTarget;
+    }
+    dataTarget = dataTarget->next;
+  }
+  return NULL;
 }
 
 /*
@@ -554,39 +560,38 @@
 /* Add a 32-bit constant either in the constant pool */
 LIR* addWordData(CompilationUnit* cUnit, LIR* *constantListP, int value)
 {
-    /* Add the constant to the literal pool */
-    if (constantListP) {
-        LIR* newValue = (LIR* ) oatNew(cUnit, sizeof(LIR), true,
-                                             kAllocData);
-        newValue->operands[0] = value;
-        newValue->next = *constantListP;
-        *constantListP = (LIR*) newValue;
-        return newValue;
-    }
-    return NULL;
+  /* Add the constant to the literal pool */
+  if (constantListP) {
+    LIR* newValue = (LIR* ) oatNew(cUnit, sizeof(LIR), true, kAllocData);
+    newValue->operands[0] = value;
+    newValue->next = *constantListP;
+    *constantListP = (LIR*) newValue;
+    return newValue;
+  }
+  return NULL;
 }
 
 /* Add a 64-bit constant to the constant pool or mixed with code */
 LIR* addWideData(CompilationUnit* cUnit, LIR* *constantListP,
-                           int valLo, int valHi)
+               int valLo, int valHi)
 {
-    //FIXME: hard-coded little endian, need BE variant
-    // Insert high word into list first
-    addWordData(cUnit, constantListP, valHi);
-    return addWordData(cUnit, constantListP, valLo);
+  //FIXME: hard-coded little endian, need BE variant
+  // Insert high word into list first
+  addWordData(cUnit, constantListP, valHi);
+  return addWordData(cUnit, constantListP, valLo);
 }
 
 void pushWord(std::vector<uint8_t>&buf, int data) {
-    buf.push_back( data & 0xff);
-    buf.push_back( (data >> 8) & 0xff);
-    buf.push_back( (data >> 16) & 0xff);
-    buf.push_back( (data >> 24) & 0xff);
+  buf.push_back( data & 0xff);
+  buf.push_back( (data >> 8) & 0xff);
+  buf.push_back( (data >> 16) & 0xff);
+  buf.push_back( (data >> 24) & 0xff);
 }
 
 void alignBuffer(std::vector<uint8_t>&buf, size_t offset) {
-    while (buf.size() < offset) {
-        buf.push_back(0);
-    }
+  while (buf.size() < offset) {
+    buf.push_back(0);
+  }
 }
 
 bool IsDirect(int invokeType) {
@@ -597,188 +602,189 @@
 /* Write the literal pool to the output stream */
 void installLiteralPools(CompilationUnit* cUnit)
 {
-    alignBuffer(cUnit->codeBuffer, cUnit->dataOffset);
-    LIR* dataLIR = cUnit->literalList;
+  alignBuffer(cUnit->codeBuffer, cUnit->dataOffset);
+  LIR* dataLIR = cUnit->literalList;
+  while (dataLIR != NULL) {
+    pushWord(cUnit->codeBuffer, dataLIR->operands[0]);
+    dataLIR = NEXT_LIR(dataLIR);
+  }
+  // Push code and method literals, record offsets for the compiler to patch.
+  dataLIR = cUnit->codeLiteralList;
+  if (dataLIR != NULL) {
     while (dataLIR != NULL) {
-        pushWord(cUnit->codeBuffer, dataLIR->operands[0]);
-        dataLIR = NEXT_LIR(dataLIR);
+      uint32_t target = dataLIR->operands[0];
+      cUnit->compiler->AddCodePatch(cUnit->dex_cache, cUnit->dex_file,
+                                    cUnit->method_idx,
+                                    cUnit->access_flags,
+                                    target,
+                                    IsDirect(dataLIR->operands[1]),
+                                    cUnit->codeBuffer.size());
+      const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
+      // unique based on target to ensure code deduplication works
+      uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
+      pushWord(cUnit->codeBuffer, unique_patch_value);
+      dataLIR = NEXT_LIR(dataLIR);
     }
-    // Push code and method literals, record offsets for the compiler to patch.
-    dataLIR = cUnit->codeLiteralList;
-    if (dataLIR != NULL) {
-        while (dataLIR != NULL) {
-            uint32_t target = dataLIR->operands[0];
-            cUnit->compiler->AddCodePatch(cUnit->dex_cache, cUnit->dex_file,
-                                          cUnit->method_idx,
-                                          cUnit->access_flags,
-                                          target,
-                                          IsDirect(dataLIR->operands[1]),
-                                          cUnit->codeBuffer.size());
-            const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
-            // unique based on target to ensure code deduplication works
-            uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
-            pushWord(cUnit->codeBuffer, unique_patch_value);
-            dataLIR = NEXT_LIR(dataLIR);
-        }
-        dataLIR = cUnit->methodLiteralList;
-        while (dataLIR != NULL) {
-            uint32_t target = dataLIR->operands[0];
-            cUnit->compiler->AddMethodPatch(cUnit->dex_cache, cUnit->dex_file,
-                                            cUnit->method_idx,
-                                            cUnit->access_flags,
-                                            target,
-                                            IsDirect(dataLIR->operands[1]),
-                                            cUnit->codeBuffer.size());
-            const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
-            // unique based on target to ensure code deduplication works
-            uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
-            pushWord(cUnit->codeBuffer, unique_patch_value);
-            dataLIR = NEXT_LIR(dataLIR);
-        }
+    dataLIR = cUnit->methodLiteralList;
+    while (dataLIR != NULL) {
+      uint32_t target = dataLIR->operands[0];
+      cUnit->compiler->AddMethodPatch(cUnit->dex_cache, cUnit->dex_file,
+                                      cUnit->method_idx,
+                                      cUnit->access_flags,
+                                      target,
+                                      IsDirect(dataLIR->operands[1]),
+                                      cUnit->codeBuffer.size());
+      const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
+      // unique based on target to ensure code deduplication works
+      uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
+      pushWord(cUnit->codeBuffer, unique_patch_value);
+      dataLIR = NEXT_LIR(dataLIR);
     }
+  }
 
 }
 
 /* Write the switch tables to the output stream */
 void installSwitchTables(CompilationUnit* cUnit)
 {
-    GrowableListIterator iterator;
-    oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
-    while (true) {
-        SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(
-             &iterator);
-        if (tabRec == NULL) break;
-        alignBuffer(cUnit->codeBuffer, tabRec->offset);
-        /*
-         * For Arm, our reference point is the address of the bx
-         * instruction that does the launch, so we have to subtract
-         * the auto pc-advance.  For other targets the reference point
-         * is a label, so we can use the offset as-is.
-         */
+  GrowableListIterator iterator;
+  oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+  while (true) {
+    SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(
+       &iterator);
+    if (tabRec == NULL) break;
+    alignBuffer(cUnit->codeBuffer, tabRec->offset);
+    /*
+     * For Arm, our reference point is the address of the bx
+     * instruction that does the launch, so we have to subtract
+     * the auto pc-advance.  For other targets the reference point
+     * is a label, so we can use the offset as-is.
+     */
 #if defined(TARGET_ARM)
-        int bxOffset = tabRec->anchor->offset + 4;
+    int bxOffset = tabRec->anchor->offset + 4;
 #elif defined(TARGET_X86)
-        int bxOffset = 0;
+    int bxOffset = 0;
 #else
-        int bxOffset = tabRec->anchor->offset;
+    int bxOffset = tabRec->anchor->offset;
 #endif
-        if (cUnit->printMe) {
-            LOG(INFO) << "Switch table for offset 0x" << std::hex << bxOffset;
-        }
-        if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
-            int* keys = (int*)&(tabRec->table[2]);
-            for (int elems = 0; elems < tabRec->table[1]; elems++) {
-                int disp = tabRec->targets[elems]->offset - bxOffset;
-                if (cUnit->printMe) {
-                    LOG(INFO) << "    Case[" << elems << "] key: 0x" <<
-                        std::hex << keys[elems] << ", disp: 0x" <<
-                        std::hex << disp;
-                }
-                pushWord(cUnit->codeBuffer, keys[elems]);
-                pushWord(cUnit->codeBuffer,
-                    tabRec->targets[elems]->offset - bxOffset);
-            }
-        } else {
-            DCHECK_EQ(static_cast<int>(tabRec->table[0]), static_cast<int>(Instruction::kPackedSwitchSignature));
-            for (int elems = 0; elems < tabRec->table[1]; elems++) {
-                int disp = tabRec->targets[elems]->offset - bxOffset;
-                if (cUnit->printMe) {
-                    LOG(INFO) << "    Case[" << elems << "] disp: 0x" <<
-                        std::hex << disp;
-                }
-                pushWord(cUnit->codeBuffer,
-                         tabRec->targets[elems]->offset - bxOffset);
-            }
-        }
+    if (cUnit->printMe) {
+      LOG(INFO) << "Switch table for offset 0x" << std::hex << bxOffset;
     }
+    if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
+      int* keys = (int*)&(tabRec->table[2]);
+      for (int elems = 0; elems < tabRec->table[1]; elems++) {
+        int disp = tabRec->targets[elems]->offset - bxOffset;
+        if (cUnit->printMe) {
+          LOG(INFO) << "  Case[" << elems << "] key: 0x"
+                    << std::hex << keys[elems] << ", disp: 0x"
+                    << std::hex << disp;
+        }
+        pushWord(cUnit->codeBuffer, keys[elems]);
+        pushWord(cUnit->codeBuffer,
+          tabRec->targets[elems]->offset - bxOffset);
+      }
+    } else {
+      DCHECK_EQ(static_cast<int>(tabRec->table[0]),
+                static_cast<int>(Instruction::kPackedSwitchSignature));
+      for (int elems = 0; elems < tabRec->table[1]; elems++) {
+        int disp = tabRec->targets[elems]->offset - bxOffset;
+        if (cUnit->printMe) {
+          LOG(INFO) << "  Case[" << elems << "] disp: 0x"
+                    << std::hex << disp;
+        }
+        pushWord(cUnit->codeBuffer, tabRec->targets[elems]->offset - bxOffset);
+      }
+    }
+  }
 }
 
 /* Write the fill array dta to the output stream */
 void installFillArrayData(CompilationUnit* cUnit)
 {
-    GrowableListIterator iterator;
-    oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
-    while (true) {
-        FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(
-             &iterator);
-        if (tabRec == NULL) break;
-        alignBuffer(cUnit->codeBuffer, tabRec->offset);
-        for (int i = 0; i < (tabRec->size + 1) / 2; i++) {
-            cUnit->codeBuffer.push_back( tabRec->table[i] & 0xFF);
-            cUnit->codeBuffer.push_back( (tabRec->table[i] >> 8) & 0xFF);
-        }
+  GrowableListIterator iterator;
+  oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
+  while (true) {
+    FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(
+       &iterator);
+    if (tabRec == NULL) break;
+    alignBuffer(cUnit->codeBuffer, tabRec->offset);
+    for (int i = 0; i < (tabRec->size + 1) / 2; i++) {
+      cUnit->codeBuffer.push_back( tabRec->table[i] & 0xFF);
+      cUnit->codeBuffer.push_back( (tabRec->table[i] >> 8) & 0xFF);
     }
+  }
 }
 
 int assignLiteralOffsetCommon(LIR* lir, int offset)
 {
-    for (;lir != NULL; lir = lir->next) {
-        lir->offset = offset;
-        offset += 4;
-    }
-    return offset;
+  for (;lir != NULL; lir = lir->next) {
+    lir->offset = offset;
+    offset += 4;
+  }
+  return offset;
 }
 
 void createMappingTable(CompilationUnit* cUnit)
 {
-    LIR* tgtLIR;
-    int currentDalvikOffset = -1;
+  LIR* tgtLIR;
+  int currentDalvikOffset = -1;
 
-    for (tgtLIR = (LIR *) cUnit->firstLIRInsn;
-         tgtLIR;
-         tgtLIR = NEXT_LIR(tgtLIR)) {
-        if ((tgtLIR->opcode >= 0) && !tgtLIR->flags.isNop &&
-            (currentDalvikOffset != tgtLIR->dalvikOffset)) {
-            // Changed - need to emit a record
-            cUnit->mappingTable.push_back(tgtLIR->offset);
-            cUnit->mappingTable.push_back(tgtLIR->dalvikOffset);
-            currentDalvikOffset = tgtLIR->dalvikOffset;
-        }
+  for (tgtLIR = (LIR *) cUnit->firstLIRInsn;
+     tgtLIR;
+     tgtLIR = NEXT_LIR(tgtLIR)) {
+    if ((tgtLIR->opcode >= 0) && !tgtLIR->flags.isNop &&
+      (currentDalvikOffset != tgtLIR->dalvikOffset)) {
+      // Changed - need to emit a record
+      cUnit->mappingTable.push_back(tgtLIR->offset);
+      cUnit->mappingTable.push_back(tgtLIR->dalvikOffset);
+      currentDalvikOffset = tgtLIR->dalvikOffset;
     }
+  }
 }
 
 /* Determine the offset of each literal field */
 int assignLiteralOffset(CompilationUnit* cUnit, int offset)
 {
-    offset = assignLiteralOffsetCommon(cUnit->literalList, offset);
-    offset = assignLiteralOffsetCommon(cUnit->codeLiteralList, offset);
-    offset = assignLiteralOffsetCommon(cUnit->methodLiteralList, offset);
-    return offset;
+  offset = assignLiteralOffsetCommon(cUnit->literalList, offset);
+  offset = assignLiteralOffsetCommon(cUnit->codeLiteralList, offset);
+  offset = assignLiteralOffsetCommon(cUnit->methodLiteralList, offset);
+  return offset;
 }
 
 int assignSwitchTablesOffset(CompilationUnit* cUnit, int offset)
 {
-    GrowableListIterator iterator;
-    oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
-    while (true) {
-        SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(
-             &iterator);
-        if (tabRec == NULL) break;
-        tabRec->offset = offset;
-        if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
-            offset += tabRec->table[1] * (sizeof(int) * 2);
-        } else {
-            DCHECK_EQ(static_cast<int>(tabRec->table[0]), static_cast<int>(Instruction::kPackedSwitchSignature));
-            offset += tabRec->table[1] * sizeof(int);
-        }
+  GrowableListIterator iterator;
+  oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+  while (true) {
+    SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(
+       &iterator);
+    if (tabRec == NULL) break;
+    tabRec->offset = offset;
+    if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
+      offset += tabRec->table[1] * (sizeof(int) * 2);
+    } else {
+      DCHECK_EQ(static_cast<int>(tabRec->table[0]),
+                static_cast<int>(Instruction::kPackedSwitchSignature));
+      offset += tabRec->table[1] * sizeof(int);
     }
-    return offset;
+  }
+  return offset;
 }
 
 int assignFillArrayDataOffset(CompilationUnit* cUnit, int offset)
 {
-    GrowableListIterator iterator;
-    oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
-    while (true) {
-        FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(
-             &iterator);
-        if (tabRec == NULL) break;
-        tabRec->offset = offset;
-        offset += tabRec->size;
-        // word align
-        offset = (offset + 3) & ~3;
-        }
-    return offset;
+  GrowableListIterator iterator;
+  oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
+  while (true) {
+    FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(
+       &iterator);
+    if (tabRec == NULL) break;
+    tabRec->offset = offset;
+    offset += tabRec->size;
+    // word align
+    offset = (offset + 3) & ~3;
+    }
+  return offset;
 }
 
 /*
@@ -787,21 +793,21 @@
  */
 void oatAssignOffsets(CompilationUnit* cUnit)
 {
-    int offset = oatAssignInsnOffsets(cUnit);
+  int offset = oatAssignInsnOffsets(cUnit);
 
-    /* Const values have to be word aligned */
-    offset = (offset + 3) & ~3;
+  /* Const values have to be word aligned */
+  offset = (offset + 3) & ~3;
 
-    /* Set up offsets for literals */
-    cUnit->dataOffset = offset;
+  /* Set up offsets for literals */
+  cUnit->dataOffset = offset;
 
-    offset = assignLiteralOffset(cUnit, offset);
+  offset = assignLiteralOffset(cUnit, offset);
 
-    offset = assignSwitchTablesOffset(cUnit, offset);
+  offset = assignSwitchTablesOffset(cUnit, offset);
 
-    offset = assignFillArrayDataOffset(cUnit, offset);
+  offset = assignFillArrayDataOffset(cUnit, offset);
 
-    cUnit->totalSize = offset;
+  cUnit->totalSize = offset;
 }
 
 /*
@@ -811,41 +817,41 @@
  */
 void oatAssembleLIR(CompilationUnit* cUnit)
 {
-    oatAssignOffsets(cUnit);
-    /*
-     * Assemble here.  Note that we generate code with optimistic assumptions
-     * and if found now to work, we'll have to redo the sequence and retry.
-     */
+  oatAssignOffsets(cUnit);
+  /*
+   * Assemble here.  Note that we generate code with optimistic assumptions
+   * and if found now to work, we'll have to redo the sequence and retry.
+   */
 
-    while (true) {
-        AssemblerStatus res = oatAssembleInstructions(cUnit, 0);
-        if (res == kSuccess) {
-            break;
-        } else {
-            cUnit->assemblerRetries++;
-            if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {
-              oatCodegenDump(cUnit);
-              LOG(FATAL) << "Assembler error - too many retries";
-            }
-            // Redo offsets and try again
-            oatAssignOffsets(cUnit);
-            cUnit->codeBuffer.clear();
-        }
+  while (true) {
+    AssemblerStatus res = oatAssembleInstructions(cUnit, 0);
+    if (res == kSuccess) {
+      break;
+    } else {
+      cUnit->assemblerRetries++;
+      if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {
+        oatCodegenDump(cUnit);
+        LOG(FATAL) << "Assembler error - too many retries";
+      }
+      // Redo offsets and try again
+      oatAssignOffsets(cUnit);
+      cUnit->codeBuffer.clear();
     }
+  }
 
-    // Install literals
-    installLiteralPools(cUnit);
+  // Install literals
+  installLiteralPools(cUnit);
 
-    // Install switch tables
-    installSwitchTables(cUnit);
+  // Install switch tables
+  installSwitchTables(cUnit);
 
-    // Install fill array data
-    installFillArrayData(cUnit);
+  // Install fill array data
+  installFillArrayData(cUnit);
 
-    /*
-     * Create the mapping table
-     */
-    createMappingTable(cUnit);
+  /*
+   * Create the mapping table
+   */
+  createMappingTable(cUnit);
 }
 
 /*
@@ -857,109 +863,108 @@
  */
 LIR* insertCaseLabel(CompilationUnit* cUnit, int vaddr, int keyVal)
 {
-    SafeMap<unsigned int, LIR*>::iterator it;
-    it = cUnit->boundaryMap.find(vaddr);
-    if (it == cUnit->boundaryMap.end()) {
-        LOG(FATAL) << "Error: didn't find vaddr 0x" << std::hex << vaddr;
-    }
-    LIR* newLabel = (LIR*)oatNew(cUnit, sizeof(LIR), true, kAllocLIR);
-    newLabel->dalvikOffset = vaddr;
-    newLabel->opcode = kPseudoCaseLabel;
-    newLabel->operands[0] = keyVal;
-    oatInsertLIRAfter(it->second, (LIR*)newLabel);
-    return newLabel;
+  SafeMap<unsigned int, LIR*>::iterator it;
+  it = cUnit->boundaryMap.find(vaddr);
+  if (it == cUnit->boundaryMap.end()) {
+    LOG(FATAL) << "Error: didn't find vaddr 0x" << std::hex << vaddr;
+  }
+  LIR* newLabel = (LIR*)oatNew(cUnit, sizeof(LIR), true, kAllocLIR);
+  newLabel->dalvikOffset = vaddr;
+  newLabel->opcode = kPseudoCaseLabel;
+  newLabel->operands[0] = keyVal;
+  oatInsertLIRAfter(it->second, (LIR*)newLabel);
+  return newLabel;
 }
 
 void markPackedCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
 {
-    const u2* table = tabRec->table;
-    int baseVaddr = tabRec->vaddr;
-    int *targets = (int*)&table[4];
-    int entries = table[1];
-    int lowKey = s4FromSwitchData(&table[2]);
-    for (int i = 0; i < entries; i++) {
-        tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i],
-                                             i + lowKey);
-    }
+  const u2* table = tabRec->table;
+  int baseVaddr = tabRec->vaddr;
+  int *targets = (int*)&table[4];
+  int entries = table[1];
+  int lowKey = s4FromSwitchData(&table[2]);
+  for (int i = 0; i < entries; i++) {
+    tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i],
+                                         i + lowKey);
+  }
 }
 
 void markSparseCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
 {
-    const u2* table = tabRec->table;
-    int baseVaddr = tabRec->vaddr;
-    int entries = table[1];
-    int* keys = (int*)&table[2];
-    int* targets = &keys[entries];
-    for (int i = 0; i < entries; i++) {
-        tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i],
-                                             keys[i]);
-    }
+  const u2* table = tabRec->table;
+  int baseVaddr = tabRec->vaddr;
+  int entries = table[1];
+  int* keys = (int*)&table[2];
+  int* targets = &keys[entries];
+  for (int i = 0; i < entries; i++) {
+    tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i],
+                                         keys[i]);
+  }
 }
 
 void oatProcessSwitchTables(CompilationUnit* cUnit)
 {
-    GrowableListIterator iterator;
-    oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
-    while (true) {
-        SwitchTable *tabRec = (SwitchTable *) oatGrowableListIteratorNext(
-             &iterator);
-        if (tabRec == NULL) break;
-        if (tabRec->table[0] == Instruction::kPackedSwitchSignature) {
-            markPackedCaseLabels(cUnit, tabRec);
-        } else if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
-            markSparseCaseLabels(cUnit, tabRec);
-        } else {
-            LOG(FATAL) << "Invalid switch table";
-        }
+  GrowableListIterator iterator;
+  oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+  while (true) {
+    SwitchTable *tabRec =
+        (SwitchTable *) oatGrowableListIteratorNext(&iterator);
+    if (tabRec == NULL) break;
+    if (tabRec->table[0] == Instruction::kPackedSwitchSignature) {
+      markPackedCaseLabels(cUnit, tabRec);
+    } else if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
+      markSparseCaseLabels(cUnit, tabRec);
+    } else {
+      LOG(FATAL) << "Invalid switch table";
     }
+  }
 }
 
 //FIXME: Do we have endian issues here?
 
 void dumpSparseSwitchTable(const u2* table)
-    /*
-     * Sparse switch data format:
-     *  ushort ident = 0x0200   magic value
-     *  ushort size             number of entries in the table; > 0
-     *  int keys[size]          keys, sorted low-to-high; 32-bit aligned
-     *  int targets[size]       branch targets, relative to switch opcode
-     *
-     * Total size is (2+size*4) 16-bit code units.
-     */
+  /*
+   * Sparse switch data format:
+   *  ushort ident = 0x0200   magic value
+   *  ushort size       number of entries in the table; > 0
+   *  int keys[size]      keys, sorted low-to-high; 32-bit aligned
+   *  int targets[size]     branch targets, relative to switch opcode
+   *
+   * Total size is (2+size*4) 16-bit code units.
+   */
 {
-    u2 ident = table[0];
-    int entries = table[1];
-    int* keys = (int*)&table[2];
-    int* targets = &keys[entries];
-    LOG(INFO) <<  "Sparse switch table - ident:0x" << std::hex << ident <<
-       ", entries: " << std::dec << entries;
-    for (int i = 0; i < entries; i++) {
-        LOG(INFO) << "    Key[" << keys[i] << "] -> 0x" << std::hex <<
-        targets[i];
-    }
+  u2 ident = table[0];
+  int entries = table[1];
+  int* keys = (int*)&table[2];
+  int* targets = &keys[entries];
+  LOG(INFO) <<  "Sparse switch table - ident:0x" << std::hex << ident
+            << ", entries: " << std::dec << entries;
+  for (int i = 0; i < entries; i++) {
+    LOG(INFO) << "  Key[" << keys[i] << "] -> 0x" << std::hex << targets[i];
+  }
 }
 
 void dumpPackedSwitchTable(const u2* table)
-    /*
-     * Packed switch data format:
-     *  ushort ident = 0x0100   magic value
-     *  ushort size             number of entries in the table
-     *  int first_key           first (and lowest) switch case value
-     *  int targets[size]       branch targets, relative to switch opcode
-     *
-     * Total size is (4+size*2) 16-bit code units.
-     */
+  /*
+   * Packed switch data format:
+   *  ushort ident = 0x0100   magic value
+   *  ushort size       number of entries in the table
+   *  int first_key       first (and lowest) switch case value
+   *  int targets[size]     branch targets, relative to switch opcode
+   *
+   * Total size is (4+size*2) 16-bit code units.
+   */
 {
-    u2 ident = table[0];
-    int* targets = (int*)&table[4];
-    int entries = table[1];
-    int lowKey = s4FromSwitchData(&table[2]);
-    LOG(INFO) << "Packed switch table - ident:0x" << std::hex << ident <<
-        ", entries: " << std::dec << entries << ", lowKey: " << lowKey;
-    for (int i = 0; i < entries; i++) {
-        LOG(INFO) << "    Key[" << (i + lowKey) << "] -> 0x" << std::hex <<
-            targets[i];
-    }
+  u2 ident = table[0];
+  int* targets = (int*)&table[4];
+  int entries = table[1];
+  int lowKey = s4FromSwitchData(&table[2]);
+  LOG(INFO) << "Packed switch table - ident:0x" << std::hex << ident
+            << ", entries: " << std::dec << entries << ", lowKey: " << lowKey;
+  for (int i = 0; i < entries; i++) {
+    LOG(INFO) << "  Key[" << (i + lowKey) << "] -> 0x" << std::hex
+              << targets[i];
+  }
 }
 
 
diff --git a/src/compiler/codegen/CompilerCodegen.h b/src/compiler/codegen/CompilerCodegen.h
index 20b2e45..9381735 100644
--- a/src/compiler/codegen/CompilerCodegen.h
+++ b/src/compiler/codegen/CompilerCodegen.h
@@ -22,7 +22,8 @@
 namespace art {
 
 LIR* rawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0 = 0,
-            int op1 = 0, int op2 = 0, int op3 = 0, int op4 = 0, LIR* target = NULL);
+            int op1 = 0, int op2 = 0, int op3 = 0, int op4 = 0,
+            LIR* target = NULL);
 
 int oatGetInsnSize(LIR* lir);
 
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index e2b8282..9e21aea 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -24,7 +24,7 @@
  * and "op" calls may be used here.
  */
 void genInvoke(CompilationUnit* cUnit, BasicBlock* bb,  MIR* mir,
-               InvokeType type, bool isRange);
+         InvokeType type, bool isRange);
 #if defined(TARGET_ARM)
 LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide);
 bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
@@ -33,148 +33,148 @@
 
 void callRuntimeHelperImm(CompilationUnit* cUnit, int helperOffset, int arg0) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperReg(CompilationUnit* cUnit, int helperOffset, int arg0) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    opRegCopy(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  opRegCopy(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset,
                                   RegLocation arg0) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    if (arg0.wide == 0) {
-        loadValueDirectFixed(cUnit, arg0, rARG0);
-    } else {
-        loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
-    }
-    oatClobberCalleeSave(cUnit);
+  if (arg0.wide == 0) {
+    loadValueDirectFixed(cUnit, arg0, rARG0);
+  } else {
+    loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
+  }
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset,
                              int arg0, int arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadConstant(cUnit, rARG0, arg0);
-    loadConstant(cUnit, rARG1, arg1);
-    oatClobberCalleeSave(cUnit);
+  loadConstant(cUnit, rARG0, arg0);
+  loadConstant(cUnit, rARG1, arg1);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset,
                                      int arg0, RegLocation arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    if (arg1.wide == 0) {
-        loadValueDirectFixed(cUnit, arg1, rARG1);
-    } else {
-        loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
-    }
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  if (arg1.wide == 0) {
+    loadValueDirectFixed(cUnit, arg1, rARG1);
+  } else {
+    loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
+  }
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset,
                                      RegLocation arg0, int arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadValueDirectFixed(cUnit, arg0, rARG0);
-    loadConstant(cUnit, rARG1, arg1);
-    oatClobberCalleeSave(cUnit);
+  loadValueDirectFixed(cUnit, arg0, rARG0);
+  loadConstant(cUnit, rARG1, arg1);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperImmReg(CompilationUnit* cUnit, int helperOffset,
                              int arg0, int arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    opRegCopy(cUnit, rARG1, arg1);
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  opRegCopy(cUnit, rARG1, arg1);
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperRegImm(CompilationUnit* cUnit, int helperOffset,
                              int arg0, int arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    opRegCopy(cUnit, rARG0, arg0);
-    loadConstant(cUnit, rARG1, arg1);
-    oatClobberCalleeSave(cUnit);
+  opRegCopy(cUnit, rARG0, arg0);
+  loadConstant(cUnit, rARG1, arg1);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperImmMethod(CompilationUnit* cUnit, int helperOffset,
                                 int arg0) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadCurrMethodDirect(cUnit, rARG1);
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  loadCurrMethodDirect(cUnit, rARG1);
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
@@ -183,98 +183,99 @@
                                              RegLocation arg0,
                                              RegLocation arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    if (arg0.wide == 0) {
-        loadValueDirectFixed(cUnit, arg0, rARG0);
-        if (arg1.wide == 0) {
-            loadValueDirectFixed(cUnit, arg1, rARG1);
-        } else {
-            loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
-        }
+  if (arg0.wide == 0) {
+    loadValueDirectFixed(cUnit, arg0, rARG0);
+    if (arg1.wide == 0) {
+      loadValueDirectFixed(cUnit, arg1, rARG1);
     } else {
-        loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
-        if (arg1.wide == 0) {
-            loadValueDirectFixed(cUnit, arg1, rARG2);
-        } else {
-            loadValueDirectWideFixed(cUnit, arg1, rARG2, rARG3);
-        }
+      loadValueDirectWideFixed(cUnit, arg1, rARG1, rARG2);
     }
-    oatClobberCalleeSave(cUnit);
+  } else {
+    loadValueDirectWideFixed(cUnit, arg0, rARG0, rARG1);
+    if (arg1.wide == 0) {
+      loadValueDirectFixed(cUnit, arg1, rARG2);
+    } else {
+      loadValueDirectWideFixed(cUnit, arg1, rARG2, rARG3);
+    }
+  }
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset,
                              int arg0, int arg1) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    DCHECK_NE((int)rARG0, arg1);  // check copy into arg0 won't clobber arg1
-    opRegCopy(cUnit, rARG0, arg0);
-    opRegCopy(cUnit, rARG1, arg1);
-    oatClobberCalleeSave(cUnit);
+  DCHECK_NE((int)rARG0, arg1);  // check copy into arg0 won't clobber arg1
+  opRegCopy(cUnit, rARG0, arg0);
+  opRegCopy(cUnit, rARG1, arg1);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperRegRegImm(CompilationUnit* cUnit, int helperOffset,
                                 int arg0, int arg1, int arg2) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    DCHECK_NE((int)rARG0, arg1);  // check copy into arg0 won't clobber arg1
-    opRegCopy(cUnit, rARG0, arg0);
-    opRegCopy(cUnit, rARG1, arg1);
-    loadConstant(cUnit, rARG2, arg2);
-    oatClobberCalleeSave(cUnit);
+  DCHECK_NE((int)rARG0, arg1);  // check copy into arg0 won't clobber arg1
+  opRegCopy(cUnit, rARG0, arg0);
+  opRegCopy(cUnit, rARG1, arg1);
+  loadConstant(cUnit, rARG2, arg2);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
-void callRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit, int helperOffset,
-                                           int arg0, RegLocation arg2) {
+void callRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit,
+                                           int helperOffset,
+                       int arg0, RegLocation arg2) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadValueDirectFixed(cUnit, arg2, rARG2);
-    loadCurrMethodDirect(cUnit, rARG1);
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  loadValueDirectFixed(cUnit, arg2, rARG2);
+  loadCurrMethodDirect(cUnit, rARG1);
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
 void callRuntimeHelperImmMethodImm(CompilationUnit* cUnit, int helperOffset,
                                    int arg0, int arg2) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadCurrMethodDirect(cUnit, rARG1);
-    loadConstant(cUnit, rARG2, arg2);
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  loadCurrMethodDirect(cUnit, rARG1);
+  loadConstant(cUnit, rARG2, arg2);
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
@@ -283,21 +284,21 @@
                                                 int arg0, RegLocation arg1,
                                                 RegLocation arg2) {
 #if !defined(TARGET_X86)
-    int rTgt = loadHelper(cUnit, helperOffset);
+  int rTgt = loadHelper(cUnit, helperOffset);
 #endif
-    loadValueDirectFixed(cUnit, arg1, rARG1);
-    if (arg2.wide == 0) {
-        loadValueDirectFixed(cUnit, arg2, rARG2);
-    } else {
-        loadValueDirectWideFixed(cUnit, arg2, rARG2, rARG3);
-    }
-    loadConstant(cUnit, rARG0, arg0);
-    oatClobberCalleeSave(cUnit);
+  loadValueDirectFixed(cUnit, arg1, rARG1);
+  if (arg2.wide == 0) {
+    loadValueDirectFixed(cUnit, arg2, rARG2);
+  } else {
+    loadValueDirectWideFixed(cUnit, arg2, rARG2, rARG3);
+  }
+  loadConstant(cUnit, rARG0, arg0);
+  oatClobberCalleeSave(cUnit);
 #if !defined(TARGET_X86)
-    opReg(cUnit, kOpBlx, rTgt);
-    oatFreeTemp(cUnit, rTgt);
+  opReg(cUnit, kOpBlx, rTgt);
+  oatFreeTemp(cUnit, rTgt);
 #else
-    opThreadMem(cUnit, kOpBlx, helperOffset);
+  opThreadMem(cUnit, kOpBlx, helperOffset);
 #endif
 }
 
@@ -307,18 +308,18 @@
  */
 void genBarrier(CompilationUnit* cUnit)
 {
-    LIR* barrier = newLIR0(cUnit, kPseudoBarrier);
-    /* Mark all resources as being clobbered */
-    barrier->defMask = -1;
+  LIR* barrier = newLIR0(cUnit, kPseudoBarrier);
+  /* Mark all resources as being clobbered */
+  barrier->defMask = -1;
 }
 
 
 /* Generate unconditional branch instructions */
 LIR* opUnconditionalBranch(CompilationUnit* cUnit, LIR* target)
 {
-    LIR* branch = opBranchUnconditional(cUnit, kOpUncondBr);
-    branch->target = (LIR*) target;
-    return branch;
+  LIR* branch = opBranchUnconditional(cUnit, kOpUncondBr);
+  branch->target = (LIR*) target;
+  return branch;
 }
 
 // FIXME: need to do some work to split out targets with
@@ -327,170 +328,169 @@
 LIR* genCheck(CompilationUnit* cUnit, ConditionCode cCode, MIR* mir,
               ThrowKind kind)
 {
-    LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
-                      mir ? mir->offset : 0);
-    LIR* branch = opCondBranch(cUnit, cCode, tgt);
-    // Remember branch target - will process later
-    oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
-    return branch;
+  LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+                    mir ? mir->offset : 0);
+  LIR* branch = opCondBranch(cUnit, cCode, tgt);
+  // Remember branch target - will process later
+  oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
+  return branch;
 }
 #endif
 
 LIR* genImmedCheck(CompilationUnit* cUnit, ConditionCode cCode,
                    int reg, int immVal, MIR* mir, ThrowKind kind)
 {
-    LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind, mir->offset);
-    LIR* branch;
-    if (cCode == kCondAl) {
-        branch = opUnconditionalBranch(cUnit, tgt);
-    } else {
-        branch = opCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
-    }
-    // Remember branch target - will process later
-    oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
-    return branch;
+  LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind, mir->offset);
+  LIR* branch;
+  if (cCode == kCondAl) {
+    branch = opUnconditionalBranch(cUnit, tgt);
+  } else {
+    branch = opCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
+  }
+  // Remember branch target - will process later
+  oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
+  return branch;
 }
 
 /* Perform null-check on a register.  */
 LIR* genNullCheck(CompilationUnit* cUnit, int sReg, int mReg, MIR* mir)
 {
-    if (!(cUnit->disableOpt & (1 << kNullCheckElimination)) &&
-        mir->optimizationFlags & MIR_IGNORE_NULL_CHECK) {
-        return NULL;
-    }
-    return genImmedCheck(cUnit, kCondEq, mReg, 0, mir, kThrowNullPointer);
+  if (!(cUnit->disableOpt & (1 << kNullCheckElimination)) &&
+    mir->optimizationFlags & MIR_IGNORE_NULL_CHECK) {
+    return NULL;
+  }
+  return genImmedCheck(cUnit, kCondEq, mReg, 0, mir, kThrowNullPointer);
 }
 
 /* Perform check on two registers */
 LIR* genRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode,
-                     int reg1, int reg2, MIR* mir, ThrowKind kind)
+                    int reg1, int reg2, MIR* mir, ThrowKind kind)
 {
-    LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
-                      mir ? mir->offset : 0, reg1, reg2);
+  LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+                    mir ? mir->offset : 0, reg1, reg2);
 #if defined(TARGET_MIPS)
-    LIR* branch = opCmpBranch(cUnit, cCode, reg1, reg2, tgt);
+  LIR* branch = opCmpBranch(cUnit, cCode, reg1, reg2, tgt);
 #else
-    opRegReg(cUnit, kOpCmp, reg1, reg2);
-    LIR* branch = opCondBranch(cUnit, cCode, tgt);
+  opRegReg(cUnit, kOpCmp, reg1, reg2);
+  LIR* branch = opCondBranch(cUnit, cCode, tgt);
 #endif
-    // Remember branch target - will process later
-    oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
-    return branch;
+  // Remember branch target - will process later
+  oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, (intptr_t)tgt);
+  return branch;
 }
 
 void genCompareAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
                          RegLocation rlSrc1, RegLocation rlSrc2, LIR* labelList)
 {
-    ConditionCode cond;
-    rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
-    rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
-    Instruction::Code opcode = mir->dalvikInsn.opcode;
-    switch (opcode) {
-        case Instruction::IF_EQ:
-            cond = kCondEq;
-            break;
-        case Instruction::IF_NE:
-            cond = kCondNe;
-            break;
-        case Instruction::IF_LT:
-            cond = kCondLt;
-            break;
-        case Instruction::IF_GE:
-            cond = kCondGe;
-            break;
-        case Instruction::IF_GT:
-            cond = kCondGt;
-            break;
-        case Instruction::IF_LE:
-            cond = kCondLe;
-            break;
-        default:
-            cond = (ConditionCode)0;
-            LOG(FATAL) << "Unexpected opcode " << (int)opcode;
-    }
+  ConditionCode cond;
+  rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
+  rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
+  Instruction::Code opcode = mir->dalvikInsn.opcode;
+  switch (opcode) {
+    case Instruction::IF_EQ:
+      cond = kCondEq;
+      break;
+    case Instruction::IF_NE:
+      cond = kCondNe;
+      break;
+    case Instruction::IF_LT:
+      cond = kCondLt;
+      break;
+    case Instruction::IF_GE:
+      cond = kCondGe;
+      break;
+    case Instruction::IF_GT:
+      cond = kCondGt;
+      break;
+    case Instruction::IF_LE:
+      cond = kCondLe;
+      break;
+    default:
+      cond = (ConditionCode)0;
+      LOG(FATAL) << "Unexpected opcode " << (int)opcode;
+  }
 #if defined(TARGET_MIPS)
-    opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg,
-                &labelList[bb->taken->id]);
+  opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg,
+              &labelList[bb->taken->id]);
 #else
-    opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
-    opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
+  opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
+  opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
 #endif
-    opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+  opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
 }
 
 void genCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
                              RegLocation rlSrc, LIR* labelList)
 {
-    ConditionCode cond;
-    rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
-    Instruction::Code opcode = mir->dalvikInsn.opcode;
-    switch (opcode) {
-        case Instruction::IF_EQZ:
-            cond = kCondEq;
-            break;
-        case Instruction::IF_NEZ:
-            cond = kCondNe;
-            break;
-        case Instruction::IF_LTZ:
-            cond = kCondLt;
-            break;
-        case Instruction::IF_GEZ:
-            cond = kCondGe;
-            break;
-        case Instruction::IF_GTZ:
-            cond = kCondGt;
-            break;
-        case Instruction::IF_LEZ:
-            cond = kCondLe;
-            break;
-        default:
-            cond = (ConditionCode)0;
-            LOG(FATAL) << "Unexpected opcode " << (int)opcode;
-    }
+  ConditionCode cond;
+  rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+  Instruction::Code opcode = mir->dalvikInsn.opcode;
+  switch (opcode) {
+    case Instruction::IF_EQZ:
+      cond = kCondEq;
+      break;
+    case Instruction::IF_NEZ:
+      cond = kCondNe;
+      break;
+    case Instruction::IF_LTZ:
+      cond = kCondLt;
+      break;
+    case Instruction::IF_GEZ:
+      cond = kCondGe;
+      break;
+    case Instruction::IF_GTZ:
+      cond = kCondGt;
+      break;
+    case Instruction::IF_LEZ:
+      cond = kCondLe;
+      break;
+    default:
+      cond = (ConditionCode)0;
+      LOG(FATAL) << "Unexpected opcode " << (int)opcode;
+  }
 #if defined(TARGET_MIPS) || defined(TARGET_X86)
-    opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, &labelList[bb->taken->id]);
+  opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, &labelList[bb->taken->id]);
 #else
-    opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
-    opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
+  opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
+  opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
 #endif
-    opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+  opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
 }
 
 void genIntToLong(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
                   RegLocation rlSrc)
 {
-    RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
-    if (rlSrc.location == kLocPhysReg) {
-        opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
-    } else {
-        loadValueDirect(cUnit, rlSrc, rlResult.lowReg);
-    }
-    opRegRegImm(cUnit, kOpAsr, rlResult.highReg,
-                rlResult.lowReg, 31);
-    storeValueWide(cUnit, rlDest, rlResult);
+  RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+  if (rlSrc.location == kLocPhysReg) {
+    opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
+  } else {
+    loadValueDirect(cUnit, rlSrc, rlResult.lowReg);
+  }
+  opRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
+  storeValueWide(cUnit, rlDest, rlResult);
 }
 
 void genIntNarrowing(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
                      RegLocation rlSrc)
 {
-     rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
-     RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
-     OpKind op = kOpInvalid;
-     switch (mir->dalvikInsn.opcode) {
-         case Instruction::INT_TO_BYTE:
-             op = kOp2Byte;
-             break;
-         case Instruction::INT_TO_SHORT:
-              op = kOp2Short;
-              break;
-         case Instruction::INT_TO_CHAR:
-              op = kOp2Char;
-              break;
-         default:
-             LOG(ERROR) << "Bad int conversion type";
-     }
-     opRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
-     storeValue(cUnit, rlDest, rlResult);
+   rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+   RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+   OpKind op = kOpInvalid;
+   switch (mir->dalvikInsn.opcode) {
+     case Instruction::INT_TO_BYTE:
+       op = kOp2Byte;
+       break;
+     case Instruction::INT_TO_SHORT:
+        op = kOp2Short;
+        break;
+     case Instruction::INT_TO_CHAR:
+        op = kOp2Char;
+        break;
+     default:
+       LOG(ERROR) << "Bad int conversion type";
+   }
+   opRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
+   storeValue(cUnit, rlDest, rlResult);
 }
 
 /*
@@ -501,20 +501,20 @@
 void genNewArray(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
                  RegLocation rlSrc)
 {
-    oatFlushAllRegs(cUnit);    /* Everything to home location */
-    uint32_t type_idx = mir->dalvikInsn.vC;
-    int funcOffset;
-    if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                    cUnit->dex_cache,
-                                                    *cUnit->dex_file,
-                                                    type_idx)) {
-        funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
-    } else {
-        funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
-    }
-    callRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc);
-    RegLocation rlResult = oatGetReturn(cUnit, false);
-    storeValue(cUnit, rlDest, rlResult);
+  oatFlushAllRegs(cUnit);  /* Everything to home location */
+  uint32_t type_idx = mir->dalvikInsn.vC;
+  int funcOffset;
+  if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
+                                                  cUnit->dex_cache,
+                                                  *cUnit->dex_file,
+                                                  type_idx)) {
+    funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
+  } else {
+    funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
+  }
+  callRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc);
+  RegLocation rlResult = oatGetReturn(cUnit, false);
+  storeValue(cUnit, rlDest, rlResult);
 }
 
 /*
@@ -525,302 +525,299 @@
  */
 void genFilledNewArray(CompilationUnit* cUnit, MIR* mir, bool isRange)
 {
-    DecodedInstruction* dInsn = &mir->dalvikInsn;
-    int elems = dInsn->vA;
-    int typeIdx = dInsn->vB;
-    oatFlushAllRegs(cUnit);    /* Everything to home location */
-    int funcOffset;
-    if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                    cUnit->dex_cache,
-                                                    *cUnit->dex_file,
-                                                    typeIdx)) {
-        funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
-    } else {
-        funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
-    }
-    callRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems);
-    oatFreeTemp(cUnit, rARG2);
-    oatFreeTemp(cUnit, rARG1);
+  DecodedInstruction* dInsn = &mir->dalvikInsn;
+  int elems = dInsn->vA;
+  int typeIdx = dInsn->vB;
+  oatFlushAllRegs(cUnit);  /* Everything to home location */
+  int funcOffset;
+  if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
+                                                  cUnit->dex_cache,
+                                                  *cUnit->dex_file,
+                                                  typeIdx)) {
+    funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
+  } else {
+    funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
+  }
+  callRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems);
+  oatFreeTemp(cUnit, rARG2);
+  oatFreeTemp(cUnit, rARG1);
+  /*
+   * NOTE: the implicit target for Instruction::FILLED_NEW_ARRAY is the
+   * return region.  Because AllocFromCode placed the new array
+   * in rRET0, we'll just lock it into place.  When debugger support is
+   * added, it may be necessary to additionally copy all return
+   * values to a home location in thread-local storage
+   */
+  oatLockTemp(cUnit, rRET0);
+
+  // TODO: use the correct component size, currently all supported types
+  // share array alignment with ints (see comment at head of function)
+  size_t component_size = sizeof(int32_t);
+
+  // Having a range of 0 is legal
+  if (isRange && (dInsn->vA > 0)) {
     /*
-     * NOTE: the implicit target for Instruction::FILLED_NEW_ARRAY is the
-     * return region.  Because AllocFromCode placed the new array
-     * in rRET0, we'll just lock it into place.  When debugger support is
-     * added, it may be necessary to additionally copy all return
-     * values to a home location in thread-local storage
+     * Bit of ugliness here.  We're going generate a mem copy loop
+     * on the register range, but it is possible that some regs
+     * in the range have been promoted.  This is unlikely, but
+     * before generating the copy, we'll just force a flush
+     * of any regs in the source range that have been promoted to
+     * home location.
      */
-    oatLockTemp(cUnit, rRET0);
-
-    // TODO: use the correct component size, currently all supported types
-    // share array alignment with ints (see comment at head of function)
-    size_t component_size = sizeof(int32_t);
-
-    // Having a range of 0 is legal
-    if (isRange && (dInsn->vA > 0)) {
-        /*
-         * Bit of ugliness here.  We're going generate a mem copy loop
-         * on the register range, but it is possible that some regs
-         * in the range have been promoted.  This is unlikely, but
-         * before generating the copy, we'll just force a flush
-         * of any regs in the source range that have been promoted to
-         * home location.
-         */
-        for (unsigned int i = 0; i < dInsn->vA; i++) {
-            RegLocation loc = oatUpdateLoc(cUnit,
-                oatGetSrc(cUnit, mir, i));
-            if (loc.location == kLocPhysReg) {
-                storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, loc.sRegLow),
-                              loc.lowReg, kWord);
-            }
-        }
-        /*
-         * TUNING note: generated code here could be much improved, but
-         * this is an uncommon operation and isn't especially performance
-         * critical.
-         */
-        int rSrc = oatAllocTemp(cUnit);
-        int rDst = oatAllocTemp(cUnit);
-        int rIdx = oatAllocTemp(cUnit);
-#if defined(TARGET_ARM)
-        int rVal = rLR;  // Using a lot of temps, rLR is known free here
-#elif defined(TARGET_X86)
-        int rVal = rSrc;
-#else
-        int rVal = oatAllocTemp(cUnit);
-#endif
-        // Set up source pointer
-        RegLocation rlFirst = oatGetSrc(cUnit, mir, 0);
-        opRegRegImm(cUnit, kOpAdd, rSrc, rSP,
-                    oatSRegOffset(cUnit, rlFirst.sRegLow));
-        // Set up the target pointer
-        opRegRegImm(cUnit, kOpAdd, rDst, rRET0,
-                    Array::DataOffset(component_size).Int32Value());
-        // Set up the loop counter (known to be > 0)
-        loadConstant(cUnit, rIdx, dInsn->vA - 1);
-        // Generate the copy loop.  Going backwards for convenience
-        LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
-        // Copy next element
-        loadBaseIndexed(cUnit, rSrc, rIdx, rVal, 2, kWord);
-        storeBaseIndexed(cUnit, rDst, rIdx, rVal, 2, kWord);
-#if defined(TARGET_ARM)
-        // Combine sub & test using sub setflags encoding here
-        newLIR3(cUnit, kThumb2SubsRRI12, rIdx, rIdx, 1);
-        opCondBranch(cUnit, kCondGe, target);
-#else
-        oatFreeTemp(cUnit, rVal);
-        opRegImm(cUnit, kOpSub, rIdx, 1);
-        opCmpImmBranch(cUnit, kCondGe, rIdx, 0, target);
-#endif
-    } else if (!isRange) {
-        // TUNING: interleave
-        for (unsigned int i = 0; i < dInsn->vA; i++) {
-            RegLocation rlArg = loadValue(cUnit,
-                oatGetSrc(cUnit, mir, i), kCoreReg);
-            storeBaseDisp(cUnit, rRET0,
-                          Array::DataOffset(component_size).Int32Value() +
-                          i * 4, rlArg.lowReg, kWord);
-            // If the loadValue caused a temp to be allocated, free it
-            if (oatIsTemp(cUnit, rlArg.lowReg)) {
-                oatFreeTemp(cUnit, rlArg.lowReg);
-            }
-        }
+    for (unsigned int i = 0; i < dInsn->vA; i++) {
+      RegLocation loc = oatUpdateLoc(cUnit, oatGetSrc(cUnit, mir, i));
+      if (loc.location == kLocPhysReg) {
+        storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, loc.sRegLow),
+                      loc.lowReg, kWord);
+      }
     }
+    /*
+     * TUNING note: generated code here could be much improved, but
+     * this is an uncommon operation and isn't especially performance
+     * critical.
+     */
+    int rSrc = oatAllocTemp(cUnit);
+    int rDst = oatAllocTemp(cUnit);
+    int rIdx = oatAllocTemp(cUnit);
+#if defined(TARGET_ARM)
+    int rVal = rLR;  // Using a lot of temps, rLR is known free here
+#elif defined(TARGET_X86)
+    int rVal = rSrc;
+#else
+    int rVal = oatAllocTemp(cUnit);
+#endif
+    // Set up source pointer
+    RegLocation rlFirst = oatGetSrc(cUnit, mir, 0);
+    opRegRegImm(cUnit, kOpAdd, rSrc, rSP,
+                oatSRegOffset(cUnit, rlFirst.sRegLow));
+    // Set up the target pointer
+    opRegRegImm(cUnit, kOpAdd, rDst, rRET0,
+                Array::DataOffset(component_size).Int32Value());
+    // Set up the loop counter (known to be > 0)
+    loadConstant(cUnit, rIdx, dInsn->vA - 1);
+    // Generate the copy loop.  Going backwards for convenience
+    LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+    // Copy next element
+    loadBaseIndexed(cUnit, rSrc, rIdx, rVal, 2, kWord);
+    storeBaseIndexed(cUnit, rDst, rIdx, rVal, 2, kWord);
+#if defined(TARGET_ARM)
+    // Combine sub & test using sub setflags encoding here
+    newLIR3(cUnit, kThumb2SubsRRI12, rIdx, rIdx, 1);
+    opCondBranch(cUnit, kCondGe, target);
+#else
+    oatFreeTemp(cUnit, rVal);
+    opRegImm(cUnit, kOpSub, rIdx, 1);
+    opCmpImmBranch(cUnit, kCondGe, rIdx, 0, target);
+#endif
+  } else if (!isRange) {
+    // TUNING: interleave
+    for (unsigned int i = 0; i < dInsn->vA; i++) {
+      RegLocation rlArg = loadValue(cUnit, oatGetSrc(cUnit, mir, i), kCoreReg);
+      storeBaseDisp(cUnit, rRET0,
+                    Array::DataOffset(component_size).Int32Value() +
+                    i * 4, rlArg.lowReg, kWord);
+      // If the loadValue caused a temp to be allocated, free it
+      if (oatIsTemp(cUnit, rlArg.lowReg)) {
+        oatFreeTemp(cUnit, rlArg.lowReg);
+      }
+    }
+  }
 }
 
 void genSput(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc,
-             bool isLongOrDouble, bool isObject)
+       bool isLongOrDouble, bool isObject)
 {
-    int fieldOffset;
-    int ssbIndex;
-    bool isVolatile;
-    bool isReferrersClass;
-    uint32_t fieldIdx = mir->dalvikInsn.vB;
+  int fieldOffset;
+  int ssbIndex;
+  bool isVolatile;
+  bool isReferrersClass;
+  uint32_t fieldIdx = mir->dalvikInsn.vB;
 
-    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);
 
-    bool fastPath =
-        cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
-                                                fieldOffset, ssbIndex,
-                                                isReferrersClass, isVolatile, true);
-    if (fastPath && !SLOW_FIELD_PATH) {
-        DCHECK_GE(fieldOffset, 0);
-        int rBase;
-        if (isReferrersClass) {
-            // Fast path, static storage base is this method's class
-            RegLocation rlMethod  = loadCurrMethod(cUnit);
-            rBase = oatAllocTemp(cUnit);
-            loadWordDisp(cUnit, rlMethod.lowReg,
-                         Method::DeclaringClassOffset().Int32Value(), rBase);
-            if (oatIsTemp(cUnit, rlMethod.lowReg)) {
-                oatFreeTemp(cUnit, rlMethod.lowReg);
-            }
-        } else {
-            // Medium path, static storage base in a different class which
-            // requires checks that the other class is initialized.
-            DCHECK_GE(ssbIndex, 0);
-            // May do runtime call so everything to home locations.
-            oatFlushAllRegs(cUnit);
-            // Using fixed register to sync with possible call to runtime
-            // support.
-            int rMethod = rARG1;
-            oatLockTemp(cUnit, rMethod);
-            loadCurrMethodDirect(cUnit, rMethod);
-            rBase = rARG0;
-            oatLockTemp(cUnit, rBase);
-            loadWordDisp(cUnit, rMethod,
-                Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
-                rBase);
-            loadWordDisp(cUnit, rBase,
-                         Array::DataOffset(sizeof(Object*)).Int32Value() + sizeof(int32_t*) *
-                         ssbIndex, rBase);
-            // rBase now points at appropriate static storage base (Class*)
-            // or NULL if not initialized. Check for NULL and call helper if NULL.
-            // TUNING: fast path should fall through
-            LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
-            loadConstant(cUnit, rARG0, ssbIndex);
-            callRuntimeHelperImm(cUnit,
-                                 ENTRYPOINT_OFFSET(pInitializeStaticStorage),
-                                 ssbIndex);
-#if defined(TARGET_MIPS)
-            // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
-            opRegCopy(cUnit, rBase, rRET0);
-#endif
-            LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
-            branchOver->target = (LIR*)skipTarget;
-            oatFreeTemp(cUnit, rMethod);
-        }
-        // rBase now holds static storage base
-        if (isLongOrDouble) {
-            rlSrc = oatGetSrcWide(cUnit, mir, 0, 1);
-            rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
-        } else {
-            rlSrc = oatGetSrc(cUnit, mir, 0);
-            rlSrc = loadValue(cUnit, rlSrc, kAnyReg);
-        }
-//FIXME: need to generalize the barrier call
-        if (isVolatile) {
-            oatGenMemBarrier(cUnit, kST);
-        }
-        if (isLongOrDouble) {
-            storeBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
-                              rlSrc.highReg);
-        } else {
-            storeWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
-        }
-        if (isVolatile) {
-            oatGenMemBarrier(cUnit, kSY);
-        }
-        if (isObject) {
-            markGCCard(cUnit, rlSrc.lowReg, rBase);
-        }
-        oatFreeTemp(cUnit, rBase);
+  bool fastPath =
+      cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
+                                              fieldOffset, ssbIndex,
+                                              isReferrersClass, isVolatile,
+                                              true);
+  if (fastPath && !SLOW_FIELD_PATH) {
+    DCHECK_GE(fieldOffset, 0);
+    int rBase;
+    if (isReferrersClass) {
+      // Fast path, static storage base is this method's class
+      RegLocation rlMethod  = loadCurrMethod(cUnit);
+      rBase = oatAllocTemp(cUnit);
+      loadWordDisp(cUnit, rlMethod.lowReg,
+                   Method::DeclaringClassOffset().Int32Value(), rBase);
+      if (oatIsTemp(cUnit, rlMethod.lowReg)) {
+        oatFreeTemp(cUnit, rlMethod.lowReg);
+      }
     } else {
-        oatFlushAllRegs(cUnit);  // Everything to home locations
-        int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Static) :
-                           (isObject ? ENTRYPOINT_OFFSET(pSetObjStatic)
-                                     : ENTRYPOINT_OFFSET(pSet32Static));
-        callRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc);
+      // Medium path, static storage base in a different class which
+      // requires checks that the other class is initialized.
+      DCHECK_GE(ssbIndex, 0);
+      // May do runtime call so everything to home locations.
+      oatFlushAllRegs(cUnit);
+      // Using fixed register to sync with possible call to runtime
+      // support.
+      int rMethod = rARG1;
+      oatLockTemp(cUnit, rMethod);
+      loadCurrMethodDirect(cUnit, rMethod);
+      rBase = rARG0;
+      oatLockTemp(cUnit, rBase);
+      loadWordDisp(cUnit, rMethod,
+                   Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
+                   rBase);
+      loadWordDisp(cUnit, rBase,
+                   Array::DataOffset(sizeof(Object*)).Int32Value() +
+                   sizeof(int32_t*) * ssbIndex, rBase);
+      // rBase now points at appropriate static storage base (Class*)
+      // or NULL if not initialized. Check for NULL and call helper if NULL.
+      // TUNING: fast path should fall through
+      LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
+      loadConstant(cUnit, rARG0, ssbIndex);
+      callRuntimeHelperImm(cUnit,
+                           ENTRYPOINT_OFFSET(pInitializeStaticStorage),
+                           ssbIndex);
+#if defined(TARGET_MIPS)
+      // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
+      opRegCopy(cUnit, rBase, rRET0);
+#endif
+      LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
+      branchOver->target = (LIR*)skipTarget;
+      oatFreeTemp(cUnit, rMethod);
     }
+    // rBase now holds static storage base
+    if (isLongOrDouble) {
+      rlSrc = oatGetSrcWide(cUnit, mir, 0, 1);
+      rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
+    } else {
+      rlSrc = oatGetSrc(cUnit, mir, 0);
+      rlSrc = loadValue(cUnit, rlSrc, kAnyReg);
+    }
+//FIXME: need to generalize the barrier call
+    if (isVolatile) {
+      oatGenMemBarrier(cUnit, kST);
+    }
+    if (isLongOrDouble) {
+      storeBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
+                        rlSrc.highReg);
+    } else {
+      storeWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
+    }
+    if (isVolatile) {
+      oatGenMemBarrier(cUnit, kSY);
+    }
+    if (isObject) {
+      markGCCard(cUnit, rlSrc.lowReg, rBase);
+    }
+    oatFreeTemp(cUnit, rBase);
+  } else {
+    oatFlushAllRegs(cUnit);  // Everything to home locations
+    int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Static) :
+        (isObject ? ENTRYPOINT_OFFSET(pSetObjStatic)
+        : ENTRYPOINT_OFFSET(pSet32Static));
+    callRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc);
+  }
 }
 
 void genSget(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
-             bool isLongOrDouble, bool isObject)
+       bool isLongOrDouble, bool isObject)
 {
-    int fieldOffset;
-    int ssbIndex;
-    bool isVolatile;
-    bool isReferrersClass;
-    uint32_t fieldIdx = mir->dalvikInsn.vB;
+  int fieldOffset;
+  int ssbIndex;
+  bool isVolatile;
+  bool isReferrersClass;
+  uint32_t fieldIdx = mir->dalvikInsn.vB;
 
-    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);
 
-    bool fastPath =
-        cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
-                                                fieldOffset, ssbIndex,
-                                                isReferrersClass, isVolatile,
-                                                false);
-    if (fastPath && !SLOW_FIELD_PATH) {
-        DCHECK_GE(fieldOffset, 0);
-        int rBase;
-        if (isReferrersClass) {
-            // Fast path, static storage base is this method's class
-            RegLocation rlMethod  = loadCurrMethod(cUnit);
-            rBase = oatAllocTemp(cUnit);
-            loadWordDisp(cUnit, rlMethod.lowReg,
-                         Method::DeclaringClassOffset().Int32Value(), rBase);
-        } else {
-            // Medium path, static storage base in a different class which
-            // requires checks that the other class is initialized
-            DCHECK_GE(ssbIndex, 0);
-            // May do runtime call so everything to home locations.
-            oatFlushAllRegs(cUnit);
-            // Using fixed register to sync with possible call to runtime
-            // support
-            int rMethod = rARG1;
-            oatLockTemp(cUnit, rMethod);
-            loadCurrMethodDirect(cUnit, rMethod);
-            rBase = rARG0;
-            oatLockTemp(cUnit, rBase);
-            loadWordDisp(cUnit, rMethod,
-                Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
-                rBase);
-            loadWordDisp(cUnit, rBase,
-                         Array::DataOffset(sizeof(Object*)).Int32Value() +
-                         sizeof(int32_t*) * ssbIndex,
-                         rBase);
-            // rBase now points at appropriate static storage base (Class*)
-            // or NULL if not initialized. Check for NULL and call helper if NULL.
-            // TUNING: fast path should fall through
-            LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
-            callRuntimeHelperImm(cUnit,
-                                 ENTRYPOINT_OFFSET(pInitializeStaticStorage),
-                                 ssbIndex);
-#if defined(TARGET_MIPS)
-            // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
-            opRegCopy(cUnit, rBase, rRET0);
-#endif
-            LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
-            branchOver->target = (LIR*)skipTarget;
-            oatFreeTemp(cUnit, rMethod);
-        }
-        // rBase now holds static storage base
-        rlDest = isLongOrDouble ? oatGetDestWide(cUnit, mir, 0, 1)
-                                : oatGetDest(cUnit, mir, 0);
-        RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-        if (isVolatile) {
-            oatGenMemBarrier(cUnit, kSY);
-        }
-        if (isLongOrDouble) {
-            loadBaseDispWide(cUnit, NULL, rBase, fieldOffset, rlResult.lowReg,
-                             rlResult.highReg, INVALID_SREG);
-        } else {
-            loadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
-        }
-        oatFreeTemp(cUnit, rBase);
-        if (isLongOrDouble) {
-            storeValueWide(cUnit, rlDest, rlResult);
-        } else {
-            storeValue(cUnit, rlDest, rlResult);
-        }
+  bool fastPath =
+    cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
+                                            fieldOffset, ssbIndex,
+                                            isReferrersClass, isVolatile,
+                                            false);
+  if (fastPath && !SLOW_FIELD_PATH) {
+    DCHECK_GE(fieldOffset, 0);
+    int rBase;
+    if (isReferrersClass) {
+      // Fast path, static storage base is this method's class
+      RegLocation rlMethod  = loadCurrMethod(cUnit);
+      rBase = oatAllocTemp(cUnit);
+      loadWordDisp(cUnit, rlMethod.lowReg,
+                   Method::DeclaringClassOffset().Int32Value(), rBase);
     } else {
-        oatFlushAllRegs(cUnit);  // Everything to home locations
-        int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Static) :
-                           (isObject ? ENTRYPOINT_OFFSET(pGetObjStatic)
-                                     : ENTRYPOINT_OFFSET(pGet32Static));
-        callRuntimeHelperImm(cUnit, getterOffset, fieldIdx);
-        if (isLongOrDouble) {
-            RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
-            storeValueWide(cUnit, rlDest, rlResult);
-        } else {
-            RegLocation rlResult = oatGetReturn(cUnit, rlDest.fp);
-            storeValue(cUnit, rlDest, rlResult);
-        }
+      // Medium path, static storage base in a different class which
+      // requires checks that the other class is initialized
+      DCHECK_GE(ssbIndex, 0);
+      // May do runtime call so everything to home locations.
+      oatFlushAllRegs(cUnit);
+      // Using fixed register to sync with possible call to runtime
+      // support
+      int rMethod = rARG1;
+      oatLockTemp(cUnit, rMethod);
+      loadCurrMethodDirect(cUnit, rMethod);
+      rBase = rARG0;
+      oatLockTemp(cUnit, rBase);
+      loadWordDisp(cUnit, rMethod,
+                   Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
+                   rBase);
+      loadWordDisp(cUnit, rBase,
+                   Array::DataOffset(sizeof(Object*)).Int32Value() +
+                   sizeof(int32_t*) * ssbIndex, rBase);
+      // rBase now points at appropriate static storage base (Class*)
+      // or NULL if not initialized. Check for NULL and call helper if NULL.
+      // TUNING: fast path should fall through
+      LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
+      callRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeStaticStorage),
+                           ssbIndex);
+#if defined(TARGET_MIPS)
+      // For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
+      opRegCopy(cUnit, rBase, rRET0);
+#endif
+      LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
+      branchOver->target = (LIR*)skipTarget;
+      oatFreeTemp(cUnit, rMethod);
     }
+    // rBase now holds static storage base
+    rlDest = isLongOrDouble ? oatGetDestWide(cUnit, mir, 0, 1)
+        : oatGetDest(cUnit, mir, 0);
+    RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+    if (isVolatile) {
+      oatGenMemBarrier(cUnit, kSY);
+    }
+    if (isLongOrDouble) {
+      loadBaseDispWide(cUnit, NULL, rBase, fieldOffset, rlResult.lowReg,
+                       rlResult.highReg, INVALID_SREG);
+    } else {
+      loadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
+    }
+    oatFreeTemp(cUnit, rBase);
+    if (isLongOrDouble) {
+      storeValueWide(cUnit, rlDest, rlResult);
+    } else {
+      storeValue(cUnit, rlDest, rlResult);
+    }
+  } else {
+    oatFlushAllRegs(cUnit);  // Everyt