diff --git a/src/compiler.cc b/src/compiler.cc
index a04a836..a3bb985 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -466,7 +466,7 @@
     CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
   }
   uint64_t duration_ns = NanoTime() - start_ns;
-  if (duration_ns > MsToNs(10)) {
+  if (duration_ns > MsToNs(100)) {
     LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
                  << " took " << PrettyDuration(duration_ns);
   }
diff --git a/src/compiler/Compiler.h b/src/compiler/Compiler.h
index 05e05b6..909ac96 100644
--- a/src/compiler/Compiler.h
+++ b/src/compiler/Compiler.h
@@ -41,6 +41,62 @@
     kSkipLargeMethodOptimization,
 };
 
+/* Type of allocation for memory tuning */
+enum oatAllocKind {
+    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
+};
+
+/* 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
+};
+
 extern uint32_t compilerOptimizerDisableFlags;
 
 /* Force code generation paths for testing */
@@ -56,6 +112,7 @@
     kDebugSlowestStringPath,
     kDebugExerciseResolveMethod,
     kDebugVerifyDataflow,
+    kDebugShowMemoryUsage,
 };
 
 extern uint32_t compilerDebugFlags;
diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 1eb6c64..b17855b 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -66,12 +66,10 @@
  * benefit in optimizing these methods, and the cost can be very high.
  * We attempt to identify these cases, and avoid performing most dataflow
  * analysis.  Two thresholds are used - one for known initializers and one
- * for everything else.  Note: we require dataflow analysis for floating point
- * type inference. If any non-move fp operations exist in a method, dataflow
- * is performed regardless of block count.
+ * for everything else.
  */
-#define MANY_BLOCKS_INITIALIZER 200 /* Threshold for switching dataflow off */
-#define MANY_BLOCKS 3000 /* Non-initializer threshold */
+#define MANY_BLOCKS_INITIALIZER 1000 /* Threshold for switching dataflow off */
+#define MANY_BLOCKS 4000 /* Non-initializer threshold */
 
 typedef enum BBType {
     kEntryBlock,
@@ -175,7 +173,7 @@
     struct BasicBlock* taken;
     struct BasicBlock* iDom;            // Immediate dominator
     struct BasicBlockDataFlow* dataFlowInfo;
-    ArenaBitVector* predecessors;
+    GrowableList* predecessors;
     ArenaBitVector* dominators;
     ArenaBitVector* iDominated;         // Set nodes being immediately dominated
     ArenaBitVector* domFrontier;        // Dominance frontier
@@ -328,13 +326,13 @@
      GrowableList fillArrayData;
      const u2* insns;
      u4 insnsSize;
-     bool usesFP;          // Method contains at least 1 non-move FP operation
      bool disableDataflow; // Skip dataflow analysis if possible
      std::map<unsigned int, BasicBlock*> blockMap; // findBlock lookup cache
      std::map<unsigned int, LIR*> boundaryMap; // boundary lookup cache
+     int defCount;         // Used to estimate number of SSA names
 } CompilationUnit;
 
-BasicBlock* oatNewBB(BBType blockType, int blockId);
+BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId);
 
 void oatAppendMIR(BasicBlock* bb, MIR* mir);
 
diff --git a/src/compiler/CompilerUtility.h b/src/compiler/CompilerUtility.h
index a68ee5f..ba449a4 100644
--- a/src/compiler/CompilerUtility.h
+++ b/src/compiler/CompilerUtility.h
@@ -27,6 +27,9 @@
 /* Allocate the initial memory block for arena-based allocation */
 bool oatHeapInit(void);
 
+/* Collect memory usage statstics */
+//#define WITH_MEMSTATS
+
 typedef struct ArenaMemBlock {
     size_t blockSize;
     size_t bytesAllocated;
@@ -34,7 +37,7 @@
     char ptr[0];
 } ArenaMemBlock;
 
-void* oatNew(size_t size, bool zero);
+void* oatNew(size_t size, bool zero, oatAllocKind kind = kAllocMisc);
 
 void oatArenaReset(void);
 
@@ -42,6 +45,9 @@
     size_t numAllocated;
     size_t numUsed;
     intptr_t *elemList;
+#ifdef WITH_MEMSTATS
+    oatListKind kind;
+#endif
 } GrowableList;
 
 typedef struct GrowableListIterator {
@@ -58,20 +64,11 @@
  */
 struct ArenaBitVector {
     bool    expandable;     /* expand bitmap if we run out? */
-    bool    firstDirty;     /* when true, don't believe firstBitSet */
-    bool    lastDirty;      /* when true, don't believe lastBitSet */
     u4      storageSize;    /* current size, in 32-bit words */
     u4*     storage;
-                            /*
-                             * Opportunistically remember first and
-                             * last set bits.  This yeilds a performance
-                             * advantage in cases where large
-                             * sparse vectors are repeatedly scanned
-                             * (something that can happen a lot during
-                             * dataflow analysis.
-                             */
-    int     firstBitSet;
-    int     lastBitSet;
+#ifdef WITH_MEMSTATS
+    oatBitMapKind kind;      /* for memory use tuning */
+#endif
 };
 
 /* Handy iterator to walk through the bit positions set to 1 */
@@ -90,14 +87,17 @@
 struct BasicBlock;
 struct CompilationUnit;
 
-void oatInitGrowableList(GrowableList* gList, size_t initLength);
+void oatInitGrowableList(GrowableList* gList, size_t initLength,
+                         oatListKind kind = kListMisc);
 void oatInsertGrowableList(GrowableList* gList, intptr_t elem);
+void oatDeleteGrowableList(GrowableList* gList, intptr_t elem);
 void oatGrowableListIteratorInit(GrowableList* gList,
                                  GrowableListIterator* iterator);
 intptr_t oatGrowableListIteratorNext(GrowableListIterator* iterator);
 intptr_t oatGrowableListGetElement(const GrowableList* gList, size_t idx);
 
-ArenaBitVector* oatAllocBitVector(unsigned int startBits, bool expandable);
+ArenaBitVector* oatAllocBitVector(unsigned int startBits, bool expandable,
+                                  oatBitMapKind = kBitMapMisc);
 void oatBitVectorIteratorInit(ArenaBitVector* pBits,
                               ArenaBitVectorIterator* iterator);
 int oatBitVectorIteratorNext(ArenaBitVectorIterator* iterator);
@@ -125,6 +125,7 @@
 void oatGetBlockName(struct BasicBlock* bb, char* name);
 const char* oatGetShortyFromTargetIdx(CompilationUnit*, int);
 void oatDumpRegLocTable(struct RegLocation*, int);
+void oatDumpMemStats(CompilationUnit* cUnit);
 
 }  // namespace art
 
diff --git a/src/compiler/Dataflow.cc b/src/compiler/Dataflow.cc
index 3f88ea5..cd63290 100644
--- a/src/compiler/Dataflow.cc
+++ b/src/compiler/Dataflow.cc
@@ -900,7 +900,7 @@
         }
     }
     int length = strlen(buffer) + 1;
-    ret = (char*)oatNew(length, false);
+    ret = (char*)oatNew(length, false, kAllocDFInfo);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -1036,7 +1036,7 @@
 
 done:
     length = strlen(buffer) + 1;
-    ret = (char*) oatNew(length, false);
+    ret = (char*) oatNew(length, false, kAllocDFInfo);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -1078,7 +1078,7 @@
     }
 
     int length = strlen(buffer) + 1;
-    ret = (char*)oatNew(length, false);
+    ret = (char*)oatNew(length, false, kAllocDFInfo);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -1111,11 +1111,11 @@
     if (bb->dataFlowInfo == NULL) return false;
 
     useV = bb->dataFlowInfo->useV =
-        oatAllocBitVector(cUnit->numDalvikRegisters, false);
+        oatAllocBitVector(cUnit->numDalvikRegisters, false, kBitMapUse);
     defV = bb->dataFlowInfo->defV =
-        oatAllocBitVector(cUnit->numDalvikRegisters, false);
+        oatAllocBitVector(cUnit->numDalvikRegisters, false, kBitMapDef);
     liveInV = bb->dataFlowInfo->liveInV =
-        oatAllocBitVector(cUnit->numDalvikRegisters, false);
+        oatAllocBitVector(cUnit->numDalvikRegisters, false, kBitMapLiveIn);
 
     for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
         int dfAttributes =
@@ -1186,9 +1186,11 @@
     int i;
 
     mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = (int *)oatNew(sizeof(int) * numUses, true);
+    mir->ssaRep->uses = (int *)oatNew(sizeof(int) * numUses, true,
+                                      kAllocDFInfo);
     // NOTE: will be filled in during type & size inference pass
-    mir->ssaRep->fpUse = (bool *)oatNew(sizeof(bool) * numUses, true);
+    mir->ssaRep->fpUse = (bool *)oatNew(sizeof(bool) * numUses, true,
+                                        kAllocDFInfo);
 
     for (i = 0; i < numUses; i++) {
         handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
@@ -1203,9 +1205,11 @@
     int i;
 
     mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = (int *)oatNew(sizeof(int) * numUses, true);
+    mir->ssaRep->uses = (int *)oatNew(sizeof(int) * numUses, true,
+                                      kAllocDFInfo);
     // NOTE: will be filled in during type & size inference pass
-    mir->ssaRep->fpUse = (bool *)oatNew(sizeof(bool) * numUses, true);
+    mir->ssaRep->fpUse = (bool *)oatNew(sizeof(bool) * numUses, true,
+                                        kAllocDFInfo);
 
     for (i = 0; i < numUses; i++) {
         handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
@@ -1221,7 +1225,7 @@
 
     for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
         mir->ssaRep = (struct SSARepresentation *)
-            oatNew(sizeof(SSARepresentation), true);
+            oatNew(sizeof(SSARepresentation), true, kAllocDFInfo);
 
         int dfAttributes =
             oatDataFlowAttributes[mir->dalvikInsn.opcode];
@@ -1272,9 +1276,9 @@
         if (numUses) {
             mir->ssaRep->numUses = numUses;
             mir->ssaRep->uses = (int *)oatNew(sizeof(int) * numUses,
-                                                      false);
+                                              false, kAllocDFInfo);
             mir->ssaRep->fpUse = (bool *)oatNew(sizeof(bool) * numUses,
-                                                false);
+                                                false, kAllocDFInfo);
         }
 
         int numDefs = 0;
@@ -1289,9 +1293,9 @@
         if (numDefs) {
             mir->ssaRep->numDefs = numDefs;
             mir->ssaRep->defs = (int *)oatNew(sizeof(int) * numDefs,
-                                                      false);
+                                              false, kAllocDFInfo);
             mir->ssaRep->fpDef = (bool *)oatNew(sizeof(bool) * numDefs,
-                                                        false);
+                                                false, kAllocDFInfo);
         }
 
         DecodedInstruction *dInsn = &mir->dalvikInsn;
@@ -1336,16 +1340,19 @@
         }
     }
 
-    /*
-     * 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->dalvikToSSAMap =
-        (int *)oatNew(sizeof(int) * cUnit->numDalvikRegisters, false);
+    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->dalvikToSSAMap =
+            (int *)oatNew(sizeof(int) * cUnit->numDalvikRegisters, false,
+                          kAllocDFInfo);
 
-    memcpy(bb->dataFlowInfo->dalvikToSSAMap, cUnit->dalvikToSSAMap,
-           sizeof(int) * cUnit->numDalvikRegisters);
+        memcpy(bb->dataFlowInfo->dalvikToSSAMap, cUnit->dalvikToSSAMap,
+               sizeof(int) * cUnit->numDalvikRegisters);
+    }
     return true;
 }
 
@@ -1436,9 +1443,11 @@
     int numDalvikReg = cUnit->numDalvikRegisters;
 
     cUnit->ssaToDalvikMap = (GrowableList *)oatNew(sizeof(GrowableList),
-                                                           false);
-    oatInitGrowableList(cUnit->ssaToDalvikMap, numDalvikReg);
-
+                                                   false, kAllocDFInfo);
+    // Create the SSAtoDalvikMap, estimating the max size
+    oatInitGrowableList(cUnit->ssaToDalvikMap,
+                        numDalvikReg + cUnit->defCount + 128,
+                        kListSSAtoDalvikMap);
     /*
      * Initial number of SSA registers is equal to the number of Dalvik
      * registers.
@@ -1460,10 +1469,10 @@
      * register N is mapped to SSA register N with subscript 0.
      */
     cUnit->dalvikToSSAMap = (int *)oatNew(sizeof(int) * numDalvikReg,
-                                                  false);
+                                          false, kAllocDFInfo);
     /* Keep track of the higest def for each dalvik reg */
     cUnit->SSALastDefs = (int *)oatNew(sizeof(int) * numDalvikReg,
-                                                  false);
+                                       false, kAllocDFInfo);
 
     for (i = 0; i < numDalvikReg; i++) {
         cUnit->dalvikToSSAMap[i] = i;
@@ -1486,7 +1495,7 @@
             bb->blockType == kExitBlock) {
             bb->dataFlowInfo = (BasicBlockDataFlow *)
                 oatNew(sizeof(BasicBlockDataFlow),
-                               true);
+                       true, kAllocDFInfo);
         }
     }
 }
@@ -1618,7 +1627,7 @@
 {
     if (bb->dataFlowInfo == NULL) return false;
     bb->dataFlowInfo->endingNullCheckV =
-        oatAllocBitVector(cUnit->numSSARegs, false);
+        oatAllocBitVector(cUnit->numSSARegs, false, kBitMapNullCheck);
     oatClearAllBits(bb->dataFlowInfo->endingNullCheckV);
     return true;
 }
