diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 5b92af1..b1c7427 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -84,14 +84,14 @@
   ArenaBitVector* bv;
 };
 
-struct InvokeInfo {
+struct CallInfo {
   int numArgWords;      // Note: word count, not arg count
   RegLocation* args;    // One for each word of arguments
   RegLocation result;   // Eventual target of MOVE_RESULT
   int optFlags;
   InvokeType type;
   uint32_t dexIdx;
-  uint32_t methodIdx;
+  uint32_t index;       // Method idx for invokes, type idx for FilledNewArray
   uintptr_t directCode;
   uintptr_t directMethod;
   RegLocation target;    // Target of following move_result
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index 2ca9046..f114b45 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -23,7 +23,7 @@
  * be applicable to most targets.  Only mid-level support utilities
  * and "op" calls may be used here.
  */
-void genInvoke(CompilationUnit* cUnit, InvokeInfo* info);
+void genInvoke(CompilationUnit* cUnit, CallInfo* info);
 #if defined(TARGET_ARM)
 LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide);
 bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
@@ -379,9 +379,9 @@
   return branch;
 }
 
-void genCompareAndBranch(CompilationUnit* cUnit, BasicBlock* bb,
-                         Instruction::Code opcode, RegLocation rlSrc1,
-                         RegLocation rlSrc2, LIR* labelList)
+void genCompareAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
+                         RegLocation rlSrc1, RegLocation rlSrc2, LIR* taken,
+                         LIR* fallThrough)
 {
   ConditionCode cond;
   rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
@@ -410,18 +410,16 @@
       LOG(FATAL) << "Unexpected opcode " << (int)opcode;
   }
 #if defined(TARGET_MIPS)
-  opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg,
-              &labelList[bb->taken->id]);
+  opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg, taken);
 #else
   opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
-  opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
+  opCondBranch(cUnit, cond, taken);
 #endif
-  opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+  opUnconditionalBranch(cUnit, fallThrough);
 }
 
-void genCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb,
-                             Instruction::Code opcode, RegLocation rlSrc,
-                             LIR* labelList)
+void genCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
+                             RegLocation rlSrc, LIR* taken, LIR* fallThrough)
 {
   ConditionCode cond;
   rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
@@ -449,12 +447,12 @@
       LOG(FATAL) << "Unexpected opcode " << (int)opcode;
   }
 #if defined(TARGET_MIPS) || defined(TARGET_X86)
-  opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, &labelList[bb->taken->id]);
+  opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, taken);
 #else
   opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
-  opCondBranch(cUnit, cond, &labelList[bb->taken->id]);
+  opCondBranch(cUnit, cond, taken);
 #endif
-  opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+  opUnconditionalBranch(cUnit, fallThrough);
 }
 
 void genIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
@@ -522,11 +520,10 @@
  * code throws runtime exception "bad Filled array req" for 'D' and 'J'.
  * Current code also throws internal unimp if not 'L', '[' or 'I'.
  */
