case REF_NOT_opcode: unary(s, INT_NOT_ACC, ir); break;
  public final void perform(OPT_IR ir) {     // Calling OPT_Simplifier.simplify ensures that the instruction is     // in normalized form. This reduces the number of cases we have to     // worry about (and does last minute constant folding on the off     // chance we've missed an opportunity...)    // BURS assumes that this has been done, so we must do it even if    // OPTIMIZE is false.    for (OPT_InstructionEnumeration instrs = ir.forwardInstrEnumerator();         instrs.hasMoreElements();) {      OPT_Instruction s = instrs.next();       OPT_Simplifier.simplify(s);    }    if (OPTIMIZE) {      // Compute simple ssa, u/d chains, spansBasicBlock      // to catch some additional cases where we don't have to insert moves      OPT_DefUse.computeDU(ir);      OPT_DefUse.recomputeSSA(ir);      OPT_DefUse.recomputeSpansBasicBlock(ir);      for (OPT_Register reg = ir.regpool.getFirstSymbolicRegister();            reg != null;            reg = reg.getNext()) {        markDead(reg);      }    }    // Reverse pass over instructions supports simple live analysis.    for (OPT_Instruction next, s = ir.lastInstructionInCodeOrder();          s != null;          s = next) {      next = s.prevInstructionInCodeOrder();            switch(s.getOpcode()) {      case BOOLEAN_NOT_opcode: unary(s, BOOLEAN_NOT_ACC, ir); break;      case INT_ADD_opcode: commutative(s, INT_ADD_ACC, ir); break;      case INT_SUB_opcode: noncommutative(s, INT_SUB_ACC, ir); break;      case INT_MUL_opcode: commutative(s, INT_MUL_ACC, ir); break;      case INT_SHL_opcode: noncommutative(s, INT_SHL_ACC, ir); break;      case INT_SHR_opcode: noncommutative(s, INT_SHR_ACC, ir); break;      case INT_USHR_opcode: noncommutative(s, INT_USHR_ACC, ir); break;      case INT_AND_opcode: commutative(s, INT_AND_ACC, ir); break;      case INT_OR_opcode: commutative(s, INT_OR_ACC, ir); break;      case INT_XOR_opcode: commutative(s, INT_XOR_ACC, ir); break;      case INT_NEG_opcode: unary(s, INT_NEG_ACC, ir); break;      case INT_NOT_opcode: unary(s, INT_NOT_ACC, ir); break;      case LONG_ADD_opcode: commutative(s, LONG_ADD_ACC, ir); break;      case LONG_SUB_opcode: noncommutative(s, LONG_SUB_ACC, ir); break;      case LONG_MUL_opcode: commutative(s, LONG_MUL_ACC, ir); break;      case LONG_SHL_opcode: noncommutative(s, LONG_SHL_ACC, ir); break;      case LONG_SHR_opcode: noncommutative(s, LONG_SHR_ACC, ir); break;      case LONG_USHR_opcode: noncommutative(s, LONG_USHR_ACC, ir); break;      case LONG_AND_opcode: commutative(s, LONG_AND_ACC, ir); break;      case LONG_OR_opcode: commutative(s, LONG_OR_ACC, ir); break;      case LONG_XOR_opcode: commutative(s, LONG_XOR_ACC, ir); break;      case LONG_NEG_opcode: unary(s, LONG_NEG_ACC, ir); break;      case LONG_NOT_opcode: unary(s, LONG_NOT_ACC, ir); break;      // BURS doesn't really care, so consolidate to reduce rule space      case FLOAT_ADD_opcode: s.operator = FP_ADD; break;      case DOUBLE_ADD_opcode: s.operator = FP_ADD; break;      case FLOAT_SUB_opcode: s.operator = FP_SUB; break;      case DOUBLE_SUB_opcode: s.operator = FP_SUB; break;      case FLOAT_MUL_opcode: s.operator = FP_MUL; break;      case DOUBLE_MUL_opcode: s.operator = FP_MUL; break;      case FLOAT_DIV_opcode: s.operator = FP_DIV; break;      case DOUBLE_DIV_opcode: s.operator = FP_DIV; break;       case FLOAT_REM_opcode: s.operator = FP_REM; break;      case DOUBLE_REM_opcode: s.operator = FP_REM; break;      case FLOAT_NEG_opcode: s.operator = FP_NEG; break;      case DOUBLE_NEG_opcode: s.operator = FP_NEG; break;      // BURS doesn't really care, so consolidate to reduce rule space      case INT_COND_MOVE_opcode: s.operator = CMOV; break;      case REF_COND_MOVE_opcode: s.operator = CMOV; break;      case FLOAT_COND_MOVE_opcode: s.operator = CMOV; break;      case DOUBLE_COND_MOVE_opcode: s.operator = CMOV; break;      case LONG_COND_MOVE_opcode: OPT_OptimizingCompilerException.TODO(); break;      case GUARD_COND_MOVE_opcode: OPT_OptimizingCompilerException.TODO(); break;      // BURS doesn't really care, so consolidate to reduce rule space      case INT_2FLOAT_opcode: s.operator = INT_2FP; break;      case INT_2DOUBLE_opcode: s.operator = INT_2FP; break;      case LONG_2FLOAT_opcode: s.operator = LONG_2FP; break;      case LONG_2DOUBLE_opcode: s.operator = LONG_2FP; break;      // BURS doesn't really care, so consolidate to reduce rule space      case REF_LOAD_opcode: s.operator = INT_LOAD; break;      case REF_STORE_opcode: s.operator = INT_STORE; break;      case REF_ALOAD_opcode: s.operator = INT_ALOAD; break;      case REF_ASTORE_opcode: s.operator = INT_ASTORE; break;      case REF_MOVE_opcode: s.operator = INT_MOVE; break;      case REF_IFCMP_opcode: s.operator = INT_IFCMP; break;      case ATTEMPT_ADDR_opcode: s.operator = ATTEMPT_INT; break;      case PREPARE_ADDR_opcode: s.operator = PREPARE_INT; break;      case INT_2ADDRSigExt_opcode: s.operator = INT_MOVE; break;      case INT_2ADDRZerExt_opcode: s.operator = INT_MOVE; break;      case ADDR_2INT_opcode: s.operator = INT_MOVE; break;      case ADDR_2LONG_opcode: s.operator = INT_2LONG; break;		}      if (OPTIMIZE) {        // update liveness         for (OPT_OperandEnumeration defs = s.getPureDefs();             defs.hasMoreElements();) {          OPT_Operand op = defs.next();          if (op.isRegister()) {            markDead(op.asRegister().register);          }        }        for (OPT_OperandEnumeration uses = s.getUses(); // includes def/uses             uses.hasMoreElements();) {          OPT_Operand op = uses.next();          if (op.isRegister()) {            markLive(op.asRegister().register);          }        }      }    }  }