@@ -1628,12 +1637,12 @@
                                  struct BasicBlock* bb)
 {
     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) {
@@ -1643,20 +1652,15 @@
         }
     } else {
         // Starting state is intesection of all incoming arcs
-        GrowableList* blockList = &cUnit->blockList;
-        ArenaBitVectorIterator bvIterator;
-        oatBitVectorIteratorInit(bb->predecessors, &bvIterator);
-        int predBBIdx = oatBitVectorIteratorNext(&bvIterator);
-        DCHECK_NE(predBBIdx, -1);
-        BasicBlock* predBB = (BasicBlock*)oatGrowableListGetElement(
-            blockList, predBBIdx);
+        GrowableListIterator iter;
+        oatGrowableListIteratorInit(bb->predecessors, &iter);
+        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+        DCHECK(predBB != NULL);
         oatCopyBitVector(cUnit->tempSSARegisterV,
                          predBB->dataFlowInfo->endingNullCheckV);
         while (true) {
-            predBBIdx = oatBitVectorIteratorNext(&bvIterator);
-            if (predBBIdx == -1) break;
-            predBB = (BasicBlock*)oatGrowableListGetElement(
-                blockList, predBBIdx);
+            predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+            if (!predBB) break;
             if ((predBB->dataFlowInfo == NULL) ||
                 (predBB->dataFlowInfo->endingNullCheckV == NULL)) {
                 continue;
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index 2a6714f..b41afc0 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -46,6 +46,7 @@
      //(1 << kDebugSlowestStringPath) |
      //(1 << kDebugExerciseResolveMethod) |
      //(1 << kDebugVerifyDataflow) |
+     //(1 << kDebugShowMemoryUsage) |
      0;
 
 std::string compilerMethodMatch;      // Method name match to apply above flags
@@ -130,8 +131,8 @@
     if (insn == NULL) {
         LOG(FATAL) << "Break split failed";
     }
-    BasicBlock *bottomBlock = oatNewBB(kDalvikByteCode,
-                                               cUnit->numBlocks++);
+    BasicBlock *bottomBlock = oatNewBB(cUnit, kDalvikByteCode,
+                                       cUnit->numBlocks++);
     oatInsertGrowableList(&cUnit->blockList, (intptr_t) bottomBlock);
 
     bottomBlock->startOffset = codeOffset;
@@ -146,8 +147,10 @@
     bottomBlock->taken = origBlock->taken;
     if (bottomBlock->taken) {
         origBlock->taken = NULL;
-        oatClearBit(bottomBlock->taken->predecessors, origBlock->id);
-        oatSetBit(bottomBlock->taken->predecessors, bottomBlock->id);
+        oatDeleteGrowableList(bottomBlock->taken->predecessors,
+                              (intptr_t)origBlock);
+        oatInsertGrowableList(bottomBlock->taken->predecessors,
+                              (intptr_t)bottomBlock);
     }
 
     /* Handle the fallthrough path */
@@ -155,12 +158,12 @@
     bottomBlock->fallThrough = origBlock->fallThrough;
     origBlock->fallThrough = bottomBlock;
     origBlock->needFallThroughBranch = true;
-    oatSetBit(bottomBlock->predecessors, origBlock->id);
+    oatInsertGrowableList(bottomBlock->predecessors, (intptr_t)origBlock);
     if (bottomBlock->fallThrough) {
-        oatClearBit(bottomBlock->fallThrough->predecessors,
-                            origBlock->id);
-        oatSetBit(bottomBlock->fallThrough->predecessors,
-                          bottomBlock->id);
+        oatDeleteGrowableList(bottomBlock->fallThrough->predecessors,
+                              (intptr_t)origBlock);
+        oatInsertGrowableList(bottomBlock->fallThrough->predecessors,
+                              (intptr_t)bottomBlock);
     }
 
     /* Handle the successor list */
@@ -176,8 +179,8 @@
                 (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
             if (successorBlockInfo == NULL) break;
             BasicBlock *bb = successorBlockInfo->block;
-            oatClearBit(bb->predecessors, origBlock->id);
-            oatSetBit(bb->predecessors, bottomBlock->id);
+            oatDeleteGrowableList(bb->predecessors, (intptr_t)origBlock);
+            oatInsertGrowableList(bb->predecessors, (intptr_t)bottomBlock);
         }
     }
 
@@ -237,7 +240,7 @@
     }
 
     /* Create a new one */
-    bb = oatNewBB(kDalvikByteCode, cUnit->numBlocks++);
+    bb = oatNewBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
     oatInsertGrowableList(&cUnit->blockList, (intptr_t) bb);
     bb->startOffset = codeOffset;
     cUnit->blockMap.insert(std::make_pair(bb->startOffset, bb));
@@ -254,7 +257,7 @@
     char* fileName = (char*) oatNew(
                         strlen(dirPrefix) +
                         name.length() +
-                        strlen(".dot") + 1, true);
+                        strlen(".dot") + 1, true, kAllocDebugInfo);
     sprintf(fileName, "%s%s%s.dot", dirPrefix, name.c_str(), startOffset);
 
     /*
@@ -405,14 +408,12 @@
 /* Verify if all the successor is connected with all the claimed predecessors */
 STATIC bool verifyPredInfo(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    ArenaBitVectorIterator bvIterator;
+    GrowableListIterator iter;
 
-    oatBitVectorIteratorInit(bb->predecessors, &bvIterator);
+    oatGrowableListIteratorInit(bb->predecessors, &iter);
     while (true) {
-        int blockIdx = oatBitVectorIteratorNext(&bvIterator);
-        if (blockIdx == -1) break;
-        BasicBlock *predBB = (BasicBlock *)
-            oatGrowableListGetElement(&cUnit->blockList, blockIdx);
+        BasicBlock *predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+        if (!predBB) break;
         bool found = false;
         if (predBB->taken == bb) {
             found = true;
@@ -525,7 +526,7 @@
                                        /* immedPredBlockP */
                                        &curBlock);
     curBlock->taken = takenBlock;
-    oatSetBit(takenBlock->predecessors, curBlock->id);
+    oatInsertGrowableList(takenBlock->predecessors, (intptr_t)curBlock);
 
     /* Always terminate the current block for conditional branches */
     if (flags & kInstrCanContinue) {
@@ -549,7 +550,8 @@
                                                  /* immedPredBlockP */
                                                  &curBlock);
         curBlock->fallThrough = fallthroughBlock;
-        oatSetBit(fallthroughBlock->predecessors, curBlock->id);
+        oatInsertGrowableList(fallthroughBlock->predecessors,
+                              (intptr_t)curBlock);
     } else if (codePtr < codeEnd) {
         /* Create a fallthrough block for real instructions (incl. OP_NOP) */
         if (contentIsInsn(codePtr)) {
@@ -616,7 +618,8 @@
     curBlock->successorBlockList.blockListType =
         (insn->dalvikInsn.opcode == OP_PACKED_SWITCH) ?
         kPackedSwitch : kSparseSwitch;
-    oatInitGrowableList(&curBlock->successorBlockList.blocks, size);
+    oatInitGrowableList(&curBlock->successorBlockList.blocks, size,
+                        kListSuccessorBlocks);
 
     for (i = 0; i < size; i++) {
         BasicBlock *caseBlock = findBlock(cUnit, curOffset + targetTable[i],
@@ -628,13 +631,13 @@
                                           &curBlock);
         SuccessorBlockInfo *successorBlockInfo =
             (SuccessorBlockInfo *) oatNew(sizeof(SuccessorBlockInfo),
-                                                  false);
+                                                  false, kAllocSuccessor);
         successorBlockInfo->block = caseBlock;
         successorBlockInfo->key = (insn->dalvikInsn.opcode == OP_PACKED_SWITCH)?
                                   firstKey + i : keyTable[i];
         oatInsertGrowableList(&curBlock->successorBlockList.blocks,
                               (intptr_t) successorBlockInfo);
-        oatSetBit(caseBlock->predecessors, curBlock->id);
+        oatInsertGrowableList(caseBlock->predecessors, (intptr_t)curBlock);
     }
 
     /* Fall-through case */
@@ -647,7 +650,7 @@
                                              /* immedPredBlockP */
                                              NULL);
     curBlock->fallThrough = fallthroughBlock;
-    oatSetBit(fallthroughBlock->predecessors, curBlock->id);
+    oatInsertGrowableList(fallthroughBlock->predecessors, (intptr_t)curBlock);
 }
 
 /* Process instructions with the kInstrCanThrow flag */
@@ -668,7 +671,8 @@
         }
 
         curBlock->successorBlockList.blockListType = kCatch;
-        oatInitGrowableList(&curBlock->successorBlockList.blocks, 2);
+        oatInitGrowableList(&curBlock->successorBlockList.blocks, 2,
+                            kListSuccessorBlocks);
 
         for (;iterator.HasNext(); iterator.Next()) {
             BasicBlock *catchBlock = findBlock(cUnit, iterator.GetHandlerAddress(),
@@ -678,20 +682,20 @@
             catchBlock->catchEntry = true;
             SuccessorBlockInfo *successorBlockInfo =
                   (SuccessorBlockInfo *) oatNew(sizeof(SuccessorBlockInfo),
-                  false);
+                                                false, kAllocSuccessor);
             successorBlockInfo->block = catchBlock;
             successorBlockInfo->key = iterator.GetHandlerTypeIndex();
             oatInsertGrowableList(&curBlock->successorBlockList.blocks,
                                   (intptr_t) successorBlockInfo);
-            oatSetBit(catchBlock->predecessors, curBlock->id);
+            oatInsertGrowableList(catchBlock->predecessors, (intptr_t)curBlock);
         }
     } else {
-        BasicBlock *ehBlock = oatNewBB(kExceptionHandling,
-                                               cUnit->numBlocks++);
+        BasicBlock *ehBlock = oatNewBB(cUnit, kExceptionHandling,
+                                       cUnit->numBlocks++);
         curBlock->taken = ehBlock;
         oatInsertGrowableList(&cUnit->blockList, (intptr_t) ehBlock);
         ehBlock->startOffset = curOffset;
-        oatSetBit(ehBlock->predecessors, curBlock->id);
+        oatInsertGrowableList(ehBlock->predecessors, (intptr_t)curBlock);
     }
 
     /*
@@ -720,7 +724,8 @@
              */
             if (insn->dalvikInsn.opcode != OP_THROW) {
                 curBlock->fallThrough = fallthroughBlock;
-                oatSetBit(fallthroughBlock->predecessors, curBlock->id);
+                oatInsertGrowableList(fallthroughBlock->predecessors,
+                                      (intptr_t)curBlock);
             }
         }
     }
@@ -779,20 +784,22 @@
     /* Assume non-throwing leaf */
     cUnit->attrs = (METHOD_IS_LEAF | METHOD_IS_THROW_FREE);
 
-    /* Initialize the block list */
-    oatInitGrowableList(&cUnit->blockList, 40);
+    /* Initialize the block list, estimate size based on insnsSize */
+    oatInitGrowableList(&cUnit->blockList, cUnit->insnsSize, kListBlockList);
 
     /* Initialize the switchTables list */
-    oatInitGrowableList(&cUnit->switchTables, 4);
+    oatInitGrowableList(&cUnit->switchTables, 4, kListSwitchTables);
 
     /* Intialize the fillArrayData list */
-    oatInitGrowableList(&cUnit->fillArrayData, 4);
+    oatInitGrowableList(&cUnit->fillArrayData, 4, kListFillArrayData);
 
-    /* Intialize the throwLaunchpads list */
-    oatInitGrowableList(&cUnit->throwLaunchpads, 4);
+    /* Intialize the throwLaunchpads list, estimate size based on insnsSize */
+    oatInitGrowableList(&cUnit->throwLaunchpads, cUnit->insnsSize,
+                        kListThrowLaunchPads);
 
     /* Intialize the suspendLaunchpads list */