-void genFilledNewArray(CompilationUnit* cUnit, MIR* mir, bool isRange)
+void genFilledNewArray(CompilationUnit* cUnit, CallInfo* info)
 {
-  DecodedInstruction* dInsn = &mir->dalvikInsn;
-  int elems = dInsn->vA;
-  int typeIdx = dInsn->vB;
+  int elems = info->numArgWords;
+  int typeIdx = info->index;
   oatFlushAllRegs(cUnit);  /* Everything to home location */
   int funcOffset;
   if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
@@ -554,7 +551,7 @@
   size_t component_size = sizeof(int32_t);
 
   // Having a range of 0 is legal
-  if (isRange && (dInsn->vA > 0)) {
+  if (info->isRange && (elems > 0)) {
     /*
      * Bit of ugliness here.  We're going generate a mem copy loop
      * on the register range, but it is possible that some regs
@@ -563,8 +560,8 @@
      * of any regs in the source range that have been promoted to
      * home location.
      */
-    for (unsigned int i = 0; i < dInsn->vA; i++) {
-      RegLocation loc = oatUpdateLoc(cUnit, oatGetSrc(cUnit, mir, i));
+    for (int i = 0; i < elems; i++) {
+      RegLocation loc = oatUpdateLoc(cUnit, info->args[i]);
       if (loc.location == kLocPhysReg) {
         storeBaseDisp(cUnit, rSP, oatSRegOffset(cUnit, loc.sRegLow),
                       loc.lowReg, kWord);
@@ -587,14 +584,14 @@
     int rVal = oatAllocTemp(cUnit);
 #endif
     // Set up source pointer
-    RegLocation rlFirst = oatGetSrc(cUnit, mir, 0);
+    RegLocation rlFirst = info->args[0];
     opRegRegImm(cUnit, kOpAdd, rSrc, rSP,
                 oatSRegOffset(cUnit, rlFirst.sRegLow));
     // Set up the target pointer
     opRegRegImm(cUnit, kOpAdd, rDst, rRET0,
                 Array::DataOffset(component_size).Int32Value());
     // Set up the loop counter (known to be > 0)
-    loadConstant(cUnit, rIdx, dInsn->vA - 1);
+    loadConstant(cUnit, rIdx, elems - 1);
     // Generate the copy loop.  Going backwards for convenience
     LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
     // Copy next element
@@ -614,10 +611,10 @@
     opRegRegImm(cUnit, kOpAdd, rRET0, rDst,
                 -Array::DataOffset(component_size).Int32Value());
 #endif
-  } else if (!isRange) {
+  } else if (!info->isRange) {
     // TUNING: interleave
-    for (unsigned int i = 0; i < dInsn->vA; i++) {
-      RegLocation rlArg = loadValue(cUnit, oatGetSrc(cUnit, mir, i), kCoreReg);
+    for (int i = 0; i < elems; i++) {
+      RegLocation rlArg = loadValue(cUnit, info->args[i], kCoreReg);
       storeBaseDisp(cUnit, rRET0,
                     Array::DataOffset(component_size).Int32Value() +
                     i * 4, rlArg.lowReg, kWord);
@@ -869,7 +866,7 @@
     oatResetRegPool(cUnit);
     oatResetDefTracking(cUnit);
     LIR* lab = intrinsicLabel[i];
-    InvokeInfo* info = (InvokeInfo*)lab->operands[0];
+    CallInfo* info = (CallInfo*)lab->operands[0];
     cUnit->currentDalvikOffset = info->offset;
     oatAppendLIR(cUnit, lab);
     genInvoke(cUnit, info);
diff --git a/src/compiler/codegen/GenInvoke.cc b/src/compiler/codegen/GenInvoke.cc
index 21ccae7..bcc9067 100644
--- a/src/compiler/codegen/GenInvoke.cc
+++ b/src/compiler/codegen/GenInvoke.cc
@@ -24,7 +24,7 @@
  * and "op" calls may be used here.
  */
 
-typedef int (*NextCallInsn)(CompilationUnit*, InvokeInfo*, int, uint32_t dexIdx,
+typedef int (*NextCallInsn)(CompilationUnit*, CallInfo*, int, uint32_t dexIdx,
                             uint32_t methodIdx, uintptr_t directCode,
                             uintptr_t directMethod, InvokeType type);
 LIR* opCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target);
@@ -133,7 +133,7 @@
  * Bit of a hack here - in the absence of a real scheduling pass,
  * emit the next instruction in static & direct invoke sequences.
  */
-int nextSDCallInsn(CompilationUnit* cUnit, InvokeInfo* info,
+int nextSDCallInsn(CompilationUnit* cUnit, CallInfo* info,
                    int state, uint32_t dexIdx, uint32_t unused,
                    uintptr_t directCode, uintptr_t directMethod,
                    InvokeType type)
@@ -241,7 +241,7 @@
  * Note also that we'll load the first argument ("this") into
  * rARG1 here rather than the standard loadArgRegs.
  */
-int nextVCallInsn(CompilationUnit* cUnit, InvokeInfo* info,
+int nextVCallInsn(CompilationUnit* cUnit, CallInfo* info,
                   int state, uint32_t dexIdx, uint32_t methodIdx,
                   uintptr_t unused, uintptr_t unused2, InvokeType unused3)
 {
@@ -281,7 +281,7 @@
   return state + 1;
 }
 
-int nextInvokeInsnSP(CompilationUnit* cUnit, InvokeInfo* info, int trampoline,
+int nextInvokeInsnSP(CompilationUnit* cUnit, CallInfo* info, int trampoline,
                      int state, uint32_t dexIdx, uint32_t methodIdx)
 {
   /*
@@ -300,7 +300,7 @@
   return -1;
 }
 
-int nextStaticCallInsnSP(CompilationUnit* cUnit, InvokeInfo* info,
+int nextStaticCallInsnSP(CompilationUnit* cUnit, CallInfo* info,
                          int state, uint32_t dexIdx, uint32_t methodIdx,
                          uintptr_t unused, uintptr_t unused2,
                          InvokeType unused3)
@@ -309,7 +309,7 @@
   return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
 }
 
-int nextDirectCallInsnSP(CompilationUnit* cUnit, InvokeInfo* info, int state,
+int nextDirectCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
                          uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
                          uintptr_t unused2, InvokeType unused3)
 {
@@ -317,7 +317,7 @@
   return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
 }
 
-int nextSuperCallInsnSP(CompilationUnit* cUnit, InvokeInfo* info, int state,
+int nextSuperCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
                         uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
                         uintptr_t unused2, InvokeType unused3)
 {
@@ -325,7 +325,7 @@
   return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
 }
 
-int nextVCallInsnSP(CompilationUnit* cUnit, InvokeInfo* info, int state,
+int nextVCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
                     uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
                     uintptr_t unused2, InvokeType unused3)
 {
@@ -337,7 +337,7 @@
  * All invoke-interface calls bounce off of art_invoke_interface_trampoline,
  * which will locate the target and continue on via a tail call.
  */
-int nextInterfaceCallInsn(CompilationUnit* cUnit, InvokeInfo* info, int state,
+int nextInterfaceCallInsn(CompilationUnit* cUnit, CallInfo* info, int state,
                           uint32_t dexIdx, uint32_t unused, uintptr_t unused2,
                           uintptr_t unused3, InvokeType unused4)
 {
@@ -346,7 +346,7 @@
 }
 
 int nextInterfaceCallInsnWithAccessCheck(CompilationUnit* cUnit,
-                                         InvokeInfo* info, int state,
+                                         CallInfo* info, int state,
                                          uint32_t dexIdx, uint32_t unused,
                                          uintptr_t unused2, uintptr_t unused3,
                                          InvokeType unused4)
@@ -355,7 +355,7 @@
   return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
 }
 
-int loadArgRegs(CompilationUnit* cUnit, InvokeInfo* info, int callState,
+int loadArgRegs(CompilationUnit* cUnit, CallInfo* info, int callState,
                 NextCallInsn nextCallInsn, uint32_t dexIdx,
                 uint32_t methodIdx, uintptr_t directCode,
                 uintptr_t directMethod, InvokeType type, bool skipThis)
@@ -391,7 +391,7 @@
  * the target method pointer.  Note, this may also be called
  * for "range" variants if the number of arguments is 5 or fewer.
  */
-int genDalvikArgsNoRange(CompilationUnit* cUnit, InvokeInfo* info,
+int genDalvikArgsNoRange(CompilationUnit* cUnit, CallInfo* info,
                          int callState,
                          LIR** pcrLabel, NextCallInsn nextCallInsn,
                          uint32_t dexIdx, uint32_t methodIdx,
@@ -493,7 +493,7 @@
  *       Pass arg0, arg1 & arg2 in rARG1-rARG3
  *
  */
-int genDalvikArgsRange(CompilationUnit* cUnit, InvokeInfo* info, int callState,
+int genDalvikArgsRange(CompilationUnit* cUnit, CallInfo* info, int callState,
                        LIR** pcrLabel, NextCallInsn nextCallInsn,
                        uint32_t dexIdx, uint32_t methodIdx,
                        uintptr_t directCode, uintptr_t directMethod,
@@ -583,7 +583,7 @@
   return callState;
 }
 
-RegLocation inlineTarget(CompilationUnit* cUnit, InvokeInfo* info)
+RegLocation inlineTarget(CompilationUnit* cUnit, CallInfo* info)
 {
   RegLocation res;
   if (info->result.location == kLocInvalid) {
@@ -594,7 +594,7 @@
   return res;
 }
 
-RegLocation inlineTargetWide(CompilationUnit* cUnit, InvokeInfo* info)
+RegLocation inlineTargetWide(CompilationUnit* cUnit, CallInfo* info)
 {
   RegLocation res;
   if (info->result.location == kLocInvalid) {
@@ -605,7 +605,7 @@
   return res;
 }
 
-bool genInlinedCharAt(CompilationUnit* cUnit, InvokeInfo* info)
+bool genInlinedCharAt(CompilationUnit* cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   // Location of reference to data array
@@ -661,7 +661,7 @@
 #endif
 }
 
-bool genInlinedMinMaxInt(CompilationUnit *cUnit, InvokeInfo* info, bool isMin)
+bool genInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
 {
 #if defined(TARGET_ARM)
   RegLocation rlSrc1 = info->args[0];
@@ -683,7 +683,7 @@
 }
 
 // Generates an inlined String.isEmpty or String.length.
-bool genInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, InvokeInfo* info,
+bool genInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, CallInfo* info,
                                      bool isEmpty)
 {
 #if defined(TARGET_ARM)
@@ -708,7 +708,7 @@
 #endif
 }
 
-bool genInlinedAbsInt(CompilationUnit *cUnit, InvokeInfo* info)
+bool genInlinedAbsInt(CompilationUnit *cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   RegLocation rlSrc = info->args[0];
@@ -727,7 +727,7 @@
 #endif
 }
 
-bool genInlinedAbsLong(CompilationUnit *cUnit, InvokeInfo* info)
+bool genInlinedAbsLong(CompilationUnit *cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   RegLocation rlSrc = info->args[0];
@@ -748,7 +748,7 @@
 #endif
 }
 
-bool genInlinedFloatCvt(CompilationUnit *cUnit, InvokeInfo* info)
+bool genInlinedFloatCvt(CompilationUnit *cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   RegLocation rlSrc = info->args[0];
@@ -760,7 +760,7 @@
 #endif
 }
 
-bool genInlinedDoubleCvt(CompilationUnit *cUnit, InvokeInfo* info)
+bool genInlinedDoubleCvt(CompilationUnit *cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   RegLocation rlSrc = info->args[0];
@@ -776,7 +776,7 @@
  * Fast string.indexOf(I) & (II).  Tests for simple case of char <= 0xffff,
  * otherwise bails to standard library code.
  */
-bool genInlinedIndexOf(CompilationUnit* cUnit, InvokeInfo* info,
+bool genInlinedIndexOf(CompilationUnit* cUnit, CallInfo* info,
                        bool zeroBased)
 {
 #if defined(TARGET_ARM)
@@ -818,7 +818,7 @@
 }
 
 /* Fast string.compareTo(Ljava/lang/string;)I. */
-bool genInlinedStringCompareTo(CompilationUnit* cUnit, InvokeInfo* info)
+bool genInlinedStringCompareTo(CompilationUnit* cUnit, CallInfo* info)
 {
 #if defined(TARGET_ARM)
   oatClobberCalleeSave(cUnit);
@@ -850,7 +850,7 @@
 #endif
 }
 
-bool genIntrinsic(CompilationUnit* cUnit, InvokeInfo* info)
+bool genIntrinsic(CompilationUnit* cUnit, CallInfo* info)
 {
   if ((info->optFlags & MIR_INLINED) || info->isRange ||
       (info->result.location == kLocInvalid))  {
@@ -866,7 +866,7 @@
    * method.  By doing this during basic block construction, we can also
    * take advantage of/generate new useful dataflow info.
    */
-  std::string tgtMethod(PrettyMethod(info->methodIdx, *cUnit->dex_file));
+  std::string tgtMethod(PrettyMethod(info->index, *cUnit->dex_file));
   if (tgtMethod.compare("char java.lang.String.charAt(int)") == 0) {
     return genInlinedCharAt(cUnit, info);
   }
diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index 1707a89..e06cf3f 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -53,7 +53,7 @@
   return res;
 }
 
-void genInvoke(CompilationUnit* cUnit, InvokeInfo* info)
+void genInvoke(CompilationUnit* cUnit, CallInfo* info)
 {
   if (genIntrinsic(cUnit, info)) {
     return;
@@ -72,7 +72,7 @@
                            cUnit->code_item, cUnit->method_idx,
                            cUnit->access_flags);
 
-  uint32_t dexMethodIdx = info->methodIdx;
+  uint32_t dexMethodIdx = info->index;
   int vtableIdx;
   uintptr_t directCode;
   uintptr_t directMethod;
@@ -174,10 +174,10 @@
  * high-word loc for wide arguments.  Also pull up any following
  * MOVE_RESULT and incorporate it into the invoke.
  */
-InvokeInfo* newInvokeInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
-                          InvokeType type, bool isRange)
+CallInfo* newCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+                      InvokeType type, bool isRange)
 {
-  InvokeInfo* info = (InvokeInfo*)oatNew(cUnit, sizeof(InvokeInfo), true,
+  CallInfo* info = (CallInfo*)oatNew(cUnit, sizeof(CallInfo), true,
                                          kAllocMisc);
   MIR* moveResultMIR = oatFindMoveResult(cUnit, bb, mir);
   if (moveResultMIR == NULL) {
@@ -195,7 +195,7 @@
   info->optFlags = mir->optimizationFlags;
   info->type = type;
   info->isRange = isRange;
-  info->methodIdx = mir->dalvikInsn.vB;
+  info->index = mir->dalvikInsn.vB;
   info->offset = mir->offset;
   return info;
 }
@@ -414,11 +414,13 @@
       break;
 
     case Instruction::FILLED_NEW_ARRAY:
-      genFilledNewArray(cUnit, mir, false /* not range */);
+      genFilledNewArray(cUnit, newCallInfo(cUnit, bb, mir, kStatic,
+                        false /* not range */));
       break;
 
     case Instruction::FILLED_NEW_ARRAY_RANGE:
-      genFilledNewArray(cUnit, mir, true /* range */);
+      genFilledNewArray(cUnit, newCallInfo(cUnit, bb, mir, kStatic,
+                        true /* range */));
       break;
 
     case Instruction::NEW_ARRAY:
@@ -460,12 +462,15 @@
     case Instruction::IF_GE:
     case Instruction::IF_GT:
     case Instruction::IF_LE: {
+      LIR* taken = &labelList[bb->taken->id];
+      LIR* fallThrough = &labelList[bb->fallThrough->id];
       bool backwardBranch;
       backwardBranch = (bb->taken->startOffset <= mir->offset);
       if (backwardBranch) {
         genSuspendTest(cUnit, optFlags);
       }
-      genCompareAndBranch(cUnit, bb, opcode, rlSrc[0], rlSrc[1], labelList);
+      genCompareAndBranch(cUnit, opcode, rlSrc[0], rlSrc[1], taken,
+                          fallThrough);
       break;
       }
 
@@ -475,12 +480,14 @@
     case Instruction::IF_GEZ:
     case Instruction::IF_GTZ:
     case Instruction::IF_LEZ: {
+      LIR* taken = &labelList[bb->taken->id];
+      LIR* fallThrough = &labelList[bb->fallThrough->id];
       bool backwardBranch;
       backwardBranch = (bb->taken->startOffset <= mir->offset);
       if (backwardBranch) {
         genSuspendTest(cUnit, optFlags);
       }
-      genCompareZeroAndBranch(cUnit, bb, opcode, rlSrc[0], labelList);
+      genCompareZeroAndBranch(cUnit, opcode, rlSrc[0], taken, fallThrough);
       break;
       }
 
@@ -610,38 +617,38 @@
       break;
 
     case Instruction::INVOKE_STATIC_RANGE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kStatic, true));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kStatic, true));
       break;
     case Instruction::INVOKE_STATIC:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kStatic, false));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kStatic, false));
       break;
 
     case Instruction::INVOKE_DIRECT:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kDirect, false));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kDirect, false));
       break;
     case Instruction::INVOKE_DIRECT_RANGE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kDirect, true));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kDirect, true));
       break;
 
     case Instruction::INVOKE_VIRTUAL:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kVirtual, false));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kVirtual, false));
       break;
     case Instruction::INVOKE_VIRTUAL_RANGE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kVirtual, true));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kVirtual, true));
       break;
 
     case Instruction::INVOKE_SUPER:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kSuper, false));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kSuper, false));
       break;
     case Instruction::INVOKE_SUPER_RANGE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kSuper, true));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kSuper, true));
       break;
 
     case Instruction::INVOKE_INTERFACE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kInterface, false));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kInterface, false));
       break;
     case Instruction::INVOKE_INTERFACE_RANGE:
-      genInvoke(cUnit, newInvokeInfo(cUnit, bb, mir, kInterface, true));
+      genInvoke(cUnit, newCallInfo(cUnit, bb, mir, kInterface, true));
       break;
 
     case Instruction::NEG_INT: