diff --git a/src/compiler/CompilerUtility.h b/src/compiler/CompilerUtility.h
index 5e8e993..da3a237 100644
--- a/src/compiler/CompilerUtility.h
+++ b/src/compiler/CompilerUtility.h
@@ -132,6 +132,7 @@
 const char* oatGetShortyFromTargetIdx(CompilationUnit*, int);
 void oatDumpRegLocTable(RegLocation*, int);
 void oatDumpMemStats(CompilationUnit* cUnit);
+void oatDumpRegLoc(RegLocation loc);
 
 }  // namespace art
 
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index 70de4fc..d5e6b12 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -765,7 +765,11 @@
   cUnit->numRegs = code_item->registers_size_ - cUnit->numIns;
   cUnit->numOuts = code_item->outs_size_;
 #if defined(ART_USE_QUICK_COMPILER)
-  cUnit->genBitcode = PrettyMethod(method_idx, dex_file).find("Fibonacci.fibonacci") != std::string::npos;
+  if ((PrettyMethod(method_idx, dex_file).find("fibonacci") != std::string::npos)
+      || (PrettyMethod(method_idx, dex_file).find("HelloWorld") != std::string::npos)
+     ) {
+    cUnit->genBitcode = true;
+  }
 #endif
   /* Adjust this value accordingly once inlining is performed */
   cUnit->numDalvikRegisters = code_item->registers_size_;
@@ -782,7 +786,9 @@
         (cUnit->enableDebug & (1 << kDebugVerbose));
   }
 #if defined(ART_USE_QUICK_COMPILER)
-  if (cUnit->genBitcode) cUnit->printMe = true;
+  if (cUnit->genBitcode) {
+    cUnit->printMe = true;
+  }
 #endif
   if (cUnit->instructionSet == kX86) {
     // Disable optimizations on X86 for now
diff --git a/src/compiler/Ralloc.cc b/src/compiler/Ralloc.cc
index a3b3c50..29766e0 100644
--- a/src/compiler/Ralloc.cc
+++ b/src/compiler/Ralloc.cc
@@ -331,6 +331,10 @@
   }
 }
 
+void oatDumpRegLoc(RegLocation loc) {
+  oatDumpRegLocTable(&loc, 1);
+}
+
 static const RegLocation freshLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
                                      INVALID_REG, INVALID_REG, INVALID_SREG,
                                      INVALID_SREG};
diff --git a/src/compiler/SSATransformation.cc b/src/compiler/SSATransformation.cc
index aedf4be..6eb0415 100644
--- a/src/compiler/SSATransformation.cc
+++ b/src/compiler/SSATransformation.cc
@@ -816,9 +816,10 @@
  */
 bool insertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
 {
-  ArenaBitVector* ssaRegV = cUnit->tempSSARegisterV;
   GrowableListIterator iter;
   MIR *mir;
+  std::vector<int> uses;
+  std::vector<int> incomingArc;
 
   /* Phi nodes are at the beginning of each block */
   for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
@@ -828,7 +829,8 @@
     DCHECK_GE(ssaReg, 0);   // Shouldn't see compiler temps here
     int vReg = SRegToVReg(cUnit, ssaReg);
 
-    oatClearAllBits(ssaRegV);
+    uses.clear();
+    incomingArc.clear();
 
     /* Iterate through the predecessors */
     oatGrowableListIteratorInit(bb->predecessors, &iter);
@@ -837,12 +839,12 @@
          (BasicBlock*)oatGrowableListIteratorNext(&iter);
       if (!predBB) break;
       int ssaReg = predBB->dataFlowInfo->vRegToSSAMap[vReg];
-      oatSetBit(cUnit, ssaRegV, ssaReg);
-      cUnit->tempSSABlockIdV[ssaReg] = predBB->id;
+      uses.push_back(ssaReg);
+      incomingArc.push_back(predBB->id);
     }
 
     /* Count the number of SSA registers for a Dalvik register */
-    int numUses = oatCountSetBits(ssaRegV);
+    int numUses = uses.size();
     mir->ssaRep->numUses = numUses;
     mir->ssaRep->uses =
         (int*) oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo);
@@ -853,17 +855,11 @@
     // TODO: Ugly, rework (but don't burden each MIR/LIR for Phi-only needs)
     mir->dalvikInsn.vB = (intptr_t) incoming;
 