-    oatInitGrowableList(&cUnit->suspendLaunchpads, 4);
+    oatInitGrowableList(&cUnit->suspendLaunchpads, 2048,
+                        kListSuspendLaunchPads);
 
     /* Allocate the bit-vector to track the beginning of basic blocks */
     ArenaBitVector *tryBlockAddr = oatAllocBitVector(cUnit->insnsSize,
@@ -800,8 +807,8 @@
     cUnit->tryBlockAddr = tryBlockAddr;
 
     /* Create the default entry and exit blocks and enter them to the list */
-    BasicBlock *entryBlock = oatNewBB(kEntryBlock, numBlocks++);
-    BasicBlock *exitBlock = oatNewBB(kExitBlock, numBlocks++);
+    BasicBlock *entryBlock = oatNewBB(cUnit.get(), kEntryBlock, numBlocks++);
+    BasicBlock *exitBlock = oatNewBB(cUnit.get(), kExitBlock, numBlocks++);
 
     cUnit->entryBlock = entryBlock;
     cUnit->exitBlock = exitBlock;
@@ -810,13 +817,13 @@
     oatInsertGrowableList(&cUnit->blockList, (intptr_t) exitBlock);
 
     /* Current block to record parsed instructions */
-    BasicBlock *curBlock = oatNewBB(kDalvikByteCode, numBlocks++);
+    BasicBlock *curBlock = oatNewBB(cUnit.get(), kDalvikByteCode, numBlocks++);
     curBlock->startOffset = 0;
     oatInsertGrowableList(&cUnit->blockList, (intptr_t) curBlock);
     /* Add first block to the fast lookup cache */
     cUnit->blockMap.insert(std::make_pair(curBlock->startOffset, curBlock));
     entryBlock->fallThrough = curBlock;
-    oatSetBit(curBlock->predecessors, entryBlock->id);
+    oatInsertGrowableList(curBlock->predecessors, (intptr_t)entryBlock);
 
     /*
      * Store back the number of blocks since new blocks may be created of
@@ -829,7 +836,7 @@
 
     /* Parse all instructions and put them into containing basic blocks */
     while (codePtr < codeEnd) {
-        MIR *insn = (MIR *) oatNew(sizeof(MIR), true);
+        MIR *insn = (MIR *) oatNew(sizeof(MIR), true, kAllocMIR);
         insn->offset = curOffset;
         int width = parseInsn(codePtr, &insn->dalvikInsn, false);
         insn->width = width;
@@ -843,15 +850,18 @@
         codePtr += width;
         int flags = dexGetFlagsFromOpcode(insn->dalvikInsn.opcode);
 
-        cUnit->usesFP |= (oatDataFlowAttributes[insn->dalvikInsn.opcode] &
-              DF_USES_FP);
+        int dfFlags = oatDataFlowAttributes[insn->dalvikInsn.opcode];
+
+        if (dfFlags & DF_HAS_DEFS) {
+            cUnit->defCount += (dfFlags & DF_DA_WIDE) ? 2 : 1;
+        }
 
         if (flags & kInstrCanBranch) {
             curBlock = processCanBranch(cUnit.get(), curBlock, insn, curOffset,
                                         width, flags, codePtr, codeEnd);
         } else if (flags & kInstrCanReturn) {
             curBlock->fallThrough = exitBlock;
-            oatSetBit(exitBlock->predecessors, curBlock->id);
+            oatInsertGrowableList(exitBlock->predecessors, (intptr_t)curBlock);
             /*
              * Terminate the current block if there are instructions
              * afterwards.
@@ -899,14 +909,14 @@
             if ((curBlock->fallThrough == NULL) &&
                 (flags & kInstrCanContinue)) {
                 curBlock->fallThrough = nextBlock;
-                oatSetBit(nextBlock->predecessors, curBlock->id);
+                oatInsertGrowableList(nextBlock->predecessors,
+                                      (intptr_t)curBlock);
             }
             curBlock = nextBlock;
         }
     }
 
-    if (!cUnit->usesFP &&
-        !(cUnit->disableOpt & (1 << kSkipLargeMethodOptimization))) {
+    if (!(cUnit->disableOpt & (1 << kSkipLargeMethodOptimization))) {
         if ((cUnit->numBlocks > MANY_BLOCKS) ||
               ((cUnit->numBlocks > MANY_BLOCKS_INITIALIZER) &&
                PrettyMethod(method_idx, dex_file).find("init>") !=
@@ -929,7 +939,8 @@
 
     if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
         /* Verify if all blocks are connected as claimed */
-        oatDataFlowAnalysisDispatcher(cUnit.get(), verifyPredInfo, kAllNodes, false /* isIterative */);
+        oatDataFlowAnalysisDispatcher(cUnit.get(), verifyPredInfo, kAllNodes,
+                                      false /* isIterative */);
     }
 
     /* Perform SSA transformation for the whole method */
@@ -987,7 +998,14 @@
                                                 vmapTable);
 
     VLOG(compiler) << "Compiled " << PrettyMethod(method_idx, dex_file)
-                   << " (" << (cUnit->codeBuffer.size() * sizeof(cUnit->codeBuffer[0])) << " bytes)";
+       << " (" << (cUnit->codeBuffer.size() * sizeof(cUnit->codeBuffer[0]))
+       << " bytes)";
+
+#ifdef WITH_MEMSTATS
+    if (cUnit->enableDebug & (1 << kDebugShowMemoryUsage)) {
+        oatDumpMemStats(cUnit.get());
+    }
+#endif
 
     return result;
 }
diff --git a/src/compiler/IntermediateRep.cc b/src/compiler/IntermediateRep.cc
index c39aed3..6cb6580 100644
--- a/src/compiler/IntermediateRep.cc
+++ b/src/compiler/IntermediateRep.cc
@@ -20,13 +20,15 @@
 namespace art {
 
 /* Allocate a new basic block */
-BasicBlock* oatNewBB(BBType blockType, int blockId)
+BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId)
 {
-    BasicBlock* bb = (BasicBlock* )oatNew(sizeof(BasicBlock), true);
+    BasicBlock* bb = (BasicBlock* )oatNew(sizeof(BasicBlock), true, kAllocBB);
     bb->blockType = blockType;
     bb->id = blockId;
-    bb->predecessors = oatAllocBitVector(blockId > 32 ? blockId : 32,
-                                                 true /* expandable */);
+    bb->predecessors = (GrowableList*) oatNew(sizeof(GrowableList), false,
+                                              kAllocPredecessors);
+    oatInitGrowableList(bb->predecessors, (blockType == kExitBlock) ? 2048 : 2,
+                        kListPredecessors);
     return bb;
 }
 
diff --git a/src/compiler/Ralloc.cc b/src/compiler/Ralloc.cc
index c6375ee..4529a83 100644
--- a/src/compiler/Ralloc.cc
+++ b/src/compiler/Ralloc.cc
@@ -315,7 +315,8 @@
     RegLocation* loc;
 
     /* Allocate the location map */
-    loc = (RegLocation*)oatNew(cUnit->numSSARegs * sizeof(*loc), true);
+    loc = (RegLocation*)oatNew(cUnit->numSSARegs * sizeof(*loc), true,
+                               kAllocRegAlloc);
     for (i=0; i< cUnit->numSSARegs; i++) {
         loc[i] = freshLoc;
         loc[i].sRegLow = i;
@@ -325,7 +326,8 @@
     /* Allocation the promotion map */
     int numRegs = cUnit->numDalvikRegisters;
     cUnit->promotionMap =
-        (PromotionMap*)oatNew(numRegs * sizeof(cUnit->promotionMap[0]), true);
+        (PromotionMap*)oatNew(numRegs * sizeof(cUnit->promotionMap[0]), true,
+                              kAllocRegAlloc);
 
     /* Add types of incoming arguments based on signature */
     int numIns = cUnit->numIns;
diff --git a/src/compiler/SSATransformation.cc b/src/compiler/SSATransformation.cc
index e9c3d70..3e1728f 100644
--- a/src/compiler/SSATransformation.cc
+++ b/src/compiler/SSATransformation.cc
@@ -55,7 +55,7 @@
 {
     /* Initialize or reset the DFS preOrder list */
     if (cUnit->dfsOrder.elemList == NULL) {
-        oatInitGrowableList(&cUnit->dfsOrder, cUnit->numBlocks);
+        oatInitGrowableList(&cUnit->dfsOrder, cUnit->numBlocks, kListDfsOrder);
     } else {
         /* Just reset the used length on the counter */
         cUnit->dfsOrder.numUsed = 0;
@@ -63,7 +63,8 @@
 
     /* Initialize or reset the DFS postOrder list */
     if (cUnit->dfsPostOrder.elemList == NULL) {
-        oatInitGrowableList(&cUnit->dfsPostOrder, cUnit->numBlocks);
+        oatInitGrowableList(&cUnit->dfsPostOrder, cUnit->numBlocks,
+                            kListDfsPostOrder);
     } else {
         /* Just reset the used length on the counter */
         cUnit->dfsPostOrder.numUsed = 0;
@@ -102,13 +103,14 @@
     int numRegisters = cUnit->numDalvikRegisters;
     /* Allocate numDalvikRegisters bit vector pointers */
     cUnit->defBlockMatrix = (ArenaBitVector **)
-        oatNew(sizeof(ArenaBitVector *) * numRegisters, true);
+        oatNew(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->numBlocks,
-                                                             false);
+        cUnit->defBlockMatrix[i] = oatAllocBitVector(cUnit->numBlocks, false,
+                                                     kBitMapBMatrix);
     }
     oatDataFlowAnalysisDispatcher(cUnit, oatFindLocalLiveIn,
                                           kAllNodes,
@@ -224,11 +226,14 @@
 
     if (bb->dominators == NULL ) {
         bb->dominators = oatAllocBitVector(numTotalBlocks,
-                                                   false /* expandable */);
+                                           false /* expandable */,
+                                           kBitMapDominators);
         bb->iDominated = oatAllocBitVector(numTotalBlocks,
-                                                   false /* expandable */);
+                                           false /* expandable */,
+                                           kBitMapIDominated);
         bb->domFrontier = oatAllocBitVector(numTotalBlocks,
-                                                   false /* expandable */);
+                                            false /* expandable */,
+                                            kBitMapDomFrontier);
     } else {
         oatClearAllBits(bb->dominators);
         oatClearAllBits(bb->iDominated);
@@ -250,7 +255,7 @@
     GrowableList* blockList = &cUnit->blockList;
     int numTotalBlocks = blockList->numUsed;
     ArenaBitVector* tempBlockV = cUnit->tempBlockV;
-    ArenaBitVectorIterator bvIterator;
+    GrowableListIterator iter;
 
     /*
      * The dominator of the entry block has been preset to itself and we need
@@ -261,12 +266,10 @@
     oatSetInitialBits(tempBlockV, numTotalBlocks);
 
     /* Iterate through the predecessors */
-    oatBitVectorIteratorInit(bb->predecessors, &bvIterator);
+    oatGrowableListIteratorInit(bb->predecessors, &iter);
     while (true) {
-        int predIdx = oatBitVectorIteratorNext(&bvIterator);
-        if (predIdx == -1) break;
-        BasicBlock* predBB = (BasicBlock* ) oatGrowableListGetElement(
-                                 blockList, predIdx);
+        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+        if (!predBB) break;
         /* tempBlockV = tempBlockV ^ dominators */
         if (predBB->dominators != NULL) {
             oatIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
@@ -350,8 +353,7 @@
 /* Worker function to compute each block's immediate dominator */
 STATIC bool computeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
 {
-    GrowableList* blockList = &cUnit->blockList;
-    ArenaBitVectorIterator bvIterator;
+    GrowableListIterator iter;
     int idom = -1;
 
     /* Special-case entry block */
@@ -360,15 +362,12 @@
     }
 
     /* Iterate through the predecessors */
-    oatBitVectorIteratorInit(bb->predecessors, &bvIterator);
+    oatGrowableListIteratorInit(bb->predecessors, &iter);
 
     /* Find the first processed predecessor */
     while (true) {
-        //TUNING: hot call to oatBitVectorIteratorNext
-        int predIdx = oatBitVectorIteratorNext(&bvIterator);
-        DCHECK_NE(predIdx, -1);  /* Should find one */
-        BasicBlock* predBB = (BasicBlock* ) oatGrowableListGetElement(
-                                 blockList, predIdx);
+        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+        CHECK(predBB != NULL);
         if (cUnit->iDomList[predBB->dfsId] != NOTVISITED) {
             idom = predBB->dfsId;
             break;
@@ -377,10 +376,8 @@
 
     /* Scan the rest of the predecessors */
     while (true) {
-        int predIdx = oatBitVectorIteratorNext(&bvIterator);
-        if (predIdx == -1) break;
-        BasicBlock* predBB = (BasicBlock* ) oatGrowableListGetElement(
-                                 blockList, predIdx);
+        BasicBlock* predBB = (BasicBlock*)oatGrowableListIteratorNext(&iter);
+        if (!predBB) break;
         if (cUnit->iDomList[predBB->dfsId] == NOTVISITED) {
             continue;
         } else {
@@ -441,7 +438,8 @@
 
     /* Initalize & Clear iDomList */
     if (cUnit->iDomList == NULL) {
-        cUnit->iDomList = (int*)oatNew(sizeof(int) * numReachableBlocks, false);
+        cUnit->iDomList = (int*)oatNew(sizeof(int) * numReachableBlocks, false,
+                                       kAllocDFInfo);
     }
     for (int i = 0; i < numReachableBlocks; i++) {
         cUnit->iDomList[i] = NOTVISITED;
@@ -462,7 +460,8 @@
 
     if (cUnit->tempBlockV == NULL) {
         cUnit->tempBlockV = oatAllocBitVector(numTotalBlocks,
-                                                  false /* expandable */);
+                                              false /* expandable */,
+                                              kBitMapTmpBlockV);
     } else {
         oatClearAllBits(cUnit->tempBlockV);
     }
@@ -493,7 +492,8 @@
      * iDominated sets.
      */
     if (cUnit->domPostOrderTraversal.elemList == NULL) {
-        oatInitGrowableList(&cUnit->domPostOrderTraversal, numReachableBlocks);
+        oatInitGrowableList(&cUnit->domPostOrderTraversal, numReachableBlocks,
+                            kListDomPostOrderTraversal);
     } else {
         cUnit->domPostOrderTraversal.numUsed = 0;
     }
@@ -576,14 +576,15 @@
     int dalvikReg;
     const GrowableList* blockList = &cUnit->blockList;
     ArenaBitVector* phiBlocks =
-        oatAllocBitVector(cUnit->numBlocks, false);
+        oatAllocBitVector(cUnit->numBlocks, false, kBitMapPhi);
     ArenaBitVector* tmpBlocks =
-        oatAllocBitVector(cUnit->numBlocks, false);
+        oatAllocBitVector(cUnit->numBlocks, false, kBitMapTmpBlocks);
     ArenaBitVector* inputBlocks =
-        oatAllocBitVector(cUnit->numBlocks, false);
+        oatAllocBitVector(cUnit->numBlocks, false, kBitMapInputBlocks);
 
     cUnit->tempDalvikRegisterV =
-        oatAllocBitVector(cUnit->numDalvikRegisters, false);
+        oatAllocBitVector(cUnit->numDalvikRegisters, false,
+                          kBitMapRegisterV);
 
     oatDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
                                           kPostOrderDFSTraversal,
@@ -641,7 +642,7 @@
                 (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(sizeof(MIR), true);
+            MIR *phi = (MIR *) oatNew(sizeof(MIR), true, kAllocDFInfo);
             phi->dalvikInsn.opcode = (Opcode)kMirOpPhi;
             phi->dalvikInsn.vA = dalvikReg;
             phi->offset = phiBB->startOffset;
@@ -659,8 +660,7 @@
 STATIC bool insertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
 {
     ArenaBitVector* ssaRegV = cUnit->tempSSARegisterV;
-    ArenaBitVectorIterator bvIterator;
-    GrowableList* blockList = &cUnit->blockList;
+    GrowableListIterator iter;
     MIR *mir;
 
     /* Phi nodes are at the beginning of each block */
@@ -675,12 +675,11 @@
         oatClearAllBits(ssaRegV);
 
         /* Iterate through the predecessors */
-        oatBitVectorIteratorInit(bb->predecessors, &bvIterator);
+        oatGrowableListIteratorInit(bb->predecessors, &iter);
         while (true) {
-            int predIdx = oatBitVectorIteratorNext(&bvIterator);
-            if (predIdx == -1) break;
-            BasicBlock* predBB = (BasicBlock* ) oatGrowableListGetElement(
-                                     blockList, predIdx);
+            BasicBlock* predBB =
+               (BasicBlock*)oatGrowableListIteratorNext(&iter);
+            if (!predBB) break;
             int encodedSSAValue =
                 predBB->dataFlowInfo->dalvikToSSAMap[dalvikReg];
             int ssaReg = DECODE_REG(encodedSSAValue);
@@ -691,9 +690,9 @@
         int numUses = oatCountSetBits(ssaRegV);
         mir->ssaRep->numUses = numUses;
         mir->ssaRep->uses =
-            (int *) oatNew(sizeof(int) * numUses, false);
+            (int *) oatNew(sizeof(int) * numUses, false, kAllocDFInfo);
         mir->ssaRep->fpUse =
-            (bool *) oatNew(sizeof(bool) * numUses, true);
+            (bool *) oatNew(sizeof(bool) * numUses, true, kAllocDFInfo);
 
         ArenaBitVectorIterator phiIterator;
 
@@ -722,7 +721,7 @@
     int mapSize = sizeof(int) * cUnit->numDalvikRegisters;
 
     /* Save SSA map snapshot */
-    int* savedSSAMap = (int*)oatNew(mapSize, false);
+    int* savedSSAMap = (int*)oatNew(mapSize, false, kAllocDalvikToSSAMap);
     memcpy(savedSSAMap, cUnit->dalvikToSSAMap, mapSize);
 
     if (block->fallThrough) {
@@ -786,8 +785,8 @@
          * Shared temp bit vector used by each block to count the number of defs
          * from all the predecessor blocks.
          */
-        cUnit->tempSSARegisterV = oatAllocBitVector(cUnit->numSSARegs,
-                                                        false);
+        cUnit->tempSSARegisterV = oatAllocBitVector(cUnit->numSSARegs, false,
+                                                    kBitMapTempSSARegisterV);
 
         /* Insert phi-operands with latest SSA names from predecessor blocks */
         oatDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
diff --git a/src/compiler/Utility.cc b/src/compiler/Utility.cc
index c76143b..0cdcfd3 100644
--- a/src/compiler/Utility.cc
+++ b/src/compiler/Utility.cc
@@ -22,6 +22,67 @@
 static ArenaMemBlock *arenaHead, *currentArena;
 static int numArenaBlocks;
 
+#ifdef WITH_MEMSTATS
+static u4 allocStats[kNumAllocKinds];
+static int listSizes[kNumListKinds];
+static int listWasted[kNumListKinds];
+static int listGrows[kNumListKinds];
+static int listMaxElems[kNumListKinds];
+static int bitMapSizes[kNumBitMapKinds];
+static int bitMapWasted[kNumBitMapKinds];
+static int bitMapGrows[kNumBitMapKinds];
+
+const char* allocNames[kNumAllocKinds] = {
+    "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          ",
+};
+
+const char* bitMapNames[kNumBitMapKinds] = {
+    "Misc                  ",
+    "Use                   ",
+    "Def                   ",
+    "LiveIn                ",
+    "BlockMatrix           ",
+    "Dominators            ",
+    "IDominated            ",
+    "DomFrontier           ",
+    "Phi                   ",
+    "TmpBlocks             ",
+    "InputBlocks           ",
+    "RegisterV             ",
+    "TempSSARegisterV      ",
+    "Null Check            ",
+    "TmpBlockV             ",
+    "Predecessors          ",
+};
+#endif
+
 #define kArenaBitVectorGrowth    4   /* increase by 4 u4s when limit hit */
 
 /* Allocate the initial memory block for arena-based allocation */
@@ -38,14 +99,16 @@
     currentArena->bytesAllocated = 0;
     currentArena->next = NULL;
     numArenaBlocks = 1;
-
     return true;
 }
 
 /* Arena-based malloc for compilation tasks */
-void* oatNew(size_t size, bool zero)
+void* oatNew(size_t size, bool zero, oatAllocKind kind)
 {
     size = (size + 3) & ~3;
+#ifdef WITH_MEMSTATS
+    allocStats[kind] += size;
+#endif
 retry:
     /* Normal case - space is available in the current page */
     if (size + currentArena->bytesAllocated <= currentArena->blockSize) {
@@ -91,6 +154,16 @@
 /* Reclaim all the arena blocks allocated so far */
 void oatArenaReset(void)
 {
+#ifdef WITH_MEMSTATS
+    memset(&allocStats[0], 0, sizeof(allocStats));
+    memset(&listSizes[0], 0, sizeof(listSizes));
+    memset(&listWasted[0], 0, sizeof(listWasted));
+    memset(&listGrows[0], 0, sizeof(listGrows));
+    memset(&listMaxElems[0], 0, sizeof(listMaxElems));
+    memset(&bitMapSizes[0], 0, sizeof(bitMapSizes));
+    memset(&bitMapWasted[0], 0, sizeof(bitMapWasted));
+    memset(&bitMapGrows[0], 0, sizeof(bitMapGrows));
+#endif
     currentArena = arenaHead;
     if (currentArena) {
         currentArena->bytesAllocated = 0;
@@ -98,12 +171,20 @@
 }
 
 /* Growable List initialization */
-void oatInitGrowableList(GrowableList* gList, size_t initLength)
+void oatInitGrowableList(GrowableList* gList, size_t initLength,
+                         oatListKind kind)
 {
     gList->numAllocated = initLength;
     gList->numUsed = 0;
     gList->elemList = (intptr_t *) oatNew(sizeof(intptr_t) * initLength,
-                                                  true);
+                                                  true, kAllocGrowableList);
+#ifdef WITH_MEMSTATS
+    listSizes[kind] += sizeof(intptr_t) * initLength;
+    gList->kind = kind;
+    if ((int)initLength > listMaxElems[kind]) {
+        listMaxElems[kind] = initLength;
+    }
+#endif
 }
 
 /* Expand the capacity of a growable list */
@@ -116,8 +197,17 @@
         newLength += 128;
     }
     intptr_t *newArray =
-        (intptr_t *) oatNew(sizeof(intptr_t) * newLength, true);
+        (intptr_t *) oatNew(sizeof(intptr_t) * newLength, true,
+                            kAllocGrowableList);
     memcpy(newArray, gList->elemList, sizeof(intptr_t) * gList->numAllocated);
+#ifdef WITH_MEMSTATS
+    listSizes[gList->kind] += sizeof(intptr_t) * newLength;
+    listWasted[gList->kind] += sizeof(intptr_t) * gList->numAllocated;
+    listGrows[gList->kind]++;
+    if (newLength > listMaxElems[gList->kind]) {
+        listMaxElems[gList->kind] = newLength;
+    }
+#endif
     gList->numAllocated = newLength;
     gList->elemList = newArray;
 }
@@ -132,6 +222,22 @@
     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];
+        }
+    }
+    DCHECK_EQ(found, true);
+    gList->numUsed--;
+}
+
 void oatGrowableListIteratorInit(GrowableList* gList,
                                  GrowableListIterator* iterator)
 {
@@ -153,6 +259,44 @@
     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 += 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 ** ";
+        }
+        LOG(INFO) << "===== Overall allocations";
+        for (int i = 0; i < kNumAllocKinds; i++) {
+            LOG(INFO) << allocNames[i] << std::setw(10) <<allocStats[i];
+        }
+        LOG(INFO) << "===== GrowableList allocations";
+        for (int i = 0; i < kNumListKinds; i++) {
+            LOG(INFO) << listNames[i]
+                << " S:" << listSizes[i]
+                << ", W:" << listWasted[i]
+                << ", G:" << listGrows[i]
+                << ", E:" << listMaxElems[i];
+        }
+        LOG(INFO) << "===== GrowableBitMap allocations";
+        for (int i = 0; i < kNumBitMapKinds; i++) {
+            LOG(INFO) << bitMapNames[i]
+                << " S:" << bitMapSizes[i]
+                << ", W:" << bitMapWasted[i]
+                << ", G:" << bitMapGrows[i];
+        }
+    }
+}
+#endif
+
 /* Debug Utility - dump a compilation unit */
 void oatDumpCompilationUnit(CompilationUnit* cUnit)
 {
@@ -217,22 +361,26 @@
  *
  * NOTE: memory is allocated from the compiler arena.
  */
-ArenaBitVector* oatAllocBitVector(unsigned int startBits, bool expandable)
+ArenaBitVector* oatAllocBitVector(unsigned int startBits, bool expandable,
+                                  oatBitMapKind kind)
 {
     ArenaBitVector* bv;
     unsigned int count;
 
     DCHECK_EQ(sizeof(bv->storage[0]), 4U);        /* assuming 32-bit units */
 
-    bv = (ArenaBitVector*) oatNew(sizeof(ArenaBitVector), false);
+    bv = (ArenaBitVector*) oatNew(sizeof(ArenaBitVector), false,
+                                  kAllocGrowableBitMap);
 
     count = (startBits + 31) >> 5;
 
     bv->storageSize = count;
     bv->expandable = expandable;
-    bv->storage = (u4*) oatNew(count * sizeof(u4), true);
-    bv->firstDirty = true;
-    bv->lastDirty = true;
+    bv->storage = (u4*) oatNew(count * sizeof(u4), true, kAllocGrowableBitMap);
+#ifdef WITH_MEMSTATS
+    bv->kind = kind;
+    bitMapSizes[kind] += count * sizeof(u4);
+#endif
     return bv;
 }
 
@@ -254,8 +402,6 @@
 {
     unsigned int count = pBits->storageSize;
     memset(pBits->storage, 0, count * sizeof(u4));
-    pBits->firstDirty = true;
-    pBits->lastDirty = true;
 }
 
 /*
@@ -276,21 +422,21 @@
         /* 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(newSize * sizeof(u4), false);
+        u4 *newStorage = (u4*)oatNew(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
+        bitMapWasted[pBits->kind] += pBits->storageSize * sizeof(u4);
+        bitMapSizes[pBits->kind] += newSize * sizeof(u4);
+        bitMapGrows[pBits->kind]++;
+#endif
         pBits->storage = newStorage;
         pBits->storageSize = newSize;
     }
 
     pBits->storage[num >> 5] |= checkMasks[num & 0x1f];
-    if (!pBits->firstDirty && ((int)num < pBits->firstBitSet)) {
-        pBits->firstBitSet = num;
-    }
-    if (!pBits->lastDirty && ((int)num > pBits->lastBitSet)) {
-        pBits->lastBitSet = num;
-    }
     return true;
 }
 
@@ -309,8 +455,6 @@
     }
 
     pBits->storage[num >> 5] &= ~checkMasks[num & 0x1f];
-    pBits->firstDirty = true;
-    pBits->lastDirty = true;
     return true;
 }
 
@@ -321,8 +465,6 @@
 {
     int value = set ? -1 : 0;
     memset(pBits->storage, value, pBits->storageSize * (int)sizeof(u4));
-    pBits->firstDirty = true;
-    pBits->lastDirty = true;
 }
 
 void oatDebugBitVector(char* msg, const ArenaBitVector* bv, int length)
@@ -388,10 +530,6 @@
     checkSizes(dest, src);
 
     memcpy(dest->storage, src->storage, sizeof(u4) * dest->storageSize);
-    dest->firstDirty = src->firstDirty;
-    dest->firstBitSet = src->firstBitSet;
-    dest->lastDirty = src->lastDirty;
-    dest->lastBitSet = src->lastBitSet;
 }
 
 /*
@@ -413,8 +551,6 @@
     for (idx = 0; idx < dest->storageSize; idx++) {
         dest->storage[idx] = src1->storage[idx] & src2->storage[idx];
     }
-    dest->firstDirty = true;
-    dest->lastDirty = true;
     return true;
 }
 
@@ -436,8 +572,6 @@
     for (idx = 0; idx < dest->storageSize; idx++) {
         dest->storage[idx] = src1->storage[idx] | src2->storage[idx];
     }
-    dest->firstDirty = true;
-    dest->lastDirty = true;
     return true;
 }
 
@@ -490,52 +624,37 @@
 {
     ArenaBitVector* pBits = iterator->pBits;
     u4 bitIndex = iterator->idx;
+    u4 bitSize = iterator->bitSize;
 
-    DCHECK_EQ(iterator->bitSize, pBits->storageSize * sizeof(u4) * 8);
-    if (bitIndex >= iterator->bitSize) return -1;
+    DCHECK_EQ(bitSize, pBits->storageSize * sizeof(u4) * 8);
 
-    /* If we know, skip past leading zeros */
-    if (!pBits->firstDirty && ((int)bitIndex < pBits->firstBitSet)) {
-        iterator->idx = pBits->firstBitSet + 1;
-        return pBits->firstBitSet;
-    }
+    if (bitIndex >= bitSize) return -1;
 
-    /* If we know, skip past trailing zeroes */
-    if (!pBits->lastDirty && ((int)bitIndex > pBits->lastBitSet)) {
-        iterator->idx = iterator->bitSize;
-        return -1;
-    }
+    u4 wordIndex = bitIndex >> 5;
+    u4 endWordIndex = bitSize >> 5;
+    u4* storage = pBits->storage;
+    u4 word = storage[wordIndex++];
 
-    bool firstPass = (bitIndex == 0);
-    u4 startIndex = bitIndex;
-    for (; bitIndex < iterator->bitSize;) {
-        unsigned int wordIndex = bitIndex >> 5;
-        unsigned int bitPos = bitIndex & 0x1f;
-        unsigned int word = pBits->storage[wordIndex];
-        if (word & checkMasks[bitPos]) {
-            iterator->idx = bitIndex+1;
-            if (firstPass && pBits->firstDirty) {
-                pBits->firstBitSet = bitIndex;
-                pBits->firstDirty = false;
-            }
-            return bitIndex;
-        }
+    // 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) {
-            // Helps if this is a sparse vector
             bitIndex += (32 - bitPos);
-        } else {
+            word = storage[wordIndex++];
+            continue;
+        }
+        for (; bitPos < 32; bitPos++) {
+            if (word & (1 << bitPos)) {
+                iterator->idx = bitIndex + 1;
+                return bitIndex;
+            }
             bitIndex++;
         }
+        word = storage[wordIndex++];
     }
-    /* No more set bits */
-    if (firstPass) {
-        // Empty
-        pBits->firstBitSet = -1;
-        pBits->firstDirty = false;
-    } else {
-        pBits->lastBitSet = startIndex - 1;
-        pBits->lastDirty = false;
-    }
+    iterator->idx = iterator->bitSize;
     return -1;
 }
 
@@ -555,8 +674,6 @@
     if (remNumBits) {
         pBits->storage[idx] = (1 << remNumBits) - 1;
     }
-    pBits->firstDirty = true;
-    pBits->lastDirty = true;
 }
 
 void oatGetBlockName(BasicBlock* bb, char* name)
diff --git a/src/compiler/codegen/RallocUtil.cc b/src/compiler/codegen/RallocUtil.cc
index 7dcb95b..2a4fe59 100644
--- a/src/compiler/codegen/RallocUtil.cc
+++ b/src/compiler/codegen/RallocUtil.cc
@@ -137,9 +137,8 @@
 }
 
 /* Mark a temp register as dead.  Does not affect allocation state. */
-void oatClobber(CompilationUnit* cUnit, int reg)
+static inline void clobberBody(CompilationUnit *cUnit, RegisterInfo* p)
 {
-    RegisterInfo* p = oatGetRegInfo(cUnit, reg);
     if (p->isTemp) {
         DCHECK(!(p->live && p->dirty))  << "Live & dirty temp in clobber";
         p->live = false;
@@ -153,6 +152,12 @@
     }
 }
 
+/* Mark a temp register as dead.  Does not affect allocation state. */
+void oatClobber(CompilationUnit* cUnit, int reg)
+{
+    clobberBody(cUnit, oatGetRegInfo(cUnit, reg));
+}
+
 STATIC void clobberSRegBody(RegisterInfo* p, int numRegs, int sReg)
 {
     int i;
@@ -577,13 +582,17 @@
     LOG(FATAL) << "Tried to lock a non-existant temp: r" << reg;
 }
 
-extern void oatResetDef(CompilationUnit* cUnit, int reg)
+static inline void resetDefBody(RegisterInfo* p)
 {
-    RegisterInfo* p = oatGetRegInfo(cUnit, reg);
     p->defStart = NULL;
     p->defEnd = NULL;
 }
 
+extern void oatResetDef(CompilationUnit* cUnit, int reg)
+{
+    resetDefBody(oatGetRegInfo(cUnit, reg));
+}
+
 STATIC void nullifyRange(CompilationUnit* cUnit, LIR *start, LIR *finish,
                          int sReg1, int sReg2)
 {
@@ -687,10 +696,10 @@
 {
     int i;
     for (i=0; i< cUnit->regPool->numCoreRegs; i++) {
-        oatResetDef(cUnit, cUnit->regPool->coreRegs[i].reg);
+        resetDefBody(&cUnit->regPool->coreRegs[i]);
     }
     for (i=0; i< cUnit->regPool->numFPRegs; i++) {
-        oatResetDef(cUnit, cUnit->regPool->FPRegs[i].reg);
+        resetDefBody(&cUnit->regPool->FPRegs[i]);
     }
 }
 
@@ -698,10 +707,10 @@
 {
     int i;
     for (i=0; i< cUnit->regPool->numCoreRegs; i++) {
-        oatClobber(cUnit, cUnit->regPool->coreRegs[i].reg);
+        clobberBody(cUnit, &cUnit->regPool->coreRegs[i]);
     }
     for (i=0; i< cUnit->regPool->numFPRegs; i++) {
-        oatClobber(cUnit, cUnit->regPool->FPRegs[i].reg);
+        clobberBody(cUnit, &cUnit->regPool->FPRegs[i]);
     }
 }
 
diff --git a/src/compiler/codegen/arm/ArchFactory.cc b/src/compiler/codegen/arm/ArchFactory.cc
index 14758b8..484a22d 100644
--- a/src/compiler/codegen/arm/ArchFactory.cc
+++ b/src/compiler/codegen/arm/ArchFactory.cc
@@ -56,7 +56,7 @@
 STATIC ArmLIR* genCheck(CompilationUnit* cUnit, ArmConditionCode cCode,
                         MIR* mir, ArmThrowKind kind)
 {
-    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true);
+    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true, kAllocLIR);
     tgt->opcode = kArmPseudoThrowTarget;
     tgt->operands[0] = kind;
     tgt->operands[1] = mir ? mir->offset : 0;
@@ -69,7 +69,7 @@
 STATIC ArmLIR* genImmedCheck(CompilationUnit* cUnit, ArmConditionCode cCode,
                              int reg, int immVal, MIR* mir, ArmThrowKind kind)
 {
-    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true);
+    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true, kAllocLIR);
     tgt->opcode = kArmPseudoThrowTarget;
     tgt->operands[0] = kind;
     tgt->operands[1] = mir->offset;
@@ -100,7 +100,7 @@
 STATIC TGT_LIR* genRegRegCheck(CompilationUnit* cUnit, ArmConditionCode cCode,
                                int reg1, int reg2, MIR* mir, ArmThrowKind kind)
 {
-    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true);
+    ArmLIR* tgt = (ArmLIR*)oatNew(sizeof(ArmLIR), true, kAllocLIR);
     tgt->opcode = kArmPseudoThrowTarget;
     tgt->operands[0] = kind;
     tgt->operands[1] = mir ? mir->offset : 0;
diff --git a/src/compiler/codegen/arm/ArmLIR.h b/src/compiler/codegen/arm/ArmLIR.h
index e77bed3..3c5daad 100644
--- a/src/compiler/codegen/arm/ArmLIR.h
+++ b/src/compiler/codegen/arm/ArmLIR.h
@@ -739,6 +739,7 @@
     kUsesCCodes,
     kMemLoad,
     kMemStore,
+    kPCRelFixup,
 } ArmOpFeatureFlags;
 
 #define IS_LOAD         (1 << kMemLoad)
