Basic block combine pass

Combine basic blocks terminated by instruction that we have since
proven not to throw.  This change is intended to relieve some of the
computational load for llvm by reducing the number of basic blocks
it has to contend with.

Also:
  Add stats to show how successful check elimination is.
  Restore mechanism to disable some expensive optimization passes when
  compiling large methods.

Change-Id: I7fae22160988cbefb90ea9fb1cc26d7364e8d229

4 files changed, 27 insertions, 23 deletions

diff --git a/src/compiler/codegen/CodegenUtil.cc b/src/compiler/codegen/CodegenUtil.cc
index 3aea76a4cc..bdc2c8b207 100644
--- a/src/compiler/codegen/CodegenUtil.cc
+++ b/src/compiler/codegen/CodegenUtil.cc
@@ -998,5 +998,20 @@ void dumpPackedSwitchTable(const u2* table)
   }
 }
 
+/*
+ * Set up special LIR to mark a Dalvik byte-code instruction start and
+ * record it in the boundaryMap.  NOTE: in cases such as kMirOpCheck in
+ * which we split a single Dalvik instruction, only the first MIR op
+ * associated with a Dalvik PC should be entered into the map.
+ */
+LIR* markBoundary(CompilationUnit* cUnit, int offset, const char* instStr)
+{
+  LIR* res = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary, (intptr_t) instStr);
+  if (cUnit->boundaryMap.find(offset) == cUnit->boundaryMap.end()) {
+    cUnit->boundaryMap.Put(offset, res);
+  }
+  return res;
+}
 
-}  // namespace art
+}
+ // namespace art
diff --git a/src/compiler/codegen/MethodBitcode.cc b/src/compiler/codegen/MethodBitcode.cc
index cfe6e6a517..8d62750a49 100644
--- a/src/compiler/codegen/MethodBitcode.cc
+++ b/src/compiler/codegen/MethodBitcode.cc
@@ -1668,8 +1668,11 @@ void convertExtendedMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
         DCHECK_EQ(rlDest.fp, loc.fp);
         DCHECK_EQ(rlDest.core, loc.core);
         DCHECK_EQ(rlDest.ref, loc.ref);
+        SafeMap<unsigned int, unsigned int>::iterator it;
+        it = cUnit->blockIdMap.find(incoming[i]);
+        DCHECK(it != cUnit->blockIdMap.end());
         phi->addIncoming(getLLVMValue(cUnit, loc.origSReg),
-                         getLLVMBlock(cUnit, incoming[i]));
+                         getLLVMBlock(cUnit, it->second));
       }
       defineValue(cUnit, phi, rlDest.origSReg);
       break;
@@ -1752,6 +1755,7 @@ void setMethodInfo(CompilationUnit* cUnit)
 /* Handle the content in each basic block */
 bool methodBlockBitcodeConversion(CompilationUnit* cUnit, BasicBlock* bb)
 {
+  if (bb->blockType == kDead) return false;
   llvm::BasicBlock* llvmBB = getLLVMBlock(cUnit, bb->id);
   cUnit->irb->SetInsertPoint(llvmBB);
   setDexOffset(cUnit, bb->startOffset);
@@ -1964,7 +1968,7 @@ bool createFunction(CompilationUnit* cUnit) {
 bool createLLVMBasicBlock(CompilationUnit* cUnit, BasicBlock* bb)
 {
   // Skip the exit block
-  if (bb->blockType == kExitBlock) {
+  if ((bb->blockType == kDead) ||(bb->blockType == kExitBlock)) {
     cUnit->idToBlockMap.Put(bb->id, NULL);
   } else {
     int offset = bb->startOffset;
@@ -2924,11 +2928,8 @@ bool methodBitcodeBlockCodeGen(CompilationUnit* cUnit, llvm::BasicBlock* bb)
     cUnit->liveSReg = INVALID_SREG;
 #endif
 
-    LIR* boundaryLIR;
-    const char* instStr = "boundary";
-    boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
-                          (intptr_t) instStr);
-    cUnit->boundaryMap.Overwrite(cUnit->currentDalvikOffset, boundaryLIR);
+    // TODO: use llvm opcode name here instead of "boundary" if verbose
+    LIR* boundaryLIR = markBoundary(cUnit, cUnit->currentDalvikOffset, "boundary");
 
     /* Remember the first LIR for thisl block*/
     if (headLIR == NULL) {
diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index b4e14ce52a..e76834d7c6 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -881,14 +881,7 @@ bool methodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
   oatResetRegPool(cUnit);
   oatResetDefTracking(cUnit);
 
-  /*
-   * If control reached us from our immediate predecessor via
-   * fallthrough and we have no other incoming arcs we can
-   * reuse existing liveness.  Otherwise, reset.
-   */
-  if (!bb->fallThroughTarget || bb->predecessors->numUsed != 1) {
-    oatClobberAllRegs(cUnit);
-  }
+  oatClobberAllRegs(cUnit);
 
   LIR* headLIR = NULL;
 
@@ -922,9 +915,7 @@ bool methodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
     /* Mark the beginning of a Dalvik instruction for line tracking */
     char* instStr = cUnit->printMe ?
        oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
-    boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
-                          (intptr_t) instStr);
-    cUnit->boundaryMap.Overwrite(mir->offset, boundaryLIR);
+    boundaryLIR = markBoundary(cUnit, mir->offset, instStr);
     /* Remember the first LIR for this block */
     if (headLIR == NULL) {
       headLIR = boundaryLIR;
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index d2532b7a47..925bbf2151 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -127,13 +127,10 @@ MIR* getNextMir(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir)
 /* Used for the "printMe" listing */
 void genPrintLabel(CompilationUnit *cUnit, MIR* mir)
 {
-  LIR* boundaryLIR;
   /* Mark the beginning of a Dalvik instruction for line tracking */
   char* instStr = cUnit->printMe ?
      oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
-  boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
-     (intptr_t) instStr);
-  cUnit->boundaryMap.Put(mir->offset, boundaryLIR);
+  markBoundary(cUnit, mir->offset, instStr);
   /* Don't generate the SSA annotation unless verbose mode is on */
   if (cUnit->printMe && mir->ssaRep) {
     char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);