OPT_RegisterOperand rOp = LowTableSwitch.getIndex(s);
OPT_RegisterOperand rOp = MIR_LowTableSwitch.getIndex(s);
  final public void perform (OPT_IR ir) {    java.util.HashMap newMap = new java.util.HashMap(5);    for (Enumeration be = ir.getBasicBlocks(); be.hasMoreElements(); ) {      OPT_BasicBlock bb = (OPT_BasicBlock)be.nextElement();      for (OPT_InstructionEnumeration ie  = bb.forwardInstrEnumerator();            ie.hasMoreElements(); ) {        OPT_Instruction s = ie.next();        // clear the cache of register assignments        newMap.clear();        // Split live ranges at PEIs and a few special cases to         // make sure we can pin values that must be in registers.        // NOTE: Any operator that is an IA32 special case that must have        //       a particular operand in a register must be mentioned both        //       here and in OPT_RegisterRestrictions!        if (s.isPEI() && s.operator != IR_PROLOGUE) {          if (bb.hasApplicableExceptionalOut(s) ||              !OPT_RegisterRestrictions.SCRATCH_IN_PEI) {            splitAllLiveRanges(s, newMap, ir, false);          }        }        // handle special cases for IA32        // These fall into two classes:        //  (1) Some operands must be in registers        //  (2) Some register operands must be in eax,ebx,ecx,or edx        //      because they are really 8 bit registers (al,bl,cl,dl).        //      This happens in a few special cases (MOVZX/MOZSX/SET)        //      and in any other operator that has an 8 bit memory operand.        switch (s.getOpcode()) {          case IA32_SHRD_opcode: case IA32_SHLD_opcode:            {              OPT_RegisterOperand rOp = MIR_DoubleShift.getSource(s);              OPT_RegisterOperand temp = findOrCreateTemp(rOp, newMap, ir);              // move r into 'temp' before s              insertMoveBefore(temp, rOp.copyRO(), s);              rOp.register = temp.register;            }            break;          case IA32_FCOMI_opcode: case IA32_FCOMIP_opcode:            {	      OPT_Operand op = MIR_Compare.getVal2(s);	      if (!(op instanceof OPT_BURSManagedFPROperand)) {		OPT_RegisterOperand rOp = op.asRegister();		OPT_RegisterOperand temp = findOrCreateTemp(rOp, newMap, ir);		// move r into 'temp' before s		insertMoveBefore(temp, rOp.copyRO(), s);		rOp.register = temp.register;	      }            }            break;          case IA32_IMUL2_opcode:            {              OPT_RegisterOperand rOp = MIR_BinaryAcc.getResult(s).asRegister();              OPT_RegisterOperand temp = findOrCreateTemp(rOp, newMap, ir);              // move r into 'temp' before s              insertMoveBefore(temp, rOp.copyRO(), s);              // move 'temp' into r after s              insertMoveAfter(rOp.copyRO(), temp.copyRO(), s);              rOp.register = temp.register;            }            break;          case IA32_LOWTABLESWITCH_opcode:            {              OPT_RegisterOperand rOp = LowTableSwitch.getIndex(s);              OPT_RegisterOperand temp = findOrCreateTemp(rOp, newMap, ir);              // NOTE: Index as marked as a DU because LowTableSwitch is               //       going to destroy the value in the register.              //       By construction (see ConvertToLowLevelIR), no one will              //       every read the value computed by a LowTableSwitch.              //       Therefore, don't insert a move instruction after the              //       LowTableSwitch (which would cause IR verification               //       problems anyways, since LowTableSwitch is a branch).              insertMoveBefore(temp, rOp.copyRO(), s); // move r into 'temp' before s              rOp.register = temp.register;            }            break;          case IA32_MOVZX$B_opcode: case IA32_MOVSX$B_opcode:            {              OPT_RegisterOperand op = (OPT_RegisterOperand)MIR_Unary.getResult(s);              OPT_RegisterOperand temp = findOrCreateTemp(op, newMap, ir);              // move 'temp' into r after s              insertMoveAfter(op.copyRO(), temp.copyRO(), s);              op.register = temp.register;              // also add restrictions on the rhs (val), if it is a register.              OPT_Operand val = MIR_Unary.getVal(s);              if (val.isRegister()) {                OPT_RegisterOperand rval = (OPT_RegisterOperand)val;                OPT_RegisterOperand tempval = findOrCreateTemp(rval, newMap, ir);                // move 'temp' into rval before s                insertMoveBefore(tempval, rval.copyRO(), s);                rval.register = tempval.register;              }            }            break;          case IA32_CMOV_opcode: case IA32_FCMOV_opcode:            {              OPT_RegisterOperand op = (OPT_RegisterOperand)MIR_CondMove.                                       getResult(s);              OPT_RegisterOperand temp = findOrCreateTemp(op, newMap, ir);              // move r into 'temp' before s              insertMoveBefore(temp.copyRO(), op.copyRO(), s);              // move 'temp' into r after s              insertMoveAfter(op.copyRO(), temp.copyRO(), s);              op.register = temp.register;            }            break;          case IA32_MOVZX$W_opcode: case IA32_MOVSX$W_opcode:            {              OPT_RegisterOperand op = (OPT_RegisterOperand)MIR_Unary.getResult(s);              OPT_RegisterOperand temp = findOrCreateTemp(op, newMap, ir);              // move 'temp' into r after s              insertMoveAfter(op.copyRO(), temp.copyRO(), s);              op.register = temp.register;            }            break;          case IA32_SET$B_opcode:            {              OPT_Operand op = MIR_Set.getResult(s);              if (op.isRegister()) {                OPT_RegisterOperand rOp = MIR_Set.getResult(s).asRegister();                OPT_RegisterOperand temp = findOrCreateTemp(rOp, newMap, ir);                // move 'temp' into r after s                insertMoveAfter(rOp.copyRO(), temp, s);                rOp.register = temp.register;              }            }            break;          case IR_PROLOGUE_opcode:             {              if (SPLIT_PARAMS) {                splitAllLiveRanges(s, newMap, ir, false);              }            }          default:            {              for (OPT_OperandEnumeration e = s.getMemoryOperands();                    e.hasMoreElements(); ) {                OPT_MemoryOperand op = (OPT_MemoryOperand)e.next();                if (op.size == 1) {                  splitAllLiveRanges(s, newMap, ir, true);                  break;                }              }            }            break;        }      }    }  }