@@ -770,6 +771,7 @@
 #define IS_IT           (1 << kIsIT)
 #define SETS_CCODES     (1 << kSetsCCodes)
 #define USES_CCODES     (1 << kUsesCCodes)
+#define NEEDS_FIXUP     (1 << kPCRelFixup)
 
 /* Common combo register usage patterns */
 #define REG_USE01       (REG_USE0 | REG_USE1)
@@ -844,9 +846,10 @@
         bool isNop:1;           // LIR is optimized away
         bool insertWrapper:1;   // insert branch to emulate memory accesses
         bool squashed:1;        // Eliminated def
+        bool pcRelFixup:1;      // May need pc-relative fixup
         unsigned int age:4;     // default is 0, set lazily by the optimizer
         unsigned int size:3;    // bytes (2 for thumb, 2/4 for thumb2)
-        unsigned int unused:22;
+        unsigned int unused:21;
     } flags;
     int aliasInfo;              // For Dalvik register & litpool disambiguation
     u8 useMask;                 // Resource mask for use
diff --git a/src/compiler/codegen/arm/ArmRallocUtil.cc b/src/compiler/codegen/arm/ArmRallocUtil.cc
index a193a7c..d540007 100644
--- a/src/compiler/codegen/arm/ArmRallocUtil.cc
+++ b/src/compiler/codegen/arm/ArmRallocUtil.cc
@@ -132,9 +132,9 @@
      * reg.
      */
     RefCounts *coreRegs = (RefCounts *)
-          oatNew(sizeof(RefCounts) * numRegs, true);
+          oatNew(sizeof(RefCounts) * numRegs, true, kAllocRegAlloc);
     RefCounts *fpRegs = (RefCounts *)
-          oatNew(sizeof(RefCounts) * numRegs, true);
+          oatNew(sizeof(RefCounts) * numRegs, true, kAllocRegAlloc);
     for (int i = 0; i < numRegs; i++) {
         coreRegs[i].sReg = fpRegs[i].sReg = i;
     }
diff --git a/src/compiler/codegen/arm/Assemble.cc b/src/compiler/codegen/arm/Assemble.cc
index 83c7a6c..685dd4c 100644
--- a/src/compiler/codegen/arm/Assemble.cc
+++ b/src/compiler/codegen/arm/Assemble.cc
@@ -118,7 +118,7 @@
                  "add", "!0C, !1C", 1),
     ENCODING_MAP(kThumbAddPcRel,    0xa000,
                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_TERTIARY_OP | IS_BRANCH,
+                 kFmtUnused, -1, -1, IS_TERTIARY_OP | IS_BRANCH | NEEDS_FIXUP,
                  "add", "!0C, pc, #!1E", 1),
     ENCODING_MAP(kThumbAddSpRel,    0xa800,
                  kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,
@@ -145,11 +145,11 @@
                  "asrs", "!0C, !1C", 1),
     ENCODING_MAP(kThumbBCond,        0xd000,
                  kFmtBitBlt, 7, 0, kFmtBitBlt, 11, 8, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | USES_CCODES,
-                 "b!1c", "!0t", 1),
+                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | USES_CCODES |
+                 NEEDS_FIXUP, "b!1c", "!0t", 1),
     ENCODING_MAP(kThumbBUncond,      0xe000,
                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, NO_OPERAND | IS_BRANCH,
+                 kFmtUnused, -1, -1, NO_OPERAND | IS_BRANCH | NEEDS_FIXUP,
                  "b", "!0t", 1),
     ENCODING_MAP(kThumbBicRR,        0x4380,
                  kFmtBitBlt, 2, 0, kFmtBitBlt, 5, 3, kFmtUnused, -1, -1,
@@ -162,12 +162,12 @@
                  "bkpt", "!0d", 1),
     ENCODING_MAP(kThumbBlx1,         0xf000,
                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR,
-                 "blx_1", "!0u", 1),
+                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR |
+                 NEEDS_FIXUP, "blx_1", "!0u", 1),
     ENCODING_MAP(kThumbBlx2,         0xe800,
                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR,
-                 "blx_2", "!0v", 1),
+                 kFmtUnused, -1, -1, IS_BINARY_OP | IS_BRANCH | REG_DEF_LR |
+                 NEEDS_FIXUP, "blx_2", "!0v", 1),
     ENCODING_MAP(kThumbBl1,          0xf000,
                  kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1, IS_UNARY_OP | IS_BRANCH | REG_DEF_LR,
@@ -230,7 +230,7 @@
     ENCODING_MAP(kThumbLdrPcRel,    0x4800,
                  kFmtBitBlt, 10, 8, kFmtBitBlt, 7, 0, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC
-                 | IS_LOAD, "ldr", "!0C, [pc, #!1E]", 1),
+                 | IS_LOAD | NEEDS_FIXUP, "ldr", "!0C, [pc, #!1E]", 1),
     ENCODING_MAP(kThumbLdrSpRel,    0x9800,
                  kFmtBitBlt, 10, 8, kFmtUnused, -1, -1, kFmtBitBlt, 7, 0,
                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0 | REG_USE_SP
@@ -405,11 +405,11 @@
     ENCODING_MAP(kThumb2Vldrs,       0xed900a00,
                  kFmtSfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD |
-                 REG_DEF_LR, "vldr", "!0s, [!1C, #!2E]", 2),
+                 REG_DEF_LR | NEEDS_FIXUP, "vldr", "!0s, [!1C, #!2E]", 2),
     ENCODING_MAP(kThumb2Vldrd,       0xed900b00,
                  kFmtDfp, 22, 12, kFmtBitBlt, 19, 16, kFmtBitBlt, 7, 0,
                  kFmtUnused, -1, -1, IS_TERTIARY_OP | REG_DEF0_USE1 | IS_LOAD |
-                 REG_DEF_LR, "vldr", "!0S, [!1C, #!2E]", 2),
+                 REG_DEF_LR | NEEDS_FIXUP, "vldr", "!0S, [!1C, #!2E]", 2),
     ENCODING_MAP(kThumb2Vmuls,        0xee200a00,
                  kFmtSfp, 22, 12, kFmtSfp, 7, 16, kFmtSfp, 5, 0,
                  kFmtUnused, -1, -1,
@@ -509,12 +509,12 @@
                  "ldr", "!0C, [!1C, #-!2d]", 2),
     ENCODING_MAP(kThumb2Cbnz,       0xb900, /* Note: does not affect flags */
                  kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH,
-                 "cbnz", "!0C,!1t", 1),
+                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH |
+                 NEEDS_FIXUP, "cbnz", "!0C,!1t", 1),
     ENCODING_MAP(kThumb2Cbz,       0xb100, /* Note: does not affect flags */
                  kFmtBitBlt, 2, 0, kFmtImm6, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH,
-                 "cbz", "!0C,!1t", 1),
+                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_USE0 | IS_BRANCH |
+                 NEEDS_FIXUP, "cbz", "!0C,!1t", 1),
     ENCODING_MAP(kThumb2AddRRI12,       0xf2000000,
                  kFmtBitBlt, 11, 8, kFmtBitBlt, 19, 16, kFmtImm12, -1, -1,
                  kFmtUnused, -1, -1,
@@ -644,12 +644,12 @@
                  kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_DEF_LIST0
-                 | IS_LOAD, "pop", "<!0R>", 2),
+                 | IS_LOAD | NEEDS_FIXUP, "pop", "<!0R>", 2),
     ENCODING_MAP(kThumb2Push,          0xe92d0000,
                  kFmtBitBlt, 15, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
                  IS_UNARY_OP | REG_DEF_SP | REG_USE_SP | REG_USE_LIST0
-                 | IS_STORE, "push", "<!0R>", 2),
+                 | IS_STORE | NEEDS_FIXUP, "push", "<!0R>", 2),
     ENCODING_MAP(kThumb2CmpRI8, 0xf1b00f00,
                  kFmtBitBlt, 19, 16, kFmtModImm, -1, -1, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
@@ -791,12 +791,12 @@
     ENCODING_MAP(kThumb2LdrPcRel12,       0xf8df0000,
                  kFmtBitBlt, 15, 12, kFmtBitBlt, 11, 0, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
-                 IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD,
+                 IS_TERTIARY_OP | REG_DEF0 | REG_USE_PC | IS_LOAD | NEEDS_FIXUP,
                  "ldr", "!0C, [r15pc, #!1d]", 2),
     ENCODING_MAP(kThumb2BCond,        0xf0008000,
                  kFmtBrOffset, -1, -1, kFmtBitBlt, 25, 22, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
-                 IS_BINARY_OP | IS_BRANCH | USES_CCODES,
+                 IS_BINARY_OP | IS_BRANCH | USES_CCODES | NEEDS_FIXUP,
                  "b!1c", "!0t", 2),
     ENCODING_MAP(kThumb2Vmovd_RR,       0xeeb00b40,
                  kFmtDfp, 22, 12, kFmtDfp, 5, 0, kFmtUnused, -1, -1,
@@ -931,15 +931,16 @@
     ENCODING_MAP(kThumb2Adr,         0xf20f0000,
                  kFmtBitBlt, 11, 8, kFmtImm12, -1, -1, kFmtUnused, -1, -1,
                  kFmtUnused, -1, -1,
-                 IS_TERTIARY_OP | REG_DEF0,/* Note: doesn't affect flags */
+                 /* Note: doesn't affect flags */
+                 IS_TERTIARY_OP | REG_DEF0 | NEEDS_FIXUP,
                  "adr", "!0C,#!1d", 2),
     ENCODING_MAP(kThumb2MovImm16LST,     0xf2400000,
                  kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
+                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0 | NEEDS_FIXUP,
                  "mov", "!0C, #!1M", 2),
     ENCODING_MAP(kThumb2MovImm16HST,     0xf2c00000,
                  kFmtBitBlt, 11, 8, kFmtImm16, -1, -1, kFmtUnused, -1, -1,
-                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0,
+                 kFmtUnused, -1, -1, IS_BINARY_OP | REG_DEF0 | NEEDS_FIXUP,
                  "movh", "!0C, #!1M", 2),
     ENCODING_MAP(kThumb2LdmiaWB,         0xe8b00000,
                  kFmtBitBlt, 19, 16, kFmtBitBlt, 15, 0, kFmtUnused, -1, -1,
@@ -1067,6 +1068,7 @@
     AssemblerStatus res = kSuccess;  // Assume success
 
     for (lir = (ArmLIR *) cUnit->firstLIRInsn; lir; lir = NEXT_LIR(lir)) {
+
         if (lir->opcode < 0) {
             if ((lir->opcode == kArmPseudoPseudoAlign4) &&
                 /* 1 means padding is needed */
@@ -1091,244 +1093,249 @@
          * Of course, the patching itself may cause new overflows so this
          * is an iterative process.
          */
-
-        if (lir->opcode == kThumbLdrPcRel ||
-            lir->opcode == kThumb2LdrPcRel12 ||
-            lir->opcode == kThumbAddPcRel ||
-            ((lir->opcode == kThumb2Vldrd) && (lir->operands[1] == r15pc)) ||
-            ((lir->opcode == kThumb2Vldrs) && (lir->operands[1] == r15pc))) {
-            /*
-             * PC-relative loads are mostly used to load immediates
-             * that are too large to materialize directly in one shot.
-             * However, if the load displacement exceeds the limit,
-             * we revert to a 2-instruction materialization sequence.
-             */
-            ArmLIR *lirTarget = (ArmLIR *) lir->generic.target;
-            intptr_t pc = (lir->generic.offset + 4) & ~3;
-            intptr_t target = lirTarget->generic.offset;
-            int delta = target - pc;
-            if (delta & 0x3) {
-                LOG(FATAL) << "PC-rel offset not multiple of 4: " << delta;
-            }
-            // First, a sanity check for cases we shouldn't see now
-            if (((lir->opcode == kThumbAddPcRel) && (delta > 1020)) ||
-                ((lir->opcode == kThumbLdrPcRel) && (delta > 1020))) {
-                // Shouldn't happen in current codegen.
-                LOG(FATAL) << "Unexpected pc-rel offset " << delta;
-            }
-            // Now, check for the two difficult cases
-            if (((lir->opcode == kThumb2LdrPcRel12) && (delta > 4091)) ||
-                ((lir->opcode == kThumb2Vldrs) && (delta > 1020)) ||
-                ((lir->opcode == kThumb2Vldrd) && (delta > 1020))) {
+        if (lir->flags.pcRelFixup) {
+            if (lir->opcode == kThumbLdrPcRel ||
+                lir->opcode == kThumb2LdrPcRel12 ||
+                lir->opcode == kThumbAddPcRel ||
+                ((lir->opcode == kThumb2Vldrd) && (lir->operands[1] == r15pc)) ||
+                ((lir->opcode == kThumb2Vldrs) && (lir->operands[1] == r15pc))) {
                 /*
-                 * Note: because rLR may be used to fix up out-of-range
-                 * vldrs/vldrd we include REG_DEF_LR in the resource
-                 * masks for these instructions.
+                 * PC-relative loads are mostly used to load immediates
+                 * that are too large to materialize directly in one shot.
+                 * However, if the load displacement exceeds the limit,
+                 * we revert to a 2-instruction materialization sequence.
                  */
-                int baseReg = (lir->opcode == kThumb2LdrPcRel12) ?
-                    lir->operands[0] : rLR;
-
-                // Add new Adr to generate the address
-                ArmLIR *newAdr =
-                    (ArmLIR *)oatNew(sizeof(ArmLIR), true);
-                newAdr->generic.dalvikOffset = lir->generic.dalvikOffset;
-                newAdr->generic.target = lir->generic.target;
-                newAdr->opcode = kThumb2Adr;
-                newAdr->operands[0] = baseReg;
-                oatSetupResourceMasks(newAdr);
-                oatInsertLIRBefore((LIR*)lir, (LIR*)newAdr);
-
-                // Convert to normal load
-                if (lir->opcode == kThumb2LdrPcRel12) {
-                    lir->opcode = kThumb2LdrRRI12;
+                ArmLIR *lirTarget = (ArmLIR *) lir->generic.target;
+                intptr_t pc = (lir->generic.offset + 4) & ~3;
+                intptr_t target = lirTarget->generic.offset;
+                int delta = target - pc;
+                if (delta & 0x3) {
+                    LOG(FATAL) << "PC-rel offset not multiple of 4: " << delta;
                 }
-                // Change the load to be relative to the new Adr base
-                lir->operands[1] = baseReg;
-                lir->operands[2] = 0;
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            } else {
-                if ((lir->opcode == kThumb2Vldrs) ||
-                    (lir->opcode == kThumb2Vldrd)) {
-                    lir->operands[2] = delta >> 2;
+                // First, a sanity check for cases we shouldn't see now
+                if (((lir->opcode == kThumbAddPcRel) && (delta > 1020)) ||
+                    ((lir->opcode == kThumbLdrPcRel) && (delta > 1020))) {
+                    // Shouldn't happen in current codegen.
+                    LOG(FATAL) << "Unexpected pc-rel offset " << delta;
+                }
+                // Now, check for the two difficult cases
+                if (((lir->opcode == kThumb2LdrPcRel12) && (delta > 4091)) ||
+                    ((lir->opcode == kThumb2Vldrs) && (delta > 1020)) ||
+                    ((lir->opcode == kThumb2Vldrd) && (delta > 1020))) {
+                    /*
+                     * Note: because rLR may be used to fix up out-of-range
+                     * vldrs/vldrd we include REG_DEF_LR in the resource
+                     * masks for these instructions.
+                     */
+                    int baseReg = (lir->opcode == kThumb2LdrPcRel12) ?
+                        lir->operands[0] : rLR;
+
+                    // Add new Adr to generate the address
+                    ArmLIR *newAdr =
+                        (ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);
+                    newAdr->generic.dalvikOffset = lir->generic.dalvikOffset;
+                    newAdr->generic.target = lir->generic.target;
+                    newAdr->opcode = kThumb2Adr;
+                    newAdr->operands[0] = baseReg;
+                    oatSetupResourceMasks(newAdr);
+                    oatInsertLIRBefore((LIR*)lir, (LIR*)newAdr);
+
+                    // Convert to normal load
+                    if (lir->opcode == kThumb2LdrPcRel12) {
+                        lir->opcode = kThumb2LdrRRI12;
+                    }
+                    // Change the load to be relative to the new Adr base
+                    lir->operands[1] = baseReg;
+                    lir->operands[2] = 0;
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
                 } else {
-                    lir->operands[1] = (lir->opcode == kThumb2LdrPcRel12) ?
-                                        delta : delta >> 2;
-                }
-            }
-        } else if (lir->opcode == kThumb2Cbnz || lir->opcode == kThumb2Cbz) {
-            ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
-            intptr_t pc = lir->generic.offset + 4;
-            intptr_t target = targetLIR->generic.offset;
-            int delta = target - pc;
-            if (delta > 126 || delta < 0) {
-                /* Convert to cmp rx,#0 / b[eq/ne] tgt pair */
-                ArmLIR *newInst =
-                    (ArmLIR *)oatNew(sizeof(ArmLIR), true);
-                /* Make new branch instruction and insert after */
-                newInst->generic.dalvikOffset = lir->generic.dalvikOffset;
-                newInst->opcode = kThumbBCond;
-                newInst->operands[0] = 0;
-                newInst->operands[1] = (lir->opcode == kThumb2Cbz) ?
-                                        kArmCondEq : kArmCondNe;
-                newInst->generic.target = lir->generic.target;
-                oatSetupResourceMasks(newInst);
-                oatInsertLIRAfter((LIR *)lir, (LIR *)newInst);
-                /* Convert the cb[n]z to a cmp rx, #0 ] */
-                lir->opcode = kThumbCmpRI8;
-                /* operand[0] is src1 in both cb[n]z & CmpRI8 */
-                lir->operands[1] = 0;
-                lir->generic.target = 0;
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            } else {
-                lir->operands[1] = delta >> 1;
-            }
-        } else if (lir->opcode == kThumb2Push ||
-                   lir->opcode == kThumb2Pop) {
-            if (__builtin_popcount(lir->operands[0]) == 1) {
-                /*
-                 * The standard push/pop multiple instruction
-                 * requires at least two registers in the list.
-                 * If we've got just one, switch to the single-reg
-                 * encoding.
-                 */
-                lir->opcode = (lir->opcode == kThumb2Push)
-                    ? kThumb2Push1 : kThumb2Pop1;
-                int reg = 0;
-                while (lir->operands[0]) {
-                    if (lir->operands[0] & 0x1) {
-                        break;
+                    if ((lir->opcode == kThumb2Vldrs) ||
+                        (lir->opcode == kThumb2Vldrd)) {
+                        lir->operands[2] = delta >> 2;
                     } else {
-                        reg++;
-                        lir->operands[0] >>= 1;
+                        lir->operands[1] = (lir->opcode == kThumb2LdrPcRel12) ?
+                                            delta : delta >> 2;
                     }
                 }
-                lir->operands[0] = reg;
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            }
-        } else if (lir->opcode == kThumbBCond ||
-                   lir->opcode == kThumb2BCond) {
-            ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
-            int delta = 0;
-            DCHECK(targetLIR);
-            intptr_t pc = lir->generic.offset + 4;
-            intptr_t target = targetLIR->generic.offset;
-            delta = target - pc;
-            if ((lir->opcode == kThumbBCond) && (delta > 254 || delta < -256)) {
-                lir->opcode = kThumb2BCond;
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            }
-            lir->operands[0] = delta >> 1;
-        } else if (lir->opcode == kThumb2BUncond) {
-            ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
-            intptr_t pc = lir->generic.offset + 4;
-            intptr_t target = targetLIR->generic.offset;
-            int delta = target - pc;
-            lir->operands[0] = delta >> 1;
-            if (lir->operands[0] == 0) {  // Useless branch?
-                lir->flags.isNop = true;
-                res = kRetryAll;
-            }
-        } else if (lir->opcode == kThumbBUncond) {
-            ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
-            intptr_t pc = lir->generic.offset + 4;
-            intptr_t target = targetLIR->generic.offset;
-            int delta = target - pc;
-            if (delta > 2046 || delta < -2048) {
-                // Convert to Thumb2BCond w/ kArmCondAl
-                lir->opcode = kThumb2BUncond;
-                lir->operands[0] = 0;
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            }
-            lir->operands[0] = delta >> 1;
-            if ((lir->operands[0] == 0) ||
-                (lir->operands[0] == -1)) {  // Useless branch?
-                lir->flags.isNop = true;
-                res = kRetryAll;
-            }
-        } else if (lir->opcode == kThumbBlx1) {
-            DCHECK(NEXT_LIR(lir)->opcode == kThumbBlx2);
-            /* curPC is Thumb */
-            intptr_t curPC = (startAddr + lir->generic.offset + 4) & ~3;
-            intptr_t target = lir->operands[1];
+            } else if (lir->opcode == kThumb2Cbnz || lir->opcode == kThumb2Cbz) {
+                ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
+                intptr_t pc = lir->generic.offset + 4;
+                intptr_t target = targetLIR->generic.offset;
+                int delta = target - pc;
+                if (delta > 126 || delta < 0) {
+                    /* Convert to cmp rx,#0 / b[eq/ne] tgt pair */
+                    ArmLIR *newInst =
+                        (ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);
+                    /* Make new branch instruction and insert after */
+                    newInst->generic.dalvikOffset = lir->generic.dalvikOffset;
+                    newInst->opcode = kThumbBCond;
+                    newInst->operands[0] = 0;
+                    newInst->operands[1] = (lir->opcode == kThumb2Cbz) ?
+                                            kArmCondEq : kArmCondNe;
+                    newInst->generic.target = lir->generic.target;
+                    oatSetupResourceMasks(newInst);
+                    oatInsertLIRAfter((LIR *)lir, (LIR *)newInst);
+                    /* Convert the cb[n]z to a cmp rx, #0 ] */
+                    lir->opcode = kThumbCmpRI8;
+                    /* operand[0] is src1 in both cb[n]z & CmpRI8 */
+                    lir->operands[1] = 0;
+                    lir->generic.target = 0;
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
+                } else {
+                    lir->operands[1] = delta >> 1;
+                }
+            } else if (lir->opcode == kThumb2Push ||
+                       lir->opcode == kThumb2Pop) {
+                if (__builtin_popcount(lir->operands[0]) == 1) {
+                    /*
+                     * The standard push/pop multiple instruction
+                     * requires at least two registers in the list.
+                     * If we've got just one, switch to the single-reg
+                     * encoding.
+                     */
+                    lir->opcode = (lir->opcode == kThumb2Push)
+                        ? kThumb2Push1 : kThumb2Pop1;
+                    int reg = 0;
+                    while (lir->operands[0]) {
+                        if (lir->operands[0] & 0x1) {
+                            break;
+                        } else {
+                            reg++;
+                            lir->operands[0] >>= 1;
+                        }
+                    }
+                    lir->operands[0] = reg;
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
+                }
+            } else if (lir->opcode == kThumbBCond ||
+                       lir->opcode == kThumb2BCond) {
+                ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
+                int delta = 0;
+                DCHECK(targetLIR);
+                intptr_t pc = lir->generic.offset + 4;
+                intptr_t target = targetLIR->generic.offset;
+                delta = target - pc;
+                if ((lir->opcode == kThumbBCond) &&
+                    (delta > 254 || delta < -256)) {
+                    lir->opcode = kThumb2BCond;
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
+                }
+                lir->operands[0] = delta >> 1;
+            } else if (lir->opcode == kThumb2BUncond) {
+                ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
+                intptr_t pc = lir->generic.offset + 4;
+                intptr_t target = targetLIR->generic.offset;
+                int delta = target - pc;
+                lir->operands[0] = delta >> 1;
+                if (lir->operands[0] == 0) {  // Useless branch?
+                    lir->flags.isNop = true;
+                    res = kRetryAll;
+                }
+            } else if (lir->opcode == kThumbBUncond) {
+                ArmLIR *targetLIR = (ArmLIR *) lir->generic.target;
+                intptr_t pc = lir->generic.offset + 4;
+                intptr_t target = targetLIR->generic.offset;
+                int delta = target - pc;
+                if (delta > 2046 || delta < -2048) {
+                    // Convert to Thumb2BCond w/ kArmCondAl
+                    lir->opcode = kThumb2BUncond;
+                    lir->operands[0] = 0;
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
+                }
+                lir->operands[0] = delta >> 1;
+                if ((lir->operands[0] == 0) ||
+                    (lir->operands[0] == -1)) {  // Useless branch?
+                    lir->flags.isNop = true;
+                    res = kRetryAll;
+                }
+            } else if (lir->opcode == kThumbBlx1) {
+                DCHECK(NEXT_LIR(lir)->opcode == kThumbBlx2);
+                /* curPC is Thumb */
+                intptr_t curPC = (startAddr + lir->generic.offset + 4) & ~3;
+                intptr_t target = lir->operands[1];
 
-            /* Match bit[1] in target with base */
-            if (curPC & 0x2) {
-                target |= 0x2;
+                /* Match bit[1] in target with base */
+                if (curPC & 0x2) {
+                    target |= 0x2;
+                }
+                int delta = target - curPC;
+                DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));
+
+                lir->operands[0] = (delta >> 12) & 0x7ff;
+                NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
+            } else if (lir->opcode == kThumbBl1) {
+                DCHECK(NEXT_LIR(lir)->opcode == kThumbBl2);
+                /* Both curPC and target are Thumb */
+                intptr_t curPC = startAddr + lir->generic.offset + 4;
+                intptr_t target = lir->operands[1];
+
+                int delta = target - curPC;
+                DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));
+
+                lir->operands[0] = (delta >> 12) & 0x7ff;
+                NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
+            } else if (lir->opcode == kThumb2Adr) {
+                SwitchTable *tabRec = (SwitchTable*)lir->operands[2];
+                ArmLIR* target = (ArmLIR*)lir->generic.target;
+                int targetDisp = tabRec ? tabRec->offset
+                                        : target->generic.offset;
+                int disp = targetDisp - ((lir->generic.offset + 4) & ~3);
+                if (disp < 4096) {
+                    lir->operands[1] = disp;
+                } else {
+                    // convert to ldimm16l, ldimm16h, add tgt, pc, operands[0]
+                    ArmLIR *newMov16L =
+                        (ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);
+                    newMov16L->generic.dalvikOffset = lir->generic.dalvikOffset;
+                    newMov16L->generic.target = lir->generic.target;
+                    newMov16L->opcode = kThumb2MovImm16LST;
+                    newMov16L->operands[0] = lir->operands[0];
+                    newMov16L->operands[2] = (intptr_t)lir;
+                    newMov16L->operands[3] = (intptr_t)tabRec;
+                    oatSetupResourceMasks(newMov16L);
+                    oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16L);
+                    ArmLIR *newMov16H =
+                        (ArmLIR *)oatNew(sizeof(ArmLIR), true, kAllocLIR);
+                    newMov16H->generic.dalvikOffset = lir->generic.dalvikOffset;
+                    newMov16H->generic.target = lir->generic.target;
+                    newMov16H->opcode = kThumb2MovImm16HST;
+                    newMov16H->operands[0] = lir->operands[0];
+                    newMov16H->operands[2] = (intptr_t)lir;
+                    newMov16H->operands[3] = (intptr_t)tabRec;
+                    oatSetupResourceMasks(newMov16H);
+                    oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16H);
+                    lir->opcode = kThumb2AddRRR;
+                    lir->operands[1] = rPC;
+                    lir->operands[2] = lir->operands[0];
+                    oatSetupResourceMasks(lir);
+                    res = kRetryAll;
+                }
+            } else if (lir->opcode == kThumb2MovImm16LST) {
+                // operands[1] should hold disp, [2] has add, [3] has tabRec
+                ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];
+                SwitchTable *tabRec = (SwitchTable*)lir->operands[3];
+                // If tabRec is null, this is a literal load. Use generic.target
+                ArmLIR* target = (ArmLIR*)lir->generic.target;
+                int targetDisp = tabRec ? tabRec->offset
+                                        : target->generic.offset;
+                lir->operands[1] = (targetDisp -
+                    (addPCInst->generic.offset + 4)) & 0xffff;
+            } else if (lir->opcode == kThumb2MovImm16HST) {
+                // operands[1] should hold disp, [2] has add, [3] has tabRec
+                ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];
+                SwitchTable *tabRec = (SwitchTable*)lir->operands[3];
+                // If tabRec is null, this is a literal load. Use generic.target
+                ArmLIR* target = (ArmLIR*)lir->generic.target;
+                int targetDisp = tabRec ? tabRec->offset
+                                        : target->generic.offset;
+                lir->operands[1] = ((targetDisp -
+                    (addPCInst->generic.offset + 4)) >> 16) & 0xffff;
             }
-            int delta = target - curPC;
-            DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));
-
-            lir->operands[0] = (delta >> 12) & 0x7ff;
-            NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
-        } else if (lir->opcode == kThumbBl1) {
-            DCHECK(NEXT_LIR(lir)->opcode == kThumbBl2);
-            /* Both curPC and target are Thumb */
-            intptr_t curPC = startAddr + lir->generic.offset + 4;
-            intptr_t target = lir->operands[1];
-
-            int delta = target - curPC;
-            DCHECK((delta >= -(1<<22)) && (delta <= ((1<<22)-2)));
-
-            lir->operands[0] = (delta >> 12) & 0x7ff;
-            NEXT_LIR(lir)->operands[0] = (delta>> 1) & 0x7ff;
-        } else if (lir->opcode == kThumb2Adr) {
-            SwitchTable *tabRec = (SwitchTable*)lir->operands[2];
-            ArmLIR* target = (ArmLIR*)lir->generic.target;
-            int targetDisp = tabRec ? tabRec->offset : target->generic.offset;
-            int disp = targetDisp - ((lir->generic.offset + 4) & ~3);
-            if (disp < 4096) {
-                lir->operands[1] = disp;
-            } else {
-                // convert to ldimm16l, ldimm16h, add tgt, pc, operands[0]
-                ArmLIR *newMov16L =
-                    (ArmLIR *)oatNew(sizeof(ArmLIR), true);
-                newMov16L->generic.dalvikOffset = lir->generic.dalvikOffset;
-                newMov16L->generic.target = lir->generic.target;
-                newMov16L->opcode = kThumb2MovImm16LST;
-                newMov16L->operands[0] = lir->operands[0];
-                newMov16L->operands[2] = (intptr_t)lir;
-                newMov16L->operands[3] = (intptr_t)tabRec;
-                oatSetupResourceMasks(newMov16L);
-                oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16L);
-                ArmLIR *newMov16H =
-                    (ArmLIR *)oatNew(sizeof(ArmLIR), true);
-                newMov16H->generic.dalvikOffset = lir->generic.dalvikOffset;
-                newMov16H->generic.target = lir->generic.target;
-                newMov16H->opcode = kThumb2MovImm16HST;
-                newMov16H->operands[0] = lir->operands[0];
-                newMov16H->operands[2] = (intptr_t)lir;
-                newMov16H->operands[3] = (intptr_t)tabRec;
-                oatSetupResourceMasks(newMov16H);
-                oatInsertLIRBefore((LIR*)lir, (LIR*)newMov16H);
-                lir->opcode = kThumb2AddRRR;
-                lir->operands[1] = rPC;
-                lir->operands[2] = lir->operands[0];
-                oatSetupResourceMasks(lir);
-                res = kRetryAll;
-            }
-        } else if (lir->opcode == kThumb2MovImm16LST) {
-            // operands[1] should hold disp, [2] has add, [3] has tabRec
-            ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];
-            SwitchTable *tabRec = (SwitchTable*)lir->operands[3];
-            // If tabRec is null, this is a literal load - use generic.target
-            ArmLIR* target = (ArmLIR*)lir->generic.target;
-            int targetDisp = tabRec ? tabRec->offset : target->generic.offset;
-            lir->operands[1] = (targetDisp -
-                (addPCInst->generic.offset + 4)) & 0xffff;
-        } else if (lir->opcode == kThumb2MovImm16HST) {
-            // operands[1] should hold disp, [2] has add, [3] has tabRec
-            ArmLIR *addPCInst = (ArmLIR*)lir->operands[2];
-            SwitchTable *tabRec = (SwitchTable*)lir->operands[3];
-            // If tabRec is null, this is a literal load - use generic.target
-            ArmLIR* target = (ArmLIR*)lir->generic.target;
-            int targetDisp = tabRec ? tabRec->offset : target->generic.offset;
-            lir->operands[1] = ((targetDisp -
-                (addPCInst->generic.offset + 4)) >> 16) & 0xffff;
         }
         ArmEncodingMap *encoder = &EncodingMap[lir->opcode];
         u4 bits = encoder->skeleton;
