s.insertBefore(MIR_Move.create(IA32_MOV, tl, R(xl)));
s.insertBefore(MIR_Move.create(IA32_MOV, tl, new OPT_RegisterOperand(xl, VM_TypeReference.Int)));
  private static void basic_long_ifcmp(OPT_Instruction s, OPT_IR ir,                                        OPT_ConditionOperand cond,                                        OPT_Register xh,                                        OPT_Register xl,                                        OPT_Operand yh,                                        OPT_Operand yl) {    if (cond.isEQUAL() || cond.isNOT_EQUAL()) {      OPT_RegisterOperand th = ir.regpool.makeTempInt();      OPT_RegisterOperand tl = ir.regpool.makeTempInt();      // tricky... ((xh^yh)|(xl^yl) == 0) <==> (lhll == rhrl)!!      s.insertBefore(MIR_Move.create(IA32_MOV, th, R(xh)));      s.insertBefore(MIR_BinaryAcc.create(IA32_XOR, th.copyD2D(), yh));      s.insertBefore(MIR_Move.create(IA32_MOV, tl, R(xl)));      s.insertBefore(MIR_BinaryAcc.create(IA32_XOR, tl.copyD2D(), yl));      s.insertBefore(MIR_BinaryAcc.create(IA32_OR, th.copyD2D(), tl.copyD2U()));      MIR_CondBranch.mutate(s, IA32_JCC,                             new OPT_IA32ConditionOperand(cond),                            IfCmp.getTarget(s),                            IfCmp.getBranchProfile(s));    } else {      // Do the naive thing and generate multiple compare/branch implementation.      OPT_IA32ConditionOperand cond1;      OPT_IA32ConditionOperand cond2;      OPT_IA32ConditionOperand cond3;      if (cond.isLESS()) {        cond1 = OPT_IA32ConditionOperand.LT();        cond2 = OPT_IA32ConditionOperand.GT();        cond3 = OPT_IA32ConditionOperand.LLT();      } else if (cond.isGREATER()) {        cond1 = OPT_IA32ConditionOperand.GT();        cond2 = OPT_IA32ConditionOperand.LT();        cond3 = OPT_IA32ConditionOperand.LGT();      } else if (cond.isLESS_EQUAL()) {        cond1 = OPT_IA32ConditionOperand.LT();        cond2 = OPT_IA32ConditionOperand.GT();        cond3 = OPT_IA32ConditionOperand.LLE();      } else if (cond.isGREATER_EQUAL()) {        cond1 = OPT_IA32ConditionOperand.GT();        cond2 = OPT_IA32ConditionOperand.LT();        cond3 = OPT_IA32ConditionOperand.LGE();      } else {        // I don't think we use the unsigned compares for longs,        // so defer actually implementing them until we find a test case. --dave        cond1 = cond2 = cond3 = null;        OPT_OptimizingCompilerException.TODO();      }      OPT_BasicBlock myBlock = s.getBasicBlock();      OPT_BasicBlock test2Block = myBlock.createSubBlock(s.bcIndex, ir, 0.25f);      OPT_BasicBlock falseBlock = myBlock.splitNodeAt(s, ir);      OPT_BasicBlock trueBlock = IfCmp.getTarget(s).target.getBasicBlock();            falseBlock.recomputeNormalOut(ir);      myBlock.insertOut(test2Block);      myBlock.insertOut(falseBlock);      myBlock.insertOut(trueBlock);      test2Block.insertOut(falseBlock);      test2Block.insertOut(trueBlock);      ir.cfg.linkInCodeOrder(myBlock, test2Block);      ir.cfg.linkInCodeOrder(test2Block, falseBlock);            s.remove();            myBlock.appendInstruction(MIR_Compare.create(IA32_CMP, R(xh), yh));      myBlock.appendInstruction(MIR_CondBranch2.create(IA32_JCC2,                                                        cond1, trueBlock.makeJumpTarget(), new OPT_BranchProfileOperand(),                                                       cond2, falseBlock.makeJumpTarget(), new OPT_BranchProfileOperand()));      test2Block.appendInstruction(MIR_Compare.create(IA32_CMP, R(xl), yl));      test2Block.appendInstruction(MIR_CondBranch.create(IA32_JCC, cond3, trueBlock.makeJumpTarget(), new OPT_BranchProfileOperand()));    }  }