-    ArenaBitVectorIterator phiIterator;
-
-    oatBitVectorIteratorInit(ssaRegV, &phiIterator);
-    int *usePtr = mir->ssaRep->uses;
-
     /* Set the uses array for the phi node */
-    while (true) {
-      int ssaRegIdx = oatBitVectorIteratorNext(&phiIterator);
-      if (ssaRegIdx == -1) break;
-        *usePtr++ = ssaRegIdx;
-        *incoming++ = cUnit->tempSSABlockIdV[ssaRegIdx];
+    int *usePtr = mir->ssaRep->uses;
+    for (int i = 0; i < numUses; i++) {
+      *usePtr++ = uses[i];
+      *incoming++ = incomingArc[i];
     }
   }
 
diff --git a/src/compiler/codegen/CodegenUtil.cc b/src/compiler/codegen/CodegenUtil.cc
index 11982ba..c189eb2 100644
--- a/src/compiler/codegen/CodegenUtil.cc
+++ b/src/compiler/codegen/CodegenUtil.cc
@@ -361,7 +361,6 @@
 /* Dump instructions and constant pool contents */
 void oatCodegenDump(CompilationUnit* cUnit)
 {
-  LOG(INFO) << "/*";
   LOG(INFO) << "Dumping LIR insns for "
             << PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
   LIR* lirInsn;
diff --git a/src/compiler/codegen/CompilerCodegen.h b/src/compiler/codegen/CompilerCodegen.h
index 4508416..61ea6b6 100644
--- a/src/compiler/codegen/CompilerCodegen.h
+++ b/src/compiler/codegen/CompilerCodegen.h
@@ -31,6 +31,8 @@
 void genFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
                          bool gtBias, bool isDouble);
 
+CallInfo* oatNewCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+                         InvokeType type, bool isRange);
 
 /* Lower middle-level IR to low-level IR for the whole method */
 void oatMethodMIR2LIR(CompilationUnit* cUnit);
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index 29f3cca..a1c7645 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -1083,8 +1083,8 @@
   }
 }
 
-void genConstClass(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
-                   RegLocation rlSrc)
+void genConstClass(CompilationUnit* cUnit, uint32_t type_idx,
+                   RegLocation rlDest)
 {
   RegLocation rlMethod = loadCurrMethod(cUnit);
   int resReg = oatAllocTemp(cUnit);
@@ -1145,8 +1145,8 @@
   }
 }
 
-void genConstString(CompilationUnit* cUnit, uint32_t string_idx, RegLocation rlDest,
-          RegLocation rlSrc)
+void genConstString(CompilationUnit* cUnit, uint32_t string_idx,
+                    RegLocation rlDest)
 {
   /* NOTE: Most strings should be available at compile time */
   int32_t offset_of_string = Array::DataOffset(sizeof(String*)).Int32Value() +
diff --git a/src/compiler/codegen/MethodBitcode.cc b/src/compiler/codegen/MethodBitcode.cc
index 3b6b087..f13a473 100644
--- a/src/compiler/codegen/MethodBitcode.cc
+++ b/src/compiler/codegen/MethodBitcode.cc
@@ -28,7 +28,7 @@
 #include <llvm/Instructions.h>
 #include <llvm/Support/Casting.h>
 
-const char* labelFormat = "L0x%x_d";
+const char* labelFormat = "L0x%x_%d";
 
 namespace art {
 extern const RegLocation badLoc;
@@ -193,6 +193,8 @@
   condValue->setName(StringPrintf("t%d", cUnit->tempName++));
   cUnit->irb->CreateCondBr(condValue, getLLVMBlock(cUnit, bb->taken->id),
                            getLLVMBlock(cUnit, bb->fallThrough->id));
+  // Don't redo the fallthrough branch in the BB driver
+  bb->fallThrough = NULL;
 }
 
 void convertCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb,
@@ -212,6 +214,8 @@
   condValue->setName(StringPrintf("t%d", cUnit->tempName++));
   cUnit->irb->CreateCondBr(condValue, getLLVMBlock(cUnit, bb->taken->id),
                            getLLVMBlock(cUnit, bb->fallThrough->id));
+  // Don't redo the fallthrough branch in the BB driver
+  bb->fallThrough = NULL;
 }
 
 llvm::Value* genDivModOp(CompilationUnit* cUnit, bool isDiv, bool isLong,
@@ -314,6 +318,70 @@
   defineValue(cUnit, res, rlDest.origSReg);
 }
 
+void convertInvoke(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+                   InvokeType invokeType, bool isRange)
+{
+  CallInfo* info = oatNewCallInfo(cUnit, bb, mir, invokeType, isRange);
+  llvm::SmallVector<llvm::Value*, 10> args;
+  // Insert the invokeType
+  args.push_back(cUnit->irb->getInt32(static_cast<int>(invokeType)));
+  // Insert the method_idx
+  args.push_back(cUnit->irb->getInt32(info->index));
+  // Insert the optimization flags
+  args.push_back(cUnit->irb->getInt32(info->optFlags));
+  // Now, insert the actual arguments
+  if (cUnit->printMe) {
+    LOG(INFO) << "Building Invoke info";
+  }
+  for (int i = 0; i < info->numArgWords;) {
+    if (cUnit->printMe) {
+      oatDumpRegLoc(info->args[i]);
+    }
+    llvm::Value* val = getLLVMValue(cUnit, info->args[i].origSReg);
+    args.push_back(val);
+    i += info->args[i].wide ? 2 : 1;
+  }
+  /*
+   * Choose the invoke return type based on actual usage.  Note: may
+   * be different than shorty.  For example, if a function return value
+   * is not used, we'll treat this as a void invoke.
+   */
+  greenland::IntrinsicHelper::IntrinsicId id;
+  if (info->result.location == kLocInvalid) {
+    id = greenland::IntrinsicHelper::HLInvokeVoid;
+  } else {
+    if (info->result.wide) {
+      if (info->result.fp) {
+        id = greenland::IntrinsicHelper::HLInvokeDouble;
+      } else {
+        id = greenland::IntrinsicHelper::HLInvokeFloat;
+      }
+    } else if (info->result.ref) {
+        id = greenland::IntrinsicHelper::HLInvokeObj;
+    } else if (info->result.fp) {
+        id = greenland::IntrinsicHelper::HLInvokeFloat;
+    } else {
+        id = greenland::IntrinsicHelper::HLInvokeInt;
+    }
+  }
+  llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
+  llvm::Value* res = cUnit->irb->CreateCall(intr, args);
+  if (info->result.location != kLocInvalid) {
+    defineValue(cUnit, res, info->result.origSReg);
+  }
+}
+
+void convertConstString(CompilationUnit* cUnit, BasicBlock* bb,
+                        uint32_t string_idx, RegLocation rlDest)
+{
+  greenland::IntrinsicHelper::IntrinsicId id;
+  id = greenland::IntrinsicHelper::ConstString;
+  llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
+  llvm::Value* index = cUnit->irb->getInt32(string_idx);
+  llvm::Value* res = cUnit->irb->CreateCall(intr, index);
+  defineValue(cUnit, res, rlDest.origSReg);
+}
+
 /*
  * Target-independent code generation.  Use only high-level
  * load/store utilities here, or target-dependent genXX() handlers
@@ -327,6 +395,9 @@
   RegLocation rlDest = badLoc;
   RegLocation rlResult = badLoc;
   Instruction::Code opcode = mir->dalvikInsn.opcode;
+  uint32_t vB = mir->dalvikInsn.vB;
+  uint32_t vC = mir->dalvikInsn.vC;
+
   bool objectDefinition = false;
 
   /* Prep Src and Dest locations */
@@ -398,7 +469,7 @@
     case Instruction::CONST:
     case Instruction::CONST_4:
     case Instruction::CONST_16: {
-        llvm::Constant* immValue = cUnit->irb->GetJInt(mir->dalvikInsn.vB);
+        llvm::Constant* immValue = cUnit->irb->GetJInt(vB);
         llvm::Value* res = emitConst(cUnit, immValue, rlDest);
         defineValue(cUnit, res, rlDest.origSReg);
       }
@@ -406,14 +477,14 @@
 
     case Instruction::CONST_WIDE_16:
     case Instruction::CONST_WIDE_32: {
-        llvm::Constant* immValue = cUnit->irb->GetJLong(mir->dalvikInsn.vB);
+        llvm::Constant* immValue = cUnit->irb->GetJLong(vB);
         llvm::Value* res = emitConst(cUnit, immValue, rlDest);
         defineValue(cUnit, res, rlDest.origSReg);
       }
       break;
 
     case Instruction::CONST_HIGH16: {
-        llvm::Constant* immValue = cUnit->irb->GetJInt(mir->dalvikInsn.vB << 16);
+        llvm::Constant* immValue = cUnit->irb->GetJInt(vB << 16);
         llvm::Value* res = emitConst(cUnit, immValue, rlDest);
         defineValue(cUnit, res, rlDest.origSReg);
       }