@@ -1526,9 +1533,11 @@
          armLIR;
          armLIR = NEXT_LIR(armLIR)) {
         armLIR->generic.offset = offset;
-        if (armLIR->opcode >= 0 && !armLIR->flags.isNop) {
-            armLIR->flags.size = EncodingMap[armLIR->opcode].size * 2;
-            offset += armLIR->flags.size;
+        if (armLIR->opcode >= 0) {
+            if (!armLIR->flags.isNop) {
+                armLIR->flags.size = EncodingMap[armLIR->opcode].size * 2;
+                offset += armLIR->flags.size;
+            }
         } else if (armLIR->opcode == kArmPseudoPseudoAlign4) {
             if (offset & 0x2) {
                 offset += 2;
diff --git a/src/compiler/codegen/arm/CodegenCommon.cc b/src/compiler/codegen/arm/CodegenCommon.cc
index 26c17ef..c99573f 100644
--- a/src/compiler/codegen/arm/CodegenCommon.cc
+++ b/src/compiler/codegen/arm/CodegenCommon.cc
@@ -124,6 +124,10 @@
 
     flags = EncodingMap[lir->opcode].flags;
 
+    if (flags & NEEDS_FIXUP) {
+        lir->flags.pcRelFixup = true;
+    }
+
     /* Set up the mask for resources that are updated */
     if (flags & (IS_LOAD | IS_STORE)) {
         /* Default to heap - will catch specialized classes later */
@@ -241,7 +245,7 @@
  */
 STATIC ArmLIR* newLIR0(CompilationUnit* cUnit, ArmOpcode opcode)
 {
-    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & NO_OPERAND));
     insn->opcode = opcode;
     setupResourceMasks(insn);
@@ -253,7 +257,7 @@
 STATIC ArmLIR* newLIR1(CompilationUnit* cUnit, ArmOpcode opcode,
                            int dest)
 {
-    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     DCHECK(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_UNARY_OP));
     insn->opcode = opcode;
     insn->operands[0] = dest;
@@ -266,7 +270,7 @@
 STATIC ArmLIR* newLIR2(CompilationUnit* cUnit, ArmOpcode opcode,
                            int dest, int src1)
 {
-    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     DCHECK(isPseudoOpcode(opcode) ||
            (EncodingMap[opcode].flags & IS_BINARY_OP));
     insn->opcode = opcode;
@@ -281,7 +285,7 @@
 STATIC ArmLIR* newLIR3(CompilationUnit* cUnit, ArmOpcode opcode,
                            int dest, int src1, int src2)
 {
-    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     DCHECK(isPseudoOpcode(opcode) ||
            (EncodingMap[opcode].flags & IS_TERTIARY_OP))
             << (int)opcode << " "
@@ -301,7 +305,7 @@
 STATIC ArmLIR* newLIR4(CompilationUnit* cUnit, ArmOpcode opcode,
                            int dest, int src1, int src2, int info)
 {
-    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* insn = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     DCHECK(isPseudoOpcode(opcode) ||
            (EncodingMap[opcode].flags & IS_QUAD_OP));
     insn->opcode = opcode;
@@ -361,7 +365,7 @@
 {
     /* Add the constant to the literal pool */
     if (constantListP) {
-        ArmLIR* newValue = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+        ArmLIR* newValue = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocData);
         newValue->operands[0] = value;
         newValue->generic.next = *constantListP;
         *constantListP = (LIR*) newValue;
diff --git a/src/compiler/codegen/arm/LocalOptimizations.cc b/src/compiler/codegen/arm/LocalOptimizations.cc
index eba701b..2883209 100644
--- a/src/compiler/codegen/arm/LocalOptimizations.cc
+++ b/src/compiler/codegen/arm/LocalOptimizations.cc
@@ -236,7 +236,7 @@
                 /* Only sink store instructions */
                 if (sinkDistance && !isThisLIRLoad) {
                     ArmLIR* newStoreLIR =
-                        (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+                        (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
                     *newStoreLIR = *thisLIR;
                     /*
                      * Stop point found - insert *before* the checkLIR
@@ -424,7 +424,7 @@
             if (slot >= 0) {
                 ArmLIR* curLIR = prevInstList[slot];
                 ArmLIR* newLoadLIR = (ArmLIR* ) oatNew(sizeof(ArmLIR),
-                                                               true);
+                                                       true, kAllocLIR);
                 *newLoadLIR = *thisLIR;
                 /*
                  * Insertion is guaranteed to succeed since checkLIR
diff --git a/src/compiler/codegen/arm/MethodCodegenDriver.cc b/src/compiler/codegen/arm/MethodCodegenDriver.cc
index bb66451..1efab12 100644
--- a/src/compiler/codegen/arm/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/arm/MethodCodegenDriver.cc
@@ -1859,13 +1859,20 @@
 STATIC void handleExtendedMethodMIR(CompilationUnit* cUnit, MIR* mir)
 {
     int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
-    char* msg = (char*)oatNew(strlen(extendedMIROpNames[opOffset]) + 1, false);
-    strcpy(msg, extendedMIROpNames[opOffset]);
+    char* msg = NULL;
+    if (cUnit->printMe) {
+        msg = (char*)oatNew(strlen(extendedMIROpNames[opOffset]) + 1, false,
+                            kAllocDebugInfo);
+        strcpy(msg, extendedMIROpNames[opOffset]);
+    }
     ArmLIR* op = newLIR1(cUnit, kArmPseudoExtended, (int) msg);
 
     switch ((ExtendedMIROpcode)mir->dalvikInsn.opcode) {
         case kMirOpPhi: {
-            char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);
+            char* ssaString = NULL;
+            if (cUnit->printMe) {
+                ssaString = oatGetSSAString(cUnit, mir->ssaRep);
+            }
             op->flags.isNop = true;
             newLIR1(cUnit, kArmPseudoSSARep, (int) ssaString);
             break;
@@ -2043,9 +2050,10 @@
         ArmLIR* boundaryLIR;
 
         /* Mark the beginning of a Dalvik instruction for line tracking */
+        char* instStr = cUnit->printMe ?
+           oatGetDalvikDisassembly(&mir->dalvikInsn, "") : NULL;
         boundaryLIR = newLIR1(cUnit, kArmPseudoDalvikByteCodeBoundary,
-                             (int) oatGetDalvikDisassembly(
-                             &mir->dalvikInsn, ""));
+                              (intptr_t) instStr);
         cUnit->boundaryMap.insert(std::make_pair(mir->offset,
                                  (LIR*)boundaryLIR));
         /* Remember the first LIR for this block */
@@ -2227,7 +2235,7 @@
 {
     /* Used to hold the labels of each block */
     cUnit->blockLabelList =
-        (void *) oatNew(sizeof(ArmLIR) * cUnit->numBlocks, true);
+        (void *) oatNew(sizeof(ArmLIR) * cUnit->numBlocks, true, kAllocLIR);
 
     oatDataFlowAnalysisDispatcher(cUnit, methodBlockCodeGen,
                                   kPreOrderDFSTraversal, false /* Iterative */);
diff --git a/src/compiler/codegen/arm/Thumb2/Factory.cc b/src/compiler/codegen/arm/Thumb2/Factory.cc
index ebc30f8..34ffa60 100644
--- a/src/compiler/codegen/arm/Thumb2/Factory.cc
+++ b/src/compiler/codegen/arm/Thumb2/Factory.cc
@@ -69,7 +69,7 @@
     if (dataTarget == NULL) {
         dataTarget = addWordData(cUnit, &cUnit->literalList, value);
     }
-    ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     loadPcRel->generic.dalvikOffset = cUnit->currentDalvikOffset;
     loadPcRel->opcode = kThumb2Vldrs;
     loadPcRel->generic.target = (LIR* ) dataTarget;
@@ -178,7 +178,7 @@
     if (dataTarget == NULL) {
         dataTarget = addWordData(cUnit, &cUnit->literalList, value);
     }
-    ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     loadPcRel->opcode = kThumb2LdrPcRel12;
     loadPcRel->generic.target = (LIR* ) dataTarget;
     loadPcRel->generic.dalvikOffset = cUnit->currentDalvikOffset;
@@ -655,7 +655,8 @@
                 dataTarget = addWideData(cUnit, &cUnit->literalList, valLo,
                                          valHi);
             }
-            ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+            ArmLIR* loadPcRel = (ArmLIR* ) oatNew(sizeof(ArmLIR), true,
+                                                  kAllocLIR);
             loadPcRel->generic.dalvikOffset = cUnit->currentDalvikOffset;
             loadPcRel->opcode = kThumb2Vldrd;
             loadPcRel->generic.target = (LIR* ) dataTarget;
@@ -1071,7 +1072,7 @@
 
 STATIC ArmLIR* fpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
 {
-    ArmLIR* res = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    ArmLIR* res = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     res->generic.dalvikOffset = cUnit->currentDalvikOffset;
     res->operands[0] = rDest;
     res->operands[1] = rSrc;
@@ -1102,7 +1103,7 @@
     ArmOpcode opcode;
     if (FPREG(rDest) || FPREG(rSrc))
         return fpRegCopy(cUnit, rDest, rSrc);
-    res = (ArmLIR* ) oatNew(sizeof(ArmLIR), true);
+    res = (ArmLIR* ) oatNew(sizeof(ArmLIR), true, kAllocLIR);
     res->generic.dalvikOffset = cUnit->currentDalvikOffset;
     if (LOWREG(rDest) && LOWREG(rSrc))
         opcode = kThumbMovRR;
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index 1c2f850..fe0d3f2 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -134,7 +134,7 @@
     if (it == cUnit->boundaryMap.end()) {
         LOG(FATAL) << "Error: didn't find vaddr 0x" << std::hex << vaddr;
     }
-    ArmLIR* newLabel = (ArmLIR*)oatNew(sizeof(ArmLIR), true);
+    ArmLIR* newLabel = (ArmLIR*)oatNew(sizeof(ArmLIR), true, kAllocLIR);
     newLabel->generic.dalvikOffset = vaddr;
     newLabel->opcode = kArmPseudoCaseLabel;
     newLabel->operands[0] = keyVal;
@@ -260,11 +260,12 @@
     }
     // Add the table to the list - we'll process it later
     SwitchTable *tabRec = (SwitchTable *)oatNew(sizeof(SwitchTable),
-                         true);
+                         true, kAllocData);
     tabRec->table = table;
     tabRec->vaddr = mir->offset;
     int size = table[1];
-    tabRec->targets = (ArmLIR* *)oatNew(size * sizeof(ArmLIR*), true);
+    tabRec->targets = (ArmLIR* *)oatNew(size * sizeof(ArmLIR*), true,
+                                        kAllocLIR);
     oatInsertGrowableList(&cUnit->switchTables, (intptr_t)tabRec);
 
     // Get the switch value
@@ -310,11 +311,12 @@
     }
     // Add the table to the list - we'll process it later
     SwitchTable *tabRec = (SwitchTable *)oatNew(sizeof(SwitchTable),
-                         true);
+                                                true, kAllocData);
     tabRec->table = table;
     tabRec->vaddr = mir->offset;
     int size = table[1];
-    tabRec->targets = (ArmLIR* *)oatNew(size * sizeof(ArmLIR*), true);
+    tabRec->targets = (ArmLIR* *)oatNew(size * sizeof(ArmLIR*), true,
+                                        kAllocLIR);
     oatInsertGrowableList(&cUnit->switchTables, (intptr_t)tabRec);
 
     // Get the switch value
@@ -365,7 +367,7 @@
     const u2* table = cUnit->insns + mir->offset + mir->dalvikInsn.vB;
     // Add the table to the list - we'll process it later
     FillArrayData *tabRec = (FillArrayData *)
-         oatNew(sizeof(FillArrayData), true);
+         oatNew(sizeof(FillArrayData), true, kAllocData);
     tabRec->table = table;
     tabRec->vaddr = mir->offset;
     u2 width = tabRec->table[1];
@@ -932,14 +934,17 @@
     int numTemps = sizeof(coreTemps)/sizeof(*coreTemps);
     int numFPRegs = sizeof(fpRegs)/sizeof(*fpRegs);
     int numFPTemps = sizeof(fpTemps)/sizeof(*fpTemps);
-    RegisterPool *pool = (RegisterPool *)oatNew(sizeof(*pool), true);
+    RegisterPool *pool = (RegisterPool *)oatNew(sizeof(*pool), true,
+                                                kAllocRegAlloc);
     cUnit->regPool = pool;
     pool->numCoreRegs = numRegs;
     pool->coreRegs = (RegisterInfo *)
-            oatNew(numRegs * sizeof(*cUnit->regPool->coreRegs), true);
+            oatNew(numRegs * sizeof(*cUnit->regPool->coreRegs), true,
+                   kAllocRegAlloc);
     pool->numFPRegs = numFPRegs;
     pool->FPRegs = (RegisterInfo *)
-            oatNew(numFPRegs * sizeof(*cUnit->regPool->FPRegs), true);
+            oatNew(numFPRegs * sizeof(*cUnit->regPool->FPRegs), true,
+                                      kAllocRegAlloc);
     oatInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
     oatInitPool(pool->FPRegs, fpRegs, pool->numFPRegs);
     // Keep special registers from being allocated
@@ -959,7 +964,8 @@
     }
     // Construct the alias map.
     cUnit->phiAliasMap = (int*)oatNew(cUnit->numSSARegs *
-                                      sizeof(cUnit->phiAliasMap[0]), false);
+                                      sizeof(cUnit->phiAliasMap[0]), false,
+                                      kAllocDFInfo);
     for (int i = 0; i < cUnit->numSSARegs; i++) {
         cUnit->phiAliasMap[i] = i;
     }
@@ -1810,7 +1816,7 @@
     ArmLIR* branch = opCondBranch(cUnit, kArmCondEq);
     ArmLIR* retLab = newLIR0(cUnit, kArmPseudoTargetLabel);
     retLab->defMask = ENCODE_ALL;
-    ArmLIR* target = (ArmLIR*)oatNew(sizeof(ArmLIR), true);
+    ArmLIR* target = (ArmLIR*)oatNew(sizeof(ArmLIR), true, kAllocLIR);
     target->generic.dalvikOffset = cUnit->currentDalvikOffset;
     target->opcode = kArmPseudoSuspendTarget;
     target->operands[0] = (intptr_t)retLab;