if (VM.VerifyAssertions) VM._assert(VM.BuildFor32Addr);
if (VM.BuildForPowerPC && VM.BuildFor64Addr) break;
    public final void perform (OPT_IR ir) {      for (OPT_Instruction s = ir.firstInstructionInCodeOrder(); s !=              null; s = s.nextInstructionInCodeOrder()) {        switch (s.getOpcode()) {        case ARRAYLENGTH_opcode:          {            // array_ref[VM_ObjectModel.getArrayLengthOffset()] contains the length            Load.mutate(s, INT_LOAD, GuardedUnary.getClearResult(s),                         GuardedUnary.getClearVal(s),                        OPT_IRTools.AC(VM_ObjectModel.getArrayLengthOffset()),                         new OPT_LocationOperand(),                         GuardedUnary.getClearGuard(s));          }          break;        case GET_OBJ_TIB_opcode:          {            VM_ObjectModel.lowerGET_OBJ_TIB(s, ir);          }          break;        case GET_CLASS_TIB_opcode:          {            VM_Type type = ((OPT_TypeOperand)Unary.getVal(s)).getVMType();            Offset offset = type.getTibOffset();            Load.mutate(s, REF_LOAD, Unary.getClearResult(s),                         ir.regpool.makeJTOCOp(ir,s),                         OPT_IRTools.AC(offset), new OPT_LocationOperand(offset));          }          break;        case GET_TYPE_FROM_TIB_opcode:          {            // TODO: Valid location operand?            Load.mutate(s, REF_LOAD, Unary.getClearResult(s),                         Unary.getClearVal(s),                         OPT_IRTools.AC(Offset.fromIntZeroExtend(TIB_TYPE_INDEX << LOG_BYTES_IN_ADDRESS)), null);          }          break;        case GET_SUPERCLASS_IDS_FROM_TIB_opcode:          {            // TODO: Valid location operand?            Load.mutate(s, REF_LOAD, Unary.getClearResult(s),                         Unary.getClearVal(s),                         OPT_IRTools.AC(Offset.fromIntZeroExtend(TIB_SUPERCLASS_IDS_INDEX << LOG_BYTES_IN_ADDRESS)), null);          }          break;        case GET_DOES_IMPLEMENT_FROM_TIB_opcode:          {            // TODO: Valid location operand?            Load.mutate(s, REF_LOAD, Unary.getClearResult(s),                         Unary.getClearVal(s),                         OPT_IRTools.AC(Offset.fromIntZeroExtend(TIB_DOES_IMPLEMENT_INDEX << LOG_BYTES_IN_ADDRESS)), null);          }          break;        case GET_ARRAY_ELEMENT_TIB_FROM_TIB_opcode:          {            // TODO: Valid location operand?            Load.mutate(s, REF_LOAD, Unary.getClearResult(s),                         Unary.getClearVal(s),                         OPT_IRTools.AC(Offset.fromIntZeroExtend(TIB_ARRAY_ELEMENT_TIB_INDEX << LOG_BYTES_IN_ADDRESS)), null);          }          break;        case LONG_DIV_opcode:          {            if (VM.VerifyAssertions) VM._assert(VM.BuildFor32Addr);            OPT_Operand val1 = GuardedBinary.getClearVal1(s);            OPT_Operand val2 = GuardedBinary.getClearVal2(s);             if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              val1 = ensureRegister(val1, s, ir);              val2 = ensureRegister(val2, s, ir);            }            Call.mutate2(s, SYSCALL,                          GuardedBinary.getClearResult(s), null,                          OPT_MethodOperand.STATIC(VM_Entrypoints.sysLongDivideIPField),                          val1, val2);            OPT_CallingConvention.expandSysCall(s, ir);          }          break;        case LONG_REM_opcode:          {            if (VM.VerifyAssertions) VM._assert(VM.BuildFor32Addr);            OPT_Operand val1 = GuardedBinary.getClearVal1(s);            OPT_Operand val2 = GuardedBinary.getClearVal2(s);             if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              val1 = ensureRegister(val1, s, ir);              val2 = ensureRegister(val2, s, ir);            }            Call.mutate2(s, SYSCALL,                          GuardedBinary.getClearResult(s), null,                          OPT_MethodOperand.STATIC(VM_Entrypoints.sysLongRemainderIPField),                          val1, val2);            OPT_CallingConvention.expandSysCall(s, ir);          }          break;          //-#if RVM_FOR_POWERPC        case FLOAT_REM_opcode: case DOUBLE_REM_opcode:          {            // NOTE: must move constants out of sysCall before we expand it.            //       otherwise we'll have the wrong value in the JTOC register when            //       we try to load the constant from the JTOC!            OPT_Operand val1 = ensureRegister(Binary.getClearVal1(s), s, ir);            OPT_Operand val2 = ensureRegister(Binary.getClearVal2(s), s, ir);            Call.mutate2(s, SYSCALL,                          Binary.getClearResult(s), null,                          OPT_MethodOperand.STATIC(VM_Entrypoints.sysDoubleRemainderIPField),                          val1, val2);            OPT_CallingConvention.expandSysCall(s, ir);          }          break;          //-#endif        case LONG_2FLOAT_opcode:          {             if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              OPT_Operand val = ensureRegister(Unary.getClearVal(s), s, ir);              Call.mutate1(s, SYSCALL,                           Unary.getClearResult(s), null,                           OPT_MethodOperand.STATIC(VM_Entrypoints.sysLongToFloatIPField),                           val);              OPT_CallingConvention.expandSysCall(s, ir);            }          }          break;                  case LONG_2DOUBLE_opcode:          {             if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              OPT_Operand val = ensureRegister(Unary.getClearVal(s), s, ir);              Call.mutate1(s, SYSCALL,                           Unary.getClearResult(s),                           null,                           OPT_MethodOperand.STATIC(VM_Entrypoints.sysLongToDoubleIPField),                           val);              OPT_CallingConvention.expandSysCall(s, ir);            }          }          break;                  case FLOAT_2LONG_opcode:          {             if (VM.BuildForPowerPC && VM.BuildFor64Addr) break; // don't reduce operator -- leave for BURS            OPT_Operand val = Unary.getClearVal(s);            if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              val = ensureRegister(val, s, ir);            }            Call.mutate1(s, SYSCALL,                         Unary.getClearResult(s),                         null,                         OPT_MethodOperand.STATIC(VM_Entrypoints.sysFloatToLongIPField),                         val);            OPT_CallingConvention.expandSysCall(s, ir);          }          break;                  case DOUBLE_2LONG_opcode:          {             if (VM.BuildForPowerPC && VM.BuildFor64Addr) break; // don't reduce operator -- leave for BURS            OPT_Operand val = Unary.getClearVal(s);            if (VM.BuildForPowerPC) {              // NOTE: must move constants out of sysCall before we expand it.              //       otherwise we'll have the wrong value in the JTOC register when              //       we try to load the constant from the JTOC!              val = ensureRegister(val, s, ir);            }            Call.mutate1(s, SYSCALL,                         Unary.getClearResult(s),                         null,                         OPT_MethodOperand.STATIC(VM_Entrypoints.sysDoubleToLongIPField),                         val);            OPT_CallingConvention.expandSysCall(s, ir);          }          break;        }      }    }