iTable.copyD2U(), itableIndex<<LOG_BYTES_IN_ADDRESS);
iTable.copyD2U(), Offset.fromIntZeroExtend(itableIndex<<LOG_BYTES_IN_ADDRESS));
  static OPT_Instruction callHelper(OPT_Instruction v, OPT_IR ir) {    if (!Call.hasMethod(v)) {      if (VM.VerifyAssertions) VM._assert(Call.getAddress(v) instanceof OPT_RegisterOperand);      return v; // nothing to do....very low level call to address already in the register.    }    OPT_MethodOperand methOp = Call.getMethod(v);    // Handle recursive invocations.    if (methOp.hasPreciseTarget() && methOp.getTarget() == ir.method) {      Call.setAddress(v, new OPT_BranchOperand(ir.firstInstructionInCodeOrder()));      return v;    }          /* RRB 100500 */    // generate direct call to specialized method if the method operand    // has been marked as a specialized call.    if (VM.runningVM) {      OPT_SpecializedMethod spMethod = methOp.spMethod;      if (spMethod != null) {        int smid = spMethod.getSpecializedMethodIndex();        Call.setAddress(v, getSpecialMethod(v, ir, smid));        return v;      }    }    //-#if RVM_WITH_OSR    if (methOp.hasDesignatedTarget()) {      Call.setAddress(v, InsertLoadOffsetJTOC(v, ir, REF_LOAD,                                              VM_TypeReference.CodeArray,                                              methOp.jtocOffset));      return v;    }    //-#endif        if (methOp.isStatic()) {      if (VM.VerifyAssertions) VM._assert(Call.hasAddress(v));      Call.setAddress(v,                       InsertLoadOffsetJTOC(v, ir, REF_LOAD,                                            VM_TypeReference.CodeArray,                                            Call.getClearAddress(v)));    } else if (methOp.isVirtual()) {      if (VM.VerifyAssertions) VM._assert(Call.hasAddress(v));      OPT_RegisterOperand tib = getTIB(v, ir, Call.getParam(v, 0).copy(), Call.getGuard(v).copy());      Call.setAddress(v, InsertLoadOffset(v, ir, REF_LOAD,                                           VM_TypeReference.CodeArray,                                           tib, Call.getClearAddress(v), null, TG()));    } else if (methOp.isSpecial()) {      VM_Method target = methOp.getTarget();      if (target == null || target.isObjectInitializer() || target.isStatic()) {        // target == null => we are calling an unresolved <init> method.        Call.setAddress(v, InsertLoadOffsetJTOC(v, ir, REF_LOAD,                                                 VM_TypeReference.CodeArray,                                                 Call.getClearAddress(v)));      } else {        // invoking a virtual method; do it via TIB of target's declaring class.        OPT_Operand tib = getTIB(v, ir, target.getDeclaringClass());        Call.setAddress(v, InsertLoadOffset(v, ir, REF_LOAD,                                             VM_TypeReference.CodeArray,                                             tib, Call.getClearAddress(v), null, TG()));      }    } else {      if (VM.VerifyAssertions) VM._assert(methOp.isInterface());      if (VM.VerifyAssertions) VM._assert(!Call.hasAddress(v));      if (VM.BuildForIMTInterfaceInvocation) {        // SEE ALSO: OPT_FinalMIRExpansion (for hidden parameter)        OPT_RegisterOperand RHStib =           getTIB(v, ir, Call.getParam(v, 0).copy(), Call.getGuard(v).copy());        VM_InterfaceMethodSignature sig = VM_InterfaceMethodSignature.findOrCreate(methOp.getMemberRef());        int offset = sig.getIMTOffset();        OPT_RegisterOperand address = null;        if (VM.BuildForEmbeddedIMT) {          address = InsertLoadOffset(v, ir, REF_LOAD,                                      VM_TypeReference.CodeArray,                                      RHStib.copyD2U(),                                      offset);        } else {          OPT_RegisterOperand IMT = InsertLoadOffset(v, ir, REF_LOAD,                                                     VM_TypeReference.JavaLangObjectArray,                                                     RHStib.copyD2U(),                                                     TIB_IMT_TIB_INDEX << LOG_BYTES_IN_ADDRESS);          address = InsertLoadOffset(v, ir, REF_LOAD,                                     VM_TypeReference.CodeArray,                                     IMT.copyD2U(),                                     offset);        }        Call.setAddress(v, address);      } else if (VM.BuildForITableInterfaceInvocation &&                  VM.DirectlyIndexedITables &&                  methOp.hasTarget() &&                 methOp.getTarget().getDeclaringClass().isResolved()) {        VM_Class I = methOp.getTarget().getDeclaringClass();        OPT_RegisterOperand RHStib =           getTIB(v, ir, Call.getParam(v, 0).copy(), Call.getGuard(v).copy());        OPT_RegisterOperand iTables =           InsertLoadOffset(v, ir, REF_LOAD,                           VM_TypeReference.JavaLangObjectArray,                           RHStib.copyD2U(),                           TIB_ITABLES_TIB_INDEX << LOG_BYTES_IN_ADDRESS);        OPT_RegisterOperand iTable =           InsertLoadOffset(v, ir, REF_LOAD,                           VM_TypeReference.JavaLangObjectArray,                           iTables.copyD2U(),                           I.getInterfaceId()<<LOG_BYTES_IN_ADDRESS);        OPT_RegisterOperand address =           InsertLoadOffset(v, ir, REF_LOAD,                           VM_TypeReference.CodeArray,                           iTable.copyD2U(),                           VM_InterfaceInvocation.getITableIndex(I,                                                                  methOp.getMemberRef().getName(),                                                                 methOp.getMemberRef().getDescriptor())<<LOG_BYTES_IN_ADDRESS);        Call.setAddress(v, address);      } else {        int itableIndex = -1;         if (VM.BuildForITableInterfaceInvocation && methOp.hasTarget()) {          VM_Class I = methOp.getTarget().getDeclaringClass();          // search ITable variant          itableIndex = VM_InterfaceInvocation.getITableIndex(I,                                                               methOp.getMemberRef().getName(),                                                              methOp.getMemberRef().getDescriptor());        }        if (itableIndex == -1) {          // itable index is not known at compile-time.          // call "invokeinterface" to resolve the object and method id          // into a method address          OPT_RegisterOperand realAddrReg =             ir.regpool.makeTemp(VM_TypeReference.CodeArray);          VM_Method target = VM_Entrypoints.invokeInterfaceMethod;          OPT_Instruction vp =             Call.create2(CALL, realAddrReg, IC(target.getOffset()),                          OPT_MethodOperand.STATIC(target),                         Call.getParam(v, 0).asRegister().copyU2U(),                          IC(methOp.getMemberRef().getId()));          vp.position = v.position;          vp.bcIndex = RUNTIME_SERVICES_BCI;          v.insertBack(vp);          callHelper(vp, ir);          Call.setAddress(v, realAddrReg.copyD2U());          return v;        } else {          // itable index is known at compile-time.          // call "findITable" to resolve object + interface id into          // itable address          OPT_RegisterOperand iTable =             ir.regpool.makeTemp(VM_TypeReference.JavaLangObjectArray);          OPT_RegisterOperand RHStib =             getTIB(v, ir, Call.getParam(v, 0).copy(), Call.getGuard(v).copy());          VM_Method target = VM_Entrypoints.findItableMethod;          OPT_Instruction fi =             Call.create2(CALL, iTable, IC(target.getOffset()),                          OPT_MethodOperand.STATIC(target),                         RHStib, IC(methOp.getTarget().getDeclaringClass().getInterfaceId()));          fi.position = v.position;          fi.bcIndex = RUNTIME_SERVICES_BCI;          v.insertBack(fi);          callHelper(fi, ir);          OPT_RegisterOperand address =             InsertLoadOffset(v, ir, REF_LOAD,                             VM_TypeReference.CodeArray,                             iTable.copyD2U(), itableIndex<<LOG_BYTES_IN_ADDRESS);          Call.setAddress(v, address);          return v;        }      }    }    return v;  }