@@ -426,7 +497,7 @@
         defineValue(cUnit, res, rlDest.origSReg);
     }
     case Instruction::CONST_WIDE_HIGH16: {
-        int64_t imm = static_cast<int64_t>(mir->dalvikInsn.vB) << 48;
+        int64_t imm = static_cast<int64_t>(vB) << 48;
         llvm::Constant* immValue = cUnit->irb->GetJLong(imm);
         llvm::Value* res = emitConst(cUnit, immValue, rlDest);
         defineValue(cUnit, res, rlDest.origSReg);
@@ -570,44 +641,44 @@
 
     case Instruction::ADD_INT_LIT16:
     case Instruction::ADD_INT_LIT8:
-      convertArithOpLit(cUnit, kOpAdd, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpAdd, rlDest, rlSrc[0], vC);
       break;
     case Instruction::RSUB_INT:
     case Instruction::RSUB_INT_LIT8:
-      convertArithOpLit(cUnit, kOpRsub, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpRsub, rlDest, rlSrc[0], vC);
       break;
     case Instruction::MUL_INT_LIT16:
     case Instruction::MUL_INT_LIT8:
-      convertArithOpLit(cUnit, kOpMul, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpMul, rlDest, rlSrc[0], vC);
       break;
     case Instruction::DIV_INT_LIT16:
     case Instruction::DIV_INT_LIT8:
-      convertArithOpLit(cUnit, kOpDiv, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpDiv, rlDest, rlSrc[0], vC);
       break;
     case Instruction::REM_INT_LIT16:
     case Instruction::REM_INT_LIT8:
-      convertArithOpLit(cUnit, kOpRem, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpRem, rlDest, rlSrc[0], vC);
       break;
     case Instruction::AND_INT_LIT16:
     case Instruction::AND_INT_LIT8:
-      convertArithOpLit(cUnit, kOpAnd, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpAnd, rlDest, rlSrc[0], vC);
       break;
     case Instruction::OR_INT_LIT16:
     case Instruction::OR_INT_LIT8:
-      convertArithOpLit(cUnit, kOpOr, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpOr, rlDest, rlSrc[0], vC);
       break;
     case Instruction::XOR_INT_LIT16:
     case Instruction::XOR_INT_LIT8:
-      convertArithOpLit(cUnit, kOpXor, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpXor, rlDest, rlSrc[0], vC);
       break;
     case Instruction::SHL_INT_LIT8:
-      convertArithOpLit(cUnit, kOpLsl, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpLsl, rlDest, rlSrc[0], vC);
       break;
     case Instruction::SHR_INT_LIT8:
-      convertArithOpLit(cUnit, kOpLsr, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpLsr, rlDest, rlSrc[0], vC);
       break;
     case Instruction::USHR_INT_LIT8:
-      convertArithOpLit(cUnit, kOpAsr, rlDest, rlSrc[0], mir->dalvikInsn.vC);
+      convertArithOpLit(cUnit, kOpAsr, rlDest, rlSrc[0], vC);
       break;
 
     case Instruction::ADD_FLOAT:
@@ -645,6 +716,47 @@
       convertFPArithOp(cUnit, kOpRem, rlDest, rlSrc[0], rlSrc[1]);
       break;
 
+    case Instruction::INVOKE_STATIC:
+      convertInvoke(cUnit, bb, mir, kStatic, false /*range*/);
+      break;
+    case Instruction::INVOKE_STATIC_RANGE:
+      convertInvoke(cUnit, bb, mir, kStatic, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_DIRECT:
+      convertInvoke(cUnit, bb,  mir, kDirect, false /*range*/);
+      break;
+    case Instruction::INVOKE_DIRECT_RANGE:
+      convertInvoke(cUnit, bb, mir, kDirect, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_VIRTUAL:
+      convertInvoke(cUnit, bb, mir, kVirtual, false /*range*/);
+      break;
+    case Instruction::INVOKE_VIRTUAL_RANGE:
+      convertInvoke(cUnit, bb, mir, kVirtual, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_SUPER:
+      convertInvoke(cUnit, bb, mir, kSuper, false /*range*/);
+      break;
+    case Instruction::INVOKE_SUPER_RANGE:
+      convertInvoke(cUnit, bb, mir, kSuper, true /*range*/);
+      break;
+
+    case Instruction::INVOKE_INTERFACE:
+      convertInvoke(cUnit, bb, mir, kInterface, false /*range*/);
+      break;
+    case Instruction::INVOKE_INTERFACE_RANGE:
+      convertInvoke(cUnit, bb, mir, kInterface, true /*range*/);
+      break;
+
+    case Instruction::CONST_STRING:
+    case Instruction::CONST_STRING_JUMBO:
+      convertConstString(cUnit, bb, vB, rlDest);
+      break;
+
+
 #if 0
 
     case Instruction::MOVE_EXCEPTION: {
@@ -715,11 +827,6 @@
       storeValue(cUnit, rlDest, rlResult);
       break;
 
-    case Instruction::CONST_STRING:
-    case Instruction::CONST_STRING_JUMBO:
-      genConstString(cUnit, mir, rlDest, rlSrc[0]);
-      break;
-
     case Instruction::CONST_CLASS:
       genConstClass(cUnit, mir, rlDest, rlSrc[0]);
       break;
@@ -884,41 +991,6 @@
       genSput(cUnit, mir, rlSrc[0], true, false);
       break;
 
-    case Instruction::INVOKE_STATIC_RANGE:
-      genInvoke(cUnit, bb, mir, kStatic, true /*range*/);
-      break;
-    case Instruction::INVOKE_STATIC:
-      genInvoke(cUnit, bb, mir, kStatic, false /*range*/);
-      break;
-
-    case Instruction::INVOKE_DIRECT:
-      genInvoke(cUnit, bb,  mir, kDirect, false /*range*/);
-      break;
-    case Instruction::INVOKE_DIRECT_RANGE:
-      genInvoke(cUnit, bb, mir, kDirect, true /*range*/);
-      break;
-
-    case Instruction::INVOKE_VIRTUAL:
-      genInvoke(cUnit, bb, mir, kVirtual, false /*range*/);
-      break;
-    case Instruction::INVOKE_VIRTUAL_RANGE:
-      genInvoke(cUnit, bb, mir, kVirtual, true /*range*/);
-      break;
-
-    case Instruction::INVOKE_SUPER:
-      genInvoke(cUnit, bb, mir, kSuper, false /*range*/);
-      break;
-    case Instruction::INVOKE_SUPER_RANGE:
-      genInvoke(cUnit, bb, mir, kSuper, true /*range*/);
-      break;
-
-    case Instruction::INVOKE_INTERFACE:
-      genInvoke(cUnit, bb, mir, kInterface, false /*range*/);
-      break;
-    case Instruction::INVOKE_INTERFACE_RANGE:
-      genInvoke(cUnit, bb, mir, kInterface, true /*range*/);
-      break;
-
     case Instruction::NEG_INT:
     case Instruction::NOT_INT:
       res = genArithOpInt(cUnit, mir, rlDest, rlSrc[0], rlSrc[0]);
@@ -1114,6 +1186,15 @@
      * path, it will need to be regenereated.
      */
     return false;
+  } else if (bb->blockType == kExceptionHandling) {
+    /*
+     * Because we're deferring null checking, delete the associated empty
+     * exception block.
+     * TODO: add new block type for exception blocks that we generate
+     * greenland code for.
+     */
+    llvmBB->eraseFromParent();
+    return false;
   }
 
   for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
@@ -1144,7 +1225,7 @@
     }
   }
 
-  if ((bb->taken == NULL) && (bb->fallThrough != NULL) && !bb->hasReturn) {
+  if ((bb->fallThrough != NULL) && !bb->hasReturn) {
     cUnit->irb->CreateBr(getLLVMBlock(cUnit, bb->fallThrough->id));
   }
 
@@ -1291,21 +1372,19 @@
 
   llvm::verifyFunction(*cUnit->func, llvm::PrintMessageAction);
 
-    // Write bitcode to file
-    std::string errmsg;
+  // Write bitcode to file
+  std::string errmsg;
 
-    llvm::OwningPtr<llvm::tool_output_file> out_file(
+  llvm::OwningPtr<llvm::tool_output_file> out_file(
       new llvm::tool_output_file("/tmp/foo.bc", errmsg,
                                  llvm::raw_fd_ostream::F_Binary));
 
-    if (!errmsg.empty()) {
-      LOG(ERROR) << "Failed to create bitcode output file: " << errmsg;
-    }
+  if (!errmsg.empty()) {
+    LOG(ERROR) << "Failed to create bitcode output file: " << errmsg;
+  }
 
-    llvm::WriteBitcodeToFile(cUnit->module, out_file->os());
-    out_file->keep();
-
-
+  llvm::WriteBitcodeToFile(cUnit->module, out_file->os());
+  out_file->keep();
 }
 
 RegLocation getLoc(CompilationUnit* cUnit, llvm::Value* val) {
@@ -1438,6 +1517,7 @@
   ConditionCode res = kCondAl;
   switch(llvmCond) {
     case llvm::ICmpInst::ICMP_NE: res = kCondNe; break;
+    case llvm::ICmpInst::ICMP_EQ: res = kCondEq; break;
     case llvm::ICmpInst::ICMP_SGT: res = kCondGt; break;
     default: LOG(FATAL) << "Unexpected llvm condition";
   }
@@ -1531,6 +1611,65 @@
   }
 }
 
+void cvtConstString(CompilationUnit* cUnit, llvm::CallInst* callInst)
+{
+  DCHECK(callInst->getNumArgOperands() == 1);
+  llvm::ConstantInt* stringIdxVal =
+      llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
+  uint32_t stringIdx = stringIdxVal->getZExtValue();
+  RegLocation rlDest = getLoc(cUnit, callInst);
+  genConstString(cUnit, stringIdx, rlDest);
+}
+
+void cvtInvoke(CompilationUnit* cUnit, llvm::CallInst* callInst,
+               greenland::JType jtype)
+{
+  CallInfo* info = (CallInfo*)oatNew(cUnit, sizeof(CallInfo), true,
+                                         kAllocMisc);
+  if (jtype == greenland::kVoid) {
+    info->result.location = kLocInvalid;
+  } else {
+    info->result = getLoc(cUnit, callInst);
+  }
+  llvm::ConstantInt* invokeTypeVal =
+      llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
+  llvm::ConstantInt* methodIndexVal =
+      llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(1));
+  llvm::ConstantInt* optFlagsVal =
+      llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(2));
+  info->type = static_cast<InvokeType>(invokeTypeVal->getZExtValue());
+  info->index = methodIndexVal->getZExtValue();
+  info->optFlags = optFlagsVal->getZExtValue();
+  info->offset = cUnit->currentDalvikOffset;
+
+  // FIXME - rework such that we no longer need isRange
+  info->isRange = false;
+
+  // Count the argument words, and then build argument array.
+  info->numArgWords = 0;
+  for (unsigned int i = 3; i < callInst->getNumArgOperands(); i++) {
+    RegLocation tLoc = getLoc(cUnit, callInst->getArgOperand(i));
+    info->numArgWords += tLoc.wide ? 2 : 1;
+  }
+  info->args = (info->numArgWords == 0) ? NULL : (RegLocation*)
+      oatNew(cUnit, sizeof(RegLocation) * info->numArgWords, false, kAllocMisc);
+  // Now, fill in the location records, synthesizing high loc of wide vals
+  for (int i = 3, next = 0; next < info->numArgWords;) {
+    info->args[next] = getLoc(cUnit, callInst->getArgOperand(i));
+    if (cUnit->printMe) {
+      oatDumpRegLoc(info->args[next]);
+    }
+    if (info->args[next].wide) {
+      next++;
+      // TODO: Might make sense to mark this as an invalid loc
+      info->args[next].origSReg = info->args[next-1].origSReg+1;
+      info->args[next].sRegLow = info->args[next-1].sRegLow+1;
+    }
+    next++;
+  }
+  genInvoke(cUnit, info);
+}
+
 bool methodBitcodeBlockCodeGen(CompilationUnit* cUnit, llvm::BasicBlock* bb)
 {
   bool isEntry = (bb == &cUnit->func->getEntryBlock());
@@ -1554,8 +1693,7 @@
   //TODO: restore oat incoming liveness optimization
   oatClobberAllRegs(cUnit);
 
-  //LIR* headLIR = NULL;
-
+  LIR* headLIR = NULL;
 
   if (isEntry) {
     cUnit->currentDalvikOffset = 0;
@@ -1575,6 +1713,32 @@
       cUnit->currentDalvikOffset = dexOffsetValue->getZExtValue();
     }
 
+    oatResetRegPool(cUnit);
+    if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
+      oatClobberAllRegs(cUnit);
+    }
+
+    if (cUnit->disableOpt & (1 << kSuppressLoads)) {
+      oatResetDefTracking(cUnit);
+    }
+
+#ifndef NDEBUG
+    /* Reset temp tracking sanity check */
+    cUnit->liveSReg = INVALID_SREG;
+#endif
+
+    LIR* boundaryLIR;
+    const char* instStr = "boundary";
+    boundaryLIR = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary,
+                          (intptr_t) instStr);
+    cUnit->boundaryMap.Overwrite(cUnit->currentDalvikOffset, boundaryLIR);
+
+    /* Remember the first LIR for thisl block*/
+    if (headLIR == NULL) {
+      headLIR = boundaryLIR;
+      headLIR->defMask = ENCODE_ALL;
+    }
+
     switch(opcode) {
 
       case llvm::Instruction::ICmp: {
@@ -1597,6 +1761,7 @@
           switch (id) {
             case greenland::IntrinsicHelper::AllocaShadowFrame:
             case greenland::IntrinsicHelper::SetShadowFrameEntry:
+            case greenland::IntrinsicHelper::PopShadowFrame:
               // Ignore shadow frame stuff for quick compiler
               break;
             case greenland::IntrinsicHelper::CopyInt:
@@ -1619,6 +1784,15 @@
             case greenland::IntrinsicHelper::CheckSuspend:
               genSuspendTest(cUnit, 0 /* optFlags already applied */);
               break;
+            case greenland::IntrinsicHelper::HLInvokeInt:
+              cvtInvoke(cUnit, callInst, greenland::kInt);
+              break;
+            case greenland::IntrinsicHelper::HLInvokeVoid:
+              cvtInvoke(cUnit, callInst, greenland::kVoid);
+              break;
+            case greenland::IntrinsicHelper::ConstString:
+              cvtConstString(cUnit, callInst);
+              break;
             case greenland::IntrinsicHelper::UnknownId:
               cvtCall(cUnit, callInst, callee);
               break;
@@ -1694,6 +1868,10 @@
         LOG(FATAL) << "Unknown llvm opcode: " << opcode; break;
     }
   }
+
+  if (headLIR != NULL) {
+    oatApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
+  }
   return false;
 }
 
diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index 7f98f07..aab323b 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -174,8 +174,8 @@
  * high-word loc for wide arguments.  Also pull up any following
  * MOVE_RESULT and incorporate it into the invoke.
  */
-CallInfo* newCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
-                      InvokeType type, bool isRange)
+CallInfo* oatNewCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+                         InvokeType type, bool isRange)
 {
   CallInfo* info = (CallInfo*)oatNew(cUnit, sizeof(CallInfo), true,
                                          kAllocMisc);
@@ -407,11 +407,11 @@
 
     case Instruction::CONST_STRING:
     case Instruction::CONST_STRING_JUMBO:
-      genConstString(cUnit, vB, rlDest, rlSrc[0]);
+      genConstString(cUnit, vB, rlDest);
       break;
 
     case Instruction::CONST_CLASS:
-      genConstClass(cUnit, vB, rlDest, rlSrc[0]);
+      genConstClass(cUnit, vB, rlDest);
       break;
 
     case Instruction::FILL_ARRAY_DATA:
@@ -419,12 +419,12 @@
       break;
 
     case Instruction::FILLED_NEW_ARRAY:
-      genFilledNewArray(cUnit, newCallInfo(cUnit, bb, mir, kStatic,
+      genFilledNewArray(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic,
                         false /* not range */));
       break;
 
     case Instruction::FILLED_NEW_ARRAY_RANGE:
-      genFilledNewArray(cUnit, newCallInfo(cUnit, bb, mir, kStatic,
+      genFilledNewArray(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic,
                         true /* range */));
       break;
 
@@ -622,38 +622,38 @@
       break;
 
     case Instruction::INVOKE_STATIC_RANGE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kStatic, true));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic, true));
       break;
     case Instruction::INVOKE_STATIC:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kStatic, false));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic, false));
       break;
 
     case Instruction::INVOKE_DIRECT:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kDirect, false));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kDirect, false));
       break;
     case Instruction::INVOKE_DIRECT_RANGE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kDirect, true));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kDirect, true));
       break;
 
     case Instruction::INVOKE_VIRTUAL:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kVirtual, false));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kVirtual, false));
       break;
     case Instruction::INVOKE_VIRTUAL_RANGE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kVirtual, true));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kVirtual, true));
       break;
 
     case Instruction::INVOKE_SUPER:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kSuper, false));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kSuper, false));
       break;
     case Instruction::INVOKE_SUPER_RANGE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kSuper, true));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kSuper, true));
       break;
 
     case Instruction::INVOKE_INTERFACE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kInterface, false));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kInterface, false));
       break;
     case Instruction::INVOKE_INTERFACE_RANGE:
-      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kInterface, true));
+      genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kInterface, true));
       break;
 
     case Instruction::NEG_INT:
diff --git a/src/greenland/intrinsic_func_list.def b/src/greenland/intrinsic_func_list.def
index 87ce43b..d2e0a17 100644
--- a/src/greenland/intrinsic_func_list.def
+++ b/src/greenland/intrinsic_func_list.def
@@ -449,6 +449,61 @@
                           _EXPAND_ARG3(kInt32ConstantTy, kJavaMethodTy, kJavaThreadTy))
 
 //----------------------------------------------------------------------------
+// High-level Invokes (fast-path determination not yet performed)
+//
+// NOTE: We expect these intrinsics to be temporary.  Once calling conventions are
+//       fully merged, the unified front end will lower down to the
+//       InvokeRetxxx() intrinsics in the next section and these will be
+//       removed.
+//
+// arg0: InvokeType
+// arg1: method_idx
+// arg2: optimization_flags (primary to note whether null checking is needed)
+// [arg3..argN]: actual arguments
+//----------------------------------------------------------------------------
+// INVOKE method returns void
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeVoid,
+                          dex_lang_hl_invoke.void,
+                          kAttrNone,
+                          kVoidTy,
+                          _EXPAND_ARG1(kVarArgTy))
+
+// INVOKE method returns object
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeObj,
+                          dex_lang_hl_invoke.obj,
+                          kAttrNone,
+                          kJavaObjectTy,
+                          _EXPAND_ARG1(kVarArgTy))
+
+// INVOKE method returns int
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeInt,
+                          dex_lang_hl_invoke.i32,
+                          kAttrNone,
+                          kInt32Ty,
+                          _EXPAND_ARG1(kVarArgTy))
+
+// INVOKE method returns float
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeFloat,
+                          dex_lang_hl_invoke.f32,
+                          kAttrNone,
+                          kFloatTy,
+                          _EXPAND_ARG1(kVarArgTy))
+
+// INVOKE method returns long
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeLong,
+                          dex_lang_hl_invoke.i64,
+                          kAttrNone,
+                          kInt64Ty,
+                          _EXPAND_ARG1(kVarArgTy))
+
+// INVOKE method returns double
+_EVAL_DEF_INTRINSICS_FUNC(HLInvokeDouble,
+                          dex_lang_hl_invoke.f64,
+                          kAttrNone,
+                          kDoubleTy,
+                          _EXPAND_ARG1(kVarArgTy))
+
+//----------------------------------------------------------------------------
 // Invoke
 //----------------------------------------------------------------------------
 
diff --git a/test/Fibonacci/Fibonacci.java b/test/Fibonacci/Fibonacci.java
index 9c94367..a5c4e4b 100644
--- a/test/Fibonacci/Fibonacci.java
+++ b/test/Fibonacci/Fibonacci.java
@@ -16,6 +16,8 @@
 
 class Fibonacci {
 
+/*
+    // Iterative version
     static int fibonacci(int n) {
         if (n == 0) {
             return 0;
@@ -29,12 +31,22 @@
         }
         return y;
     }
+*/
+
+   // Recursive version
+   static int fibonacci(int n) {
+        if ((n == 0) || (n == 1)) {
+            return n;
+        } else {
+            return fibonacci(n - 1) + (fibonacci(n - 2));
+        }
+    }
 
     public static void main(String[] args) {
         String arg = (args.length > 0) ? args[0] : "10";
         try {
             int x = Integer.parseInt(arg);
-            int y = fibonacci(x); /* to warm up cache */
+            int y = fibonacci(x);
             System.out.printf("fibonacci(%d)=%d\n", x, y);
             y = fibonacci(x + 1);
             System.out.printf("fibonacci(%d)=%d\n", x + 1, y);