if (tuple.typeCode == OSR_Constants.LongTypeCode) {
if (VM.BuildFor32Addr && (tuple.typeCode == OSR_Constants.LongTypeCode)) {
    public void perform(OPT_IR ir)      throws OPT_OptimizingCompilerException {      this.ir = ir;      // list of OsrVariableMapElement      LinkedList mapList = ir.MIRInfo.osrVarMap.list;      // for each osr instruction      for (int numOsrs=0, m=mapList.size(); numOsrs<m; numOsrs++) {        OSR_VariableMapElement elm =           (OSR_VariableMapElement)mapList.get(numOsrs);        // for each inlined method        LinkedList mvarsList = elm.mvars;        for (int numMvars=0, n=mvarsList.size(); numMvars<n; numMvars++) {          OSR_MethodVariables mvar =            (OSR_MethodVariables)mvarsList.get(numMvars);          // for each tuple          LinkedList tupleList = mvar.tupleList;          for (int numTuple=0, k=tupleList.size(); numTuple<k; numTuple++) {            OSR_LocalRegPair tuple =               (OSR_LocalRegPair) tupleList.get(numTuple);            OPT_Operand op = tuple.operand;            if (op.isRegister()) {              OPT_Register sym_reg = ((OPT_RegisterOperand)op).register;              setRealPosition(tuple, sym_reg);              // get another half part of long register              if (tuple.typeCode == OSR_Constants.LongTypeCode) {                OSR_LocalRegPair other = tuple._otherHalf;                OPT_Operand other_op = other.operand;                if (VM.VerifyAssertions) VM._assert(other_op.isRegister());                OPT_Register other_reg = ((OPT_RegisterOperand)other_op).register;                setRealPosition(other, other_reg);              }      /* According to OPT_ConvertToLowLevelIR, StringConstant, LongConstant,       * NullConstant, FloatConstant, and DoubleConstant are all materialized       * The only thing left is the integer constant.       * POTENTIAL DRAWBACKS: since any long, float, and double are moved       * to register and treated as use, it may consume more registers and       * add unnecessary MOVEs.       *       * Perhaps, OPT_ConvertToLowLevelIR can skip OsrPoint instruction.       */            } else if (op.isIntConstant()) {              setTupleValue(tuple,                            OSR_Constants.ICONST,                            ((OPT_IntConstantOperand)op).value                            );              if (tuple.typeCode == OSR_Constants.LongTypeCode) {                OSR_LocalRegPair other = tuple._otherHalf;                OPT_Operand other_op = other.operand;                if (VM.VerifyAssertions) VM._assert(other_op.isIntConstant());                setTupleValue(other,                              OSR_Constants.ICONST,                              ((OPT_IntConstantOperand)other_op).value                              );                                            }             } else if (op.isAddressConstant()) {              setTupleValue(tuple,                            OSR_Constants.ICONST,                            ((OPT_AddressConstantOperand)op).value.toInt()                            );              //KV:TODO:              if (VM.BuildFor64Addr)               throw new OPT_OptimizingCompilerException("OPT_LinearScan",                        "Unexpected operand type at ", op.toString());              //KV:end TODO            } else {              throw new OPT_OptimizingCompilerException("OPT_LinearScan",                        "Unexpected operand type at ", op.toString());            } // for the op type          } // for each tuple        } // for each inlined method      } // for each osr instruction      this.ir = null;    } // end of method