PeepholeOptimizer.cpp revision 92ad57f066e9f256e4e3d72febf152e68caa80c7
15c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)//===-- PeepholeOptimizer.cpp - Peephole Optimizations --------------------===// 25267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)// 35c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// The LLVM Compiler Infrastructure 45c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 55c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// License. See LICENSE.TXT for details. 75c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 85c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)//===----------------------------------------------------------------------===// 95c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 105c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// Perform peephole optimizations on the machine code: 115c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 125c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// - Optimize Extensions 135c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 145c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// Optimization of sign / zero extension instructions. It may be extended to 155c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// handle other instructions with similar properties. 165c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 175c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// On some targets, some instructions, e.g. X86 sign / zero extension, may 185c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// leave the source value in the lower part of the result. This optimization 195c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// will replace some uses of the pre-extension value with uses of the 205c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// sub-register of the results. 215c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 225c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// - Optimize Comparisons 235c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 245c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// Optimization of comparison instructions. For instance, in this code: 255c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 265c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// sub r1, 1 275c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// cmp r1, 0 285c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// bz L1 295c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// 305c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// If the "sub" instruction all ready sets (or could be modified to set) the 315c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)// same flag that the "cmp" instruction sets and that "bz" uses, then we can 325267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)// eliminate the "cmp" instruction. 335267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)// 34591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch//===----------------------------------------------------------------------===// 35e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 365267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)#define DEBUG_TYPE "peephole-opt" 37e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch#include "llvm/CodeGen/Passes.h" 38e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch#include "llvm/CodeGen/MachineDominators.h" 39591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch#include "llvm/CodeGen/MachineInstrBuilder.h" 405267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)#include "llvm/CodeGen/MachineRegisterInfo.h" 41e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch#include "llvm/Target/TargetInstrInfo.h" 425267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)#include "llvm/Target/TargetRegisterInfo.h" 435267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)#include "llvm/Support/CommandLine.h" 445267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)#include "llvm/ADT/SmallPtrSet.h" 455c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)#include "llvm/ADT/Statistic.h" 465c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles)using namespace llvm; 475c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles) 48521d96ec04ace82590870fb04353ec4f82bb150fTorne (Richard Coles)// Optimize Extensions 495267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)static cl::opt<bool> 50521d96ec04ace82590870fb04353ec4f82bb150fTorne (Richard Coles)Aggressive("aggressive-ext-opt", cl::Hidden, 515267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles) cl::desc("Aggressive extension optimization")); 52e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 535267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)STATISTIC(NumReuse, "Number of extension results reused"); 545267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)STATISTIC(NumEliminated, "Number of compares eliminated"); 55926b001d589ce2f10facb93dd4b87578ea35a855Torne (Richard Coles) 565267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles)namespace { 575c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles) class PeepholeOptimizer : public MachineFunctionPass { 585267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles) const TargetMachine *TM; 59926b001d589ce2f10facb93dd4b87578ea35a855Torne (Richard Coles) const TargetInstrInfo *TII; 60926b001d589ce2f10facb93dd4b87578ea35a855Torne (Richard Coles) MachineRegisterInfo *MRI; 61521d96ec04ace82590870fb04353ec4f82bb150fTorne (Richard Coles) MachineDominatorTree *DT; // Machine dominator tree 625267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles) 63521d96ec04ace82590870fb04353ec4f82bb150fTorne (Richard Coles) public: 64591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch static char ID; // Pass identification 65e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch PeepholeOptimizer() : MachineFunctionPass(ID) {} 66e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 67926b001d589ce2f10facb93dd4b87578ea35a855Torne (Richard Coles) virtual bool runOnMachineFunction(MachineFunction &MF); 685267f701546148b83dfbe1d151cb184385bb5c22Torne (Richard Coles) 69591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch virtual void getAnalysisUsage(AnalysisUsage &AU) const { 70e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch AU.setPreservesCFG(); 71e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch MachineFunctionPass::getAnalysisUsage(AU); 72e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch if (Aggressive) { 73e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch AU.addRequired<MachineDominatorTree>(); 74e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch AU.addPreserved<MachineDominatorTree>(); 75e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch } 76e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch } 77e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 78e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch private: 79e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch bool OptimizeCmpInstr(MachineInstr *MI, MachineBasicBlock *MBB, 80591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch MachineBasicBlock::iterator &MII); 81591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch bool OptimizeExtInstr(MachineInstr *MI, MachineBasicBlock *MBB, 82591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch SmallPtrSet<MachineInstr*, 8> &LocalMIs); 83591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch }; 84591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch} 85591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch 86e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdochchar PeepholeOptimizer::ID = 0; 87591b958dee2cf159d33a0b931e6231072eaf38d5Ben MurdochINITIALIZE_PASS(PeepholeOptimizer, "peephole-opts", 88591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch "Peephole Optimizations", false, false); 89591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch 90591b958dee2cf159d33a0b931e6231072eaf38d5Ben MurdochFunctionPass *llvm::createPeepholeOptimizerPass() { 91591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch return new PeepholeOptimizer(); 92591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch} 93591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch 94e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch/// OptimizeExtInstr - If instruction is a copy-like instruction, i.e. it reads 95591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// a single register and writes a single register and it does not modify the 96591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// source, and if the source value is preserved as a sub-register of the 97591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// result, then replace all reachable uses of the source with the subreg of the 98e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch/// result. 99591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// 100591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// Do not generate an EXTRACT that is used only in a debug use, as this changes 101591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// the code. Since this code does not currently share EXTRACTs, just ignore all 102591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch/// debug uses. 103591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdochbool PeepholeOptimizer:: 104591b958dee2cf159d33a0b931e6231072eaf38d5Ben MurdochOptimizeExtInstr(MachineInstr *MI, MachineBasicBlock *MBB, 105591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch SmallPtrSet<MachineInstr*, 8> &LocalMIs) { 106e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch LocalMIs.insert(MI); 107591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch 108591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch unsigned SrcReg, DstReg, SubIdx; 109591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch if (!TII->isCoalescableExtInstr(*MI, SrcReg, DstReg, SubIdx)) 110e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch return false; 111e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 112e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch if (TargetRegisterInfo::isPhysicalRegister(DstReg) || 113e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch TargetRegisterInfo::isPhysicalRegister(SrcReg)) 114e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch return false; 115e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 116e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch MachineRegisterInfo::use_nodbg_iterator UI = MRI->use_nodbg_begin(SrcReg); 117e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch if (++UI == MRI->use_nodbg_end()) 118e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // No other uses. 119e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch return false; 120e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 121591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // The source has other uses. See if we can replace the other uses with use of 122591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // the result of the extension. 123e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch SmallPtrSet<MachineBasicBlock*, 4> ReachedBBs; 124591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch UI = MRI->use_nodbg_begin(DstReg); 125e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch for (MachineRegisterInfo::use_nodbg_iterator UE = MRI->use_nodbg_end(); 126e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch UI != UE; ++UI) 127e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch ReachedBBs.insert(UI->getParent()); 128e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 129e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // Uses that are in the same BB of uses of the result of the instruction. 130e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch SmallVector<MachineOperand*, 8> Uses; 131e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 132e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // Uses that the result of the instruction can reach. 133e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch SmallVector<MachineOperand*, 8> ExtendedUses; 134e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 135591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch bool ExtendLife = true; 136e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch UI = MRI->use_nodbg_begin(SrcReg); 137e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch for (MachineRegisterInfo::use_nodbg_iterator UE = MRI->use_nodbg_end(); 138e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch UI != UE; ++UI) { 139e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch MachineOperand &UseMO = UI.getOperand(); 140e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch MachineInstr *UseMI = &*UI; 141e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch if (UseMI == MI) 142e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch continue; 143e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 144e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch if (UseMI->isPHI()) { 145e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch ExtendLife = false; 146e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch continue; 147e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch } 148e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch 149e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // It's an error to translate this: 150e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // 151591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // %reg1025 = <sext> %reg1024 152591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // ... 153e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // %reg1026 = SUBREG_TO_REG 0, %reg1024, 4 154591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // 155e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // into this: 156e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // 157591b958dee2cf159d33a0b931e6231072eaf38d5Ben Murdoch // %reg1025 = <sext> %reg1024 158e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // ... 159e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // %reg1027 = COPY %reg1025:4 1605c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles) // %reg1026 = SUBREG_TO_REG 0, %reg1027, 4 1615c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles) // 162e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // The problem here is that SUBREG_TO_REG is there to assert that an 163e69819bd8e388ea4ad1636a19aa6b2eed4952191Ben Murdoch // implicit zext occurs. It doesn't insert a zext instruction. If we allow 1645c87bf8b86a7c82ef50fb7a89697d8e02e2553beTorne (Richard Coles) // the COPY here, it will give us the value after the <sext>, not the 165 // original value of %reg1024 before <sext>. 166 if (UseMI->getOpcode() == TargetOpcode::SUBREG_TO_REG) 167 continue; 168 169 MachineBasicBlock *UseMBB = UseMI->getParent(); 170 if (UseMBB == MBB) { 171 // Local uses that come after the extension. 172 if (!LocalMIs.count(UseMI)) 173 Uses.push_back(&UseMO); 174 } else if (ReachedBBs.count(UseMBB)) { 175 // Non-local uses where the result of the extension is used. Always 176 // replace these unless it's a PHI. 177 Uses.push_back(&UseMO); 178 } else if (Aggressive && DT->dominates(MBB, UseMBB)) { 179 // We may want to extend the live range of the extension result in order 180 // to replace these uses. 181 ExtendedUses.push_back(&UseMO); 182 } else { 183 // Both will be live out of the def MBB anyway. Don't extend live range of 184 // the extension result. 185 ExtendLife = false; 186 break; 187 } 188 } 189 190 if (ExtendLife && !ExtendedUses.empty()) 191 // Extend the liveness of the extension result. 192 std::copy(ExtendedUses.begin(), ExtendedUses.end(), 193 std::back_inserter(Uses)); 194 195 // Now replace all uses. 196 bool Changed = false; 197 if (!Uses.empty()) { 198 SmallPtrSet<MachineBasicBlock*, 4> PHIBBs; 199 200 // Look for PHI uses of the extended result, we don't want to extend the 201 // liveness of a PHI input. It breaks all kinds of assumptions down 202 // stream. A PHI use is expected to be the kill of its source values. 203 UI = MRI->use_nodbg_begin(DstReg); 204 for (MachineRegisterInfo::use_nodbg_iterator 205 UE = MRI->use_nodbg_end(); UI != UE; ++UI) 206 if (UI->isPHI()) 207 PHIBBs.insert(UI->getParent()); 208 209 const TargetRegisterClass *RC = MRI->getRegClass(SrcReg); 210 for (unsigned i = 0, e = Uses.size(); i != e; ++i) { 211 MachineOperand *UseMO = Uses[i]; 212 MachineInstr *UseMI = UseMO->getParent(); 213 MachineBasicBlock *UseMBB = UseMI->getParent(); 214 if (PHIBBs.count(UseMBB)) 215 continue; 216 217 unsigned NewVR = MRI->createVirtualRegister(RC); 218 BuildMI(*UseMBB, UseMI, UseMI->getDebugLoc(), 219 TII->get(TargetOpcode::COPY), NewVR) 220 .addReg(DstReg, 0, SubIdx); 221 222 UseMO->setReg(NewVR); 223 ++NumReuse; 224 Changed = true; 225 } 226 } 227 228 return Changed; 229} 230 231/// OptimizeCmpInstr - If the instruction is a compare and the previous 232/// instruction it's comparing against all ready sets (or could be modified to 233/// set) the same flag as the compare, then we can remove the comparison and use 234/// the flag from the previous instruction. 235bool PeepholeOptimizer::OptimizeCmpInstr(MachineInstr *MI, 236 MachineBasicBlock *MBB, 237 MachineBasicBlock::iterator &NextIter){ 238 // If this instruction is a comparison against zero and isn't comparing a 239 // physical register, we can try to optimize it. 240 unsigned SrcReg; 241 int CmpValue; 242 if (!TII->AnalyzeCompare(MI, SrcReg, CmpValue) || 243 TargetRegisterInfo::isPhysicalRegister(SrcReg)) 244 return false; 245 246 // Attempt to convert the defining instruction to set the "zero" flag. 247 if (TII->ConvertToSetZeroFlag(MI, NextIter)) { 248 ++NumEliminated; 249 return true; 250 } 251 252 return false; 253} 254 255bool PeepholeOptimizer::runOnMachineFunction(MachineFunction &MF) { 256 TM = &MF.getTarget(); 257 TII = TM->getInstrInfo(); 258 MRI = &MF.getRegInfo(); 259 DT = Aggressive ? &getAnalysis<MachineDominatorTree>() : 0; 260 261 bool Changed = false; 262 263 SmallPtrSet<MachineInstr*, 8> LocalMIs; 264 for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) { 265 MachineBasicBlock *MBB = &*I; 266 LocalMIs.clear(); 267 268 for (MachineBasicBlock::iterator 269 MII = I->begin(), MIE = I->end(); MII != MIE; ) { 270 MachineInstr *MI = &*MII; 271 272 if (MI->getDesc().isCompare()) { 273 if (OptimizeCmpInstr(MI, MBB, MII)) 274 Changed = true; 275 else 276 ++MII; 277 } else { 278 Changed |= OptimizeExtInstr(MI, MBB, LocalMIs); 279 ++MII; 280 } 281 } 282 } 283 284 return Changed; 285} 286