1 //====-- X86CmovConversion.cpp - Convert Cmov to Branch -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 /// This file implements a pass that converts X86 cmov instructions into branch
11 /// when profitable. This pass is conservative, i.e., it applies transformation
12 /// if and only if it can gaurantee a gain with high confidence.
14 /// Thus, the optimization applies under the following conditions:
15 /// 1. Consider as a candidate only CMOV in most inner loop, assuming that
16 /// most hotspots are represented by these loops.
17 /// 2. Given a group of CMOV instructions, that are using same EFLAGS def
19 /// a. Consider them as candidates only if all have same code condition or
20 /// opposite one, to prevent generating more than one conditional jump
21 /// per EFLAGS def instruction.
22 /// b. Consider them as candidates only if all are profitable to be
23 /// converted, assuming that one bad conversion may casue a degradation.
24 /// 3. Apply conversion only for loop that are found profitable and only for
25 /// CMOV candidates that were found profitable.
26 /// a. Loop is considered profitable only if conversion will reduce its
27 /// depth cost by some thrishold.
28 /// b. CMOV is considered profitable if the cost of its condition is higher
29 /// than the average cost of its true-value and false-value by 25% of
30 /// branch-misprediction-penalty, this to assure no degredassion even
31 /// with 25% branch misprediction.
33 /// Note: This pass is assumed to run on SSA machine code.
34 //===----------------------------------------------------------------------===//
36 // External interfaces:
37 // FunctionPass *llvm::createX86CmovConverterPass();
38 // bool X86CmovConverterPass::runOnMachineFunction(MachineFunction &MF);
42 #include "X86InstrInfo.h"
43 #include "X86Subtarget.h"
44 #include "llvm/ADT/Statistic.h"
45 #include "llvm/CodeGen/MachineFunctionPass.h"
46 #include "llvm/CodeGen/MachineInstrBuilder.h"
47 #include "llvm/CodeGen/MachineLoopInfo.h"
48 #include "llvm/CodeGen/MachineRegisterInfo.h"
49 #include "llvm/CodeGen/Passes.h"
50 #include "llvm/CodeGen/TargetSchedule.h"
51 #include "llvm/IR/InstIterator.h"
52 #include "llvm/Support/Debug.h"
53 #include "llvm/Support/raw_ostream.h"
56 #define DEBUG_TYPE "x86-cmov-converter"
58 STATISTIC(NumOfSkippedCmovGroups, "Number of unsupported CMOV-groups");
59 STATISTIC(NumOfCmovGroupCandidate, "Number of CMOV-group candidates");
60 STATISTIC(NumOfLoopCandidate, "Number of CMOV-conversion profitable loops");
61 STATISTIC(NumOfOptimizedCmovGroups, "Number of optimized CMOV-groups");
64 // This internal switch can be used to turn off the cmov/branch optimization.
66 EnableCmovConverter("x86-cmov-converter",
67 cl::desc("Enable the X86 cmov-to-branch optimization."),
68 cl::init(true), cl::Hidden);
70 /// Converts X86 cmov instructions into branches when profitable.
71 class X86CmovConverterPass : public MachineFunctionPass {
73 X86CmovConverterPass() : MachineFunctionPass(ID) {}
74 ~X86CmovConverterPass() {}
76 StringRef getPassName() const override { return "X86 cmov Conversion"; }
77 bool runOnMachineFunction(MachineFunction &MF) override;
78 void getAnalysisUsage(AnalysisUsage &AU) const override;
81 /// Pass identification, replacement for typeid.
84 const MachineRegisterInfo *MRI;
85 const TargetInstrInfo *TII;
86 TargetSchedModel TSchedModel;
88 /// List of consecutive CMOV instructions.
89 typedef SmallVector<MachineInstr *, 2> CmovGroup;
90 typedef SmallVector<CmovGroup, 2> CmovGroups;
92 /// Collect all CMOV-group-candidates in \p CurrLoop and update \p
93 /// CmovInstGroups accordingly.
95 /// \param CurrLoop Loop being processed.
96 /// \param CmovInstGroups List of consecutive CMOV instructions in CurrLoop.
97 /// \returns true iff it found any CMOV-group-candidate.
98 bool collectCmovCandidates(MachineLoop *CurrLoop, CmovGroups &CmovInstGroups);
100 /// Check if it is profitable to transform each CMOV-group-candidates into
101 /// branch. Remove all groups that are not profitable from \p CmovInstGroups.
103 /// \param CurrLoop Loop being processed.
104 /// \param CmovInstGroups List of consecutive CMOV instructions in CurrLoop.
105 /// \returns true iff any CMOV-group-candidate remain.
106 bool checkForProfitableCmovCandidates(MachineLoop *CurrLoop,
107 CmovGroups &CmovInstGroups);
109 /// Convert the given list of consecutive CMOV instructions into a branch.
111 /// \param Group Consecutive CMOV instructions to be converted into branch.
112 void convertCmovInstsToBranches(SmallVectorImpl<MachineInstr *> &Group) const;
115 char X86CmovConverterPass::ID = 0;
117 void X86CmovConverterPass::getAnalysisUsage(AnalysisUsage &AU) const {
118 MachineFunctionPass::getAnalysisUsage(AU);
119 AU.addRequired<MachineLoopInfo>();
122 bool X86CmovConverterPass::runOnMachineFunction(MachineFunction &MF) {
123 if (skipFunction(*MF.getFunction()))
125 if (!EnableCmovConverter)
128 DEBUG(dbgs() << "********** " << getPassName() << " : " << MF.getName()
131 bool Changed = false;
132 MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
133 const TargetSubtargetInfo &STI = MF.getSubtarget();
134 MRI = &MF.getRegInfo();
135 TII = STI.getInstrInfo();
136 TSchedModel.init(STI.getSchedModel(), &STI, TII);
138 //===--------------------------------------------------------------------===//
141 // For each inner most loop
142 // collectCmovCandidates() {
143 // Find all CMOV-group-candidates.
146 // checkForProfitableCmovCandidates() {
147 // * Calculate both loop-depth and optimized-loop-depth.
148 // * Use these depth to check for loop transformation profitability.
149 // * Check for CMOV-group-candidate transformation profitability.
152 // For each profitable CMOV-group-candidate
153 // convertCmovInstsToBranches() {
154 // * Create FalseBB, SinkBB, Conditional branch to SinkBB.
155 // * Replace each CMOV instruction with a PHI instruction in SinkBB.
158 // Note: For more details, see each function description.
159 //===--------------------------------------------------------------------===//
160 for (MachineBasicBlock &MBB : MF) {
161 MachineLoop *CurrLoop = MLI.getLoopFor(&MBB);
163 // Optimize only inner most loops.
164 if (!CurrLoop || CurrLoop->getHeader() != &MBB ||
165 !CurrLoop->getSubLoops().empty())
168 // List of consecutive CMOV instructions to be processed.
169 CmovGroups CmovInstGroups;
171 if (!collectCmovCandidates(CurrLoop, CmovInstGroups))
174 if (!checkForProfitableCmovCandidates(CurrLoop, CmovInstGroups))
178 for (auto &Group : CmovInstGroups)
179 convertCmovInstsToBranches(Group);
184 bool X86CmovConverterPass::collectCmovCandidates(MachineLoop *CurrLoop,
185 CmovGroups &CmovInstGroups) {
186 //===--------------------------------------------------------------------===//
187 // Collect all CMOV-group-candidates and add them into CmovInstGroups.
190 // CMOV instructions, in same MBB, that uses same EFLAGS def instruction.
192 // CMOV-group-candidate:
193 // CMOV-group where all the CMOV instructions are
195 // 2. have same condition code or opposite one.
196 // 3. have only operand registers (X86::CMOVrr).
197 //===--------------------------------------------------------------------===//
198 // List of possible improvement (TODO's):
199 // --------------------------------------
200 // TODO: Add support for X86::CMOVrm instructions.
201 // TODO: Add support for X86::SETcc instructions.
202 // TODO: Add support for CMOV-groups with non consecutive CMOV instructions.
203 //===--------------------------------------------------------------------===//
205 // Current processed CMOV-Group.
207 for (auto *MBB : CurrLoop->getBlocks()) {
209 // Condition code of first CMOV instruction current processed range and its
210 // opposite condition code.
211 X86::CondCode FirstCC, FirstOppCC;
212 // Indicator of a non CMOVrr instruction in the current processed range.
213 bool FoundNonCMOVInst = false;
214 // Indicator for current processed CMOV-group if it should be skipped.
215 bool SkipGroup = false;
217 for (auto &I : *MBB) {
218 X86::CondCode CC = X86::getCondFromCMovOpc(I.getOpcode());
219 // Check if we found a X86::CMOVrr instruction.
220 if (CC != X86::COND_INVALID && !I.mayLoad()) {
222 // We found first CMOV in the range, reset flags.
224 FirstOppCC = X86::GetOppositeBranchCondition(CC);
225 FoundNonCMOVInst = false;
229 // Check if it is a non-consecutive CMOV instruction or it has different
230 // condition code than FirstCC or FirstOppCC.
231 if (FoundNonCMOVInst || (CC != FirstCC && CC != FirstOppCC))
232 // Mark the SKipGroup indicator to skip current processed CMOV-Group.
236 // If Group is empty, keep looking for first CMOV in the range.
240 // We found a non X86::CMOVrr instruction.
241 FoundNonCMOVInst = true;
242 // Check if this instruction define EFLAGS, to determine end of processed
243 // range, as there would be no more instructions using current EFLAGS def.
244 if (I.definesRegister(X86::EFLAGS)) {
245 // Check if current processed CMOV-group should not be skipped and add
246 // it as a CMOV-group-candidate.
248 CmovInstGroups.push_back(Group);
250 ++NumOfSkippedCmovGroups;
254 // End of basic block is considered end of range, check if current processed
255 // CMOV-group should not be skipped and add it as a CMOV-group-candidate.
259 CmovInstGroups.push_back(Group);
261 ++NumOfSkippedCmovGroups;
264 NumOfCmovGroupCandidate += CmovInstGroups.size();
265 return !CmovInstGroups.empty();
268 /// \returns Depth of CMOV instruction as if it was converted into branch.
269 /// \param TrueOpDepth depth cost of CMOV true value operand.
270 /// \param FalseOpDepth depth cost of CMOV false value operand.
271 static unsigned getDepthOfOptCmov(unsigned TrueOpDepth, unsigned FalseOpDepth) {
272 //===--------------------------------------------------------------------===//
273 // With no info about branch weight, we assume 50% for each value operand.
274 // Thus, depth of optimized CMOV instruction is the rounded up average of
275 // its True-Operand-Value-Depth and False-Operand-Value-Depth.
276 //===--------------------------------------------------------------------===//
277 return (TrueOpDepth + FalseOpDepth + 1) / 2;
280 bool X86CmovConverterPass::checkForProfitableCmovCandidates(
281 MachineLoop *CurrLoop, CmovGroups &CmovInstGroups) {
283 /// Depth of original loop.
285 /// Depth of optimized loop.
288 /// Number of loop iterations to calculate depth for ?!
289 static const unsigned LoopIterations = 2;
290 DenseMap<MachineInstr *, DepthInfo> DepthMap;
291 DepthInfo LoopDepth[LoopIterations] = {{0, 0}, {0, 0}};
292 enum { PhyRegType = 0, VirRegType = 1, RegTypeNum = 2 };
293 /// For each register type maps the register to its last def instruction.
294 DenseMap<unsigned, MachineInstr *> RegDefMaps[RegTypeNum];
295 /// Maps register operand to its def instruction, which can be nullptr if it
296 /// is unknown (e.g., operand is defined outside the loop).
297 DenseMap<MachineOperand *, MachineInstr *> OperandToDefMap;
299 // Set depth of unknown instruction (i.e., nullptr) to zero.
300 DepthMap[nullptr] = {0, 0};
302 SmallPtrSet<MachineInstr *, 4> CmovInstructions;
303 for (auto &Group : CmovInstGroups)
304 CmovInstructions.insert(Group.begin(), Group.end());
306 //===--------------------------------------------------------------------===//
307 // Step 1: Calculate instruction depth and loop depth.
309 // loop with CMOV-group-candidates converted into branches.
311 // Instruction-Depth:
312 // instruction latency + max operand depth.
313 // * For CMOV instruction in optimized loop the depth is calculated as:
314 // CMOV latency + getDepthOfOptCmov(True-Op-Depth, False-Op-depth)
315 // TODO: Find a better way to estimate the latency of the branch instruction
316 // rather than using the CMOV latency.
319 // max instruction depth of all instructions in the loop.
320 // Note: instruction with max depth represents the critical-path in the loop.
323 // Loop-Depth calculated for first `i` iterations.
324 // Note: it is enough to calculate depth for up to two iterations.
327 // Number of cycles saved in first 'i` iterations by optimizing the loop.
328 //===--------------------------------------------------------------------===//
329 for (unsigned I = 0; I < LoopIterations; ++I) {
330 DepthInfo &MaxDepth = LoopDepth[I];
331 for (auto *MBB : CurrLoop->getBlocks()) {
332 // Clear physical registers Def map.
333 RegDefMaps[PhyRegType].clear();
334 for (MachineInstr &MI : *MBB) {
335 unsigned MIDepth = 0;
336 unsigned MIDepthOpt = 0;
337 bool IsCMOV = CmovInstructions.count(&MI);
338 for (auto &MO : MI.uses()) {
339 // Checks for "isUse()" as "uses()" returns also implicit definitions.
340 if (!MO.isReg() || !MO.isUse())
342 unsigned Reg = MO.getReg();
343 auto &RDM = RegDefMaps[TargetRegisterInfo::isVirtualRegister(Reg)];
344 if (MachineInstr *DefMI = RDM.lookup(Reg)) {
345 OperandToDefMap[&MO] = DefMI;
346 DepthInfo Info = DepthMap.lookup(DefMI);
347 MIDepth = std::max(MIDepth, Info.Depth);
349 MIDepthOpt = std::max(MIDepthOpt, Info.OptDepth);
354 MIDepthOpt = getDepthOfOptCmov(
355 DepthMap[OperandToDefMap.lookup(&MI.getOperand(1))].OptDepth,
356 DepthMap[OperandToDefMap.lookup(&MI.getOperand(2))].OptDepth);
358 // Iterates over all operands to handle implicit definitions as well.
359 for (auto &MO : MI.operands()) {
360 if (!MO.isReg() || !MO.isDef())
362 unsigned Reg = MO.getReg();
363 RegDefMaps[TargetRegisterInfo::isVirtualRegister(Reg)][Reg] = &MI;
366 unsigned Latency = TSchedModel.computeInstrLatency(&MI);
367 DepthMap[&MI] = {MIDepth += Latency, MIDepthOpt += Latency};
368 MaxDepth.Depth = std::max(MaxDepth.Depth, MIDepth);
369 MaxDepth.OptDepth = std::max(MaxDepth.OptDepth, MIDepthOpt);
374 unsigned Diff[LoopIterations] = {LoopDepth[0].Depth - LoopDepth[0].OptDepth,
375 LoopDepth[1].Depth - LoopDepth[1].OptDepth};
377 //===--------------------------------------------------------------------===//
378 // Step 2: Check if Loop worth to be optimized.
379 // Worth-Optimize-Loop:
380 // case 1: Diff[1] == Diff[0]
381 // Critical-path is iteration independent - there is no dependency
382 // of critical-path instructions on critical-path instructions of
383 // previous iteration.
384 // Thus, it is enough to check gain percent of 1st iteration -
385 // To be conservative, the optimized loop need to have a depth of
386 // 12.5% cycles less than original loop, per iteration.
388 // case 2: Diff[1] > Diff[0]
389 // Critical-path is iteration dependent - there is dependency of
390 // critical-path instructions on critical-path instructions of
391 // previous iteration.
392 // Thus, it is required to check the gradient of the gain - the
393 // change in Depth-Diff compared to the change in Loop-Depth between
394 // 1st and 2nd iterations.
395 // To be conservative, the gradient need to be at least 50%.
397 // If loop is not worth optimizing, remove all CMOV-group-candidates.
398 //===--------------------------------------------------------------------===//
399 bool WorthOptLoop = false;
400 if (Diff[1] == Diff[0])
401 WorthOptLoop = Diff[0] * 8 >= LoopDepth[0].Depth;
402 else if (Diff[1] > Diff[0])
404 (Diff[1] - Diff[0]) * 2 >= (LoopDepth[1].Depth - LoopDepth[0].Depth);
409 ++NumOfLoopCandidate;
411 //===--------------------------------------------------------------------===//
412 // Step 3: Check for each CMOV-group-candidate if it worth to be optimized.
413 // Worth-Optimize-Group:
414 // Iff it worths to optimize all CMOV instructions in the group.
416 // Worth-Optimize-CMOV:
417 // Predicted branch is faster than CMOV by the difference between depth of
418 // condition operand and depth of taken (predicted) value operand.
419 // To be conservative, the gain of such CMOV transformation should cover at
420 // at least 25% of branch-misprediction-penalty.
421 //===--------------------------------------------------------------------===//
422 unsigned MispredictPenalty = TSchedModel.getMCSchedModel()->MispredictPenalty;
423 CmovGroups TempGroups;
424 std::swap(TempGroups, CmovInstGroups);
425 for (auto &Group : TempGroups) {
426 bool WorthOpGroup = true;
427 for (auto *MI : Group) {
428 // Avoid CMOV instruction which value is used as a pointer to load from.
429 // This is another conservative check to avoid converting CMOV instruction
430 // used with tree-search like algorithm, where the branch is unpredicted.
431 auto UIs = MRI->use_instructions(MI->defs().begin()->getReg());
432 if (UIs.begin() != UIs.end() && ++UIs.begin() == UIs.end()) {
433 unsigned Op = UIs.begin()->getOpcode();
434 if (Op == X86::MOV64rm || Op == X86::MOV32rm) {
435 WorthOpGroup = false;
441 DepthMap[OperandToDefMap.lookup(&MI->getOperand(3))].Depth;
442 unsigned ValCost = getDepthOfOptCmov(
443 DepthMap[OperandToDefMap.lookup(&MI->getOperand(1))].Depth,
444 DepthMap[OperandToDefMap.lookup(&MI->getOperand(2))].Depth);
445 if (ValCost > CondCost || (CondCost - ValCost) * 4 < MispredictPenalty) {
446 WorthOpGroup = false;
452 CmovInstGroups.push_back(Group);
455 return !CmovInstGroups.empty();
458 static bool checkEFLAGSLive(MachineInstr *MI) {
459 if (MI->killsRegister(X86::EFLAGS))
462 // The EFLAGS operand of MI might be missing a kill marker.
463 // Figure out whether EFLAGS operand should LIVE after MI instruction.
464 MachineBasicBlock *BB = MI->getParent();
465 MachineBasicBlock::iterator ItrMI = MI;
467 // Scan forward through BB for a use/def of EFLAGS.
468 for (auto I = std::next(ItrMI), E = BB->end(); I != E; ++I) {
469 if (I->readsRegister(X86::EFLAGS))
471 if (I->definesRegister(X86::EFLAGS))
475 // We hit the end of the block, check whether EFLAGS is live into a successor.
476 for (auto I = BB->succ_begin(), E = BB->succ_end(); I != E; ++I) {
477 if ((*I)->isLiveIn(X86::EFLAGS))
484 void X86CmovConverterPass::convertCmovInstsToBranches(
485 SmallVectorImpl<MachineInstr *> &Group) const {
486 assert(!Group.empty() && "No CMOV instructions to convert");
487 ++NumOfOptimizedCmovGroups;
489 // To convert a CMOVcc instruction, we actually have to insert the diamond
490 // control-flow pattern. The incoming instruction knows the destination vreg
491 // to set, the condition code register to branch on, the true/false values to
492 // select between, and a branch opcode to use.
498 // v1 = CMOVge t1, f1, cond
499 // v2 = CMOVlt t2, f2, cond
500 // v3 = CMOVge v1, f3, cond
512 // %v1 = phi[%f1, %FalseMBB], [%t1, %MBB]
513 // %v2 = phi[%t2, %FalseMBB], [%f2, %MBB] ; For CMOV with OppCC switch
514 // ; true-value with false-value
515 // %v3 = phi[%f3, %FalseMBB], [%t1, %MBB] ; Phi instruction cannot use
516 // ; previous Phi instruction result
518 MachineInstr &MI = *Group.front();
519 MachineInstr *LastCMOV = Group.back();
520 DebugLoc DL = MI.getDebugLoc();
521 X86::CondCode CC = X86::CondCode(X86::getCondFromCMovOpc(MI.getOpcode()));
522 X86::CondCode OppCC = X86::GetOppositeBranchCondition(CC);
523 MachineBasicBlock *MBB = MI.getParent();
524 MachineFunction::iterator It = ++MBB->getIterator();
525 MachineFunction *F = MBB->getParent();
526 const BasicBlock *BB = MBB->getBasicBlock();
528 MachineBasicBlock *FalseMBB = F->CreateMachineBasicBlock(BB);
529 MachineBasicBlock *SinkMBB = F->CreateMachineBasicBlock(BB);
530 F->insert(It, FalseMBB);
531 F->insert(It, SinkMBB);
533 // If the EFLAGS register isn't dead in the terminator, then claim that it's
534 // live into the sink and copy blocks.
535 if (checkEFLAGSLive(LastCMOV)) {
536 FalseMBB->addLiveIn(X86::EFLAGS);
537 SinkMBB->addLiveIn(X86::EFLAGS);
540 // Transfer the remainder of BB and its successor edges to SinkMBB.
541 SinkMBB->splice(SinkMBB->begin(), MBB,
542 std::next(MachineBasicBlock::iterator(LastCMOV)), MBB->end());
543 SinkMBB->transferSuccessorsAndUpdatePHIs(MBB);
545 // Add the false and sink blocks as its successors.
546 MBB->addSuccessor(FalseMBB);
547 MBB->addSuccessor(SinkMBB);
549 // Create the conditional branch instruction.
550 BuildMI(MBB, DL, TII->get(X86::GetCondBranchFromCond(CC))).addMBB(SinkMBB);
552 // Add the sink block to the false block successors.
553 FalseMBB->addSuccessor(SinkMBB);
555 MachineInstrBuilder MIB;
556 MachineBasicBlock::iterator MIItBegin = MachineBasicBlock::iterator(MI);
557 MachineBasicBlock::iterator MIItEnd =
558 std::next(MachineBasicBlock::iterator(LastCMOV));
559 MachineBasicBlock::iterator SinkInsertionPoint = SinkMBB->begin();
560 // As we are creating the PHIs, we have to be careful if there is more than
561 // one. Later CMOVs may reference the results of earlier CMOVs, but later
562 // PHIs have to reference the individual true/false inputs from earlier PHIs.
563 // That also means that PHI construction must work forward from earlier to
564 // later, and that the code must maintain a mapping from earlier PHI's
565 // destination registers, and the registers that went into the PHI.
566 DenseMap<unsigned, std::pair<unsigned, unsigned>> RegRewriteTable;
568 for (MachineBasicBlock::iterator MIIt = MIItBegin; MIIt != MIItEnd; ++MIIt) {
569 unsigned DestReg = MIIt->getOperand(0).getReg();
570 unsigned Op1Reg = MIIt->getOperand(1).getReg();
571 unsigned Op2Reg = MIIt->getOperand(2).getReg();
573 // If this CMOV we are processing is the opposite condition from the jump we
574 // generated, then we have to swap the operands for the PHI that is going to
576 if (X86::getCondFromCMovOpc(MIIt->getOpcode()) == OppCC)
577 std::swap(Op1Reg, Op2Reg);
579 auto Op1Itr = RegRewriteTable.find(Op1Reg);
580 if (Op1Itr != RegRewriteTable.end())
581 Op1Reg = Op1Itr->second.first;
583 auto Op2Itr = RegRewriteTable.find(Op2Reg);
584 if (Op2Itr != RegRewriteTable.end())
585 Op2Reg = Op2Itr->second.second;
588 // %Result = phi [ %FalseValue, FalseMBB ], [ %TrueValue, MBB ]
590 MIB = BuildMI(*SinkMBB, SinkInsertionPoint, DL, TII->get(X86::PHI), DestReg)
596 DEBUG(dbgs() << "\tFrom: "; MIIt->dump());
597 DEBUG(dbgs() << "\tTo: "; MIB->dump());
599 // Add this PHI to the rewrite table.
600 RegRewriteTable[DestReg] = std::make_pair(Op1Reg, Op2Reg);
603 // Now remove the CMOV(s).
604 MBB->erase(MIItBegin, MIItEnd);
607 } // End anonymous namespace.
609 FunctionPass *llvm::createX86CmovConverterPass() {
610 return new X86CmovConverterPass();