PrologEpilogInserter.cpp revision 78a5bd5dbd4d99d916c69d89ceaabd83c0e52469
1//===-- PrologEpilogInserter.cpp - Insert Prolog/Epilog code in function --===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This pass is responsible for finalizing the functions frame layout, saving 11// callee saved registers, and for emitting prolog & epilog code for the 12// function. 13// 14// This pass must be run after register allocation. After this pass is 15// executed, it is illegal to construct MO_FrameIndex operands. 16// 17//===----------------------------------------------------------------------===// 18 19#include "llvm/CodeGen/Passes.h" 20#include "llvm/CodeGen/MachineFunctionPass.h" 21#include "llvm/CodeGen/MachineInstr.h" 22#include "llvm/CodeGen/MachineFrameInfo.h" 23#include "llvm/CodeGen/MachineModuleInfo.h" 24#include "llvm/CodeGen/MachineRegisterInfo.h" 25#include "llvm/CodeGen/RegisterScavenging.h" 26#include "llvm/Target/TargetMachine.h" 27#include "llvm/Target/TargetRegisterInfo.h" 28#include "llvm/Target/TargetFrameInfo.h" 29#include "llvm/Target/TargetInstrInfo.h" 30#include "llvm/Support/Compiler.h" 31#include "llvm/ADT/STLExtras.h" 32#include <climits> 33using namespace llvm; 34 35namespace { 36 struct VISIBILITY_HIDDEN PEI : public MachineFunctionPass { 37 static char ID; 38 PEI() : MachineFunctionPass(&ID) {} 39 40 const char *getPassName() const { 41 return "Prolog/Epilog Insertion & Frame Finalization"; 42 } 43 44 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 45 AU.addPreservedID(MachineLoopInfoID); 46 AU.addPreservedID(MachineDominatorsID); 47 MachineFunctionPass::getAnalysisUsage(AU); 48 } 49 50 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract 51 /// frame indexes with appropriate references. 52 /// 53 bool runOnMachineFunction(MachineFunction &Fn) { 54 const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 55 RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : NULL; 56 57 // Get MachineModuleInfo so that we can track the construction of the 58 // frame. 59 if (MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>()) 60 Fn.getFrameInfo()->setMachineModuleInfo(MMI); 61 62 // Allow the target machine to make some adjustments to the function 63 // e.g. UsedPhysRegs before calculateCalleeSavedRegisters. 64 TRI->processFunctionBeforeCalleeSavedScan(Fn, RS); 65 66 // Scan the function for modified callee saved registers and insert spill 67 // code for any callee saved registers that are modified. Also calculate 68 // the MaxCallFrameSize and HasCalls variables for the function's frame 69 // information and eliminates call frame pseudo instructions. 70 calculateCalleeSavedRegisters(Fn); 71 72 // Add the code to save and restore the callee saved registers 73 saveCalleeSavedRegisters(Fn); 74 75 // Allow the target machine to make final modifications to the function 76 // before the frame layout is finalized. 77 TRI->processFunctionBeforeFrameFinalized(Fn); 78 79 // Calculate actual frame offsets for all of the abstract stack objects... 80 calculateFrameObjectOffsets(Fn); 81 82 // Add prolog and epilog code to the function. This function is required 83 // to align the stack frame as necessary for any stack variables or 84 // called functions. Because of this, calculateCalleeSavedRegisters 85 // must be called before this function in order to set the HasCalls 86 // and MaxCallFrameSize variables. 87 insertPrologEpilogCode(Fn); 88 89 // Replace all MO_FrameIndex operands with physical register references 90 // and actual offsets. 91 // 92 replaceFrameIndices(Fn); 93 94 delete RS; 95 return true; 96 } 97 98 private: 99 RegScavenger *RS; 100 101 // MinCSFrameIndex, MaxCSFrameIndex - Keeps the range of callee saved 102 // stack frame indexes. 103 unsigned MinCSFrameIndex, MaxCSFrameIndex; 104 105 void calculateCalleeSavedRegisters(MachineFunction &Fn); 106 void saveCalleeSavedRegisters(MachineFunction &Fn); 107 void calculateFrameObjectOffsets(MachineFunction &Fn); 108 void replaceFrameIndices(MachineFunction &Fn); 109 void insertPrologEpilogCode(MachineFunction &Fn); 110 }; 111 char PEI::ID = 0; 112} 113 114 115/// createPrologEpilogCodeInserter - This function returns a pass that inserts 116/// prolog and epilog code, and eliminates abstract frame references. 117/// 118FunctionPass *llvm::createPrologEpilogCodeInserter() { return new PEI(); } 119 120 121/// calculateCalleeSavedRegisters - Scan the function for modified callee saved 122/// registers. Also calculate the MaxCallFrameSize and HasCalls variables for 123/// the function's frame information and eliminates call frame pseudo 124/// instructions. 125/// 126void PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) { 127 const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 128 const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo(); 129 130 // Get the callee saved register list... 131 const unsigned *CSRegs = RegInfo->getCalleeSavedRegs(&Fn); 132 133 // Get the function call frame set-up and tear-down instruction opcode 134 int FrameSetupOpcode = RegInfo->getCallFrameSetupOpcode(); 135 int FrameDestroyOpcode = RegInfo->getCallFrameDestroyOpcode(); 136 137 // These are used to keep track the callee-save area. Initialize them. 138 MinCSFrameIndex = INT_MAX; 139 MaxCSFrameIndex = 0; 140 141 // Early exit for targets which have no callee saved registers and no call 142 // frame setup/destroy pseudo instructions. 143 if ((CSRegs == 0 || CSRegs[0] == 0) && 144 FrameSetupOpcode == -1 && FrameDestroyOpcode == -1) 145 return; 146 147 unsigned MaxCallFrameSize = 0; 148 bool HasCalls = false; 149 150 std::vector<MachineBasicBlock::iterator> FrameSDOps; 151 for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) 152 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) 153 if (I->getOpcode() == FrameSetupOpcode || 154 I->getOpcode() == FrameDestroyOpcode) { 155 assert(I->getNumOperands() >= 1 && "Call Frame Setup/Destroy Pseudo" 156 " instructions should have a single immediate argument!"); 157 unsigned Size = I->getOperand(0).getImm(); 158 if (Size > MaxCallFrameSize) MaxCallFrameSize = Size; 159 HasCalls = true; 160 FrameSDOps.push_back(I); 161 } 162 163 MachineFrameInfo *FFI = Fn.getFrameInfo(); 164 FFI->setHasCalls(HasCalls); 165 FFI->setMaxCallFrameSize(MaxCallFrameSize); 166 167 for (unsigned i = 0, e = FrameSDOps.size(); i != e; ++i) { 168 MachineBasicBlock::iterator I = FrameSDOps[i]; 169 // If call frames are not being included as part of the stack frame, 170 // and there is no dynamic allocation (therefore referencing frame slots 171 // off sp), leave the pseudo ops alone. We'll eliminate them later. 172 if (RegInfo->hasReservedCallFrame(Fn) || RegInfo->hasFP(Fn)) 173 RegInfo->eliminateCallFramePseudoInstr(Fn, *I->getParent(), I); 174 } 175 176 // Now figure out which *callee saved* registers are modified by the current 177 // function, thus needing to be saved and restored in the prolog/epilog. 178 // 179 const TargetRegisterClass* const *CSRegClasses = 180 RegInfo->getCalleeSavedRegClasses(&Fn); 181 std::vector<CalleeSavedInfo> CSI; 182 for (unsigned i = 0; CSRegs[i]; ++i) { 183 unsigned Reg = CSRegs[i]; 184 if (Fn.getRegInfo().isPhysRegUsed(Reg)) { 185 // If the reg is modified, save it! 186 CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 187 } else { 188 for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg); 189 *AliasSet; ++AliasSet) { // Check alias registers too. 190 if (Fn.getRegInfo().isPhysRegUsed(*AliasSet)) { 191 CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 192 break; 193 } 194 } 195 } 196 } 197 198 if (CSI.empty()) 199 return; // Early exit if no callee saved registers are modified! 200 201 unsigned NumFixedSpillSlots; 202 const std::pair<unsigned,int> *FixedSpillSlots = 203 TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots); 204 205 // Now that we know which registers need to be saved and restored, allocate 206 // stack slots for them. 207 for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 208 unsigned Reg = CSI[i].getReg(); 209 const TargetRegisterClass *RC = CSI[i].getRegClass(); 210 211 // Check to see if this physreg must be spilled to a particular stack slot 212 // on this target. 213 const std::pair<unsigned,int> *FixedSlot = FixedSpillSlots; 214 while (FixedSlot != FixedSpillSlots+NumFixedSpillSlots && 215 FixedSlot->first != Reg) 216 ++FixedSlot; 217 218 int FrameIdx; 219 if (FixedSlot == FixedSpillSlots+NumFixedSpillSlots) { 220 // Nope, just spill it anywhere convenient. 221 unsigned Align = RC->getAlignment(); 222 unsigned StackAlign = TFI->getStackAlignment(); 223 // We may not be able to sastify the desired alignment specification of 224 // the TargetRegisterClass if the stack alignment is smaller. Use the min. 225 Align = std::min(Align, StackAlign); 226 FrameIdx = FFI->CreateStackObject(RC->getSize(), Align); 227 if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx; 228 if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx; 229 } else { 230 // Spill it to the stack where we must. 231 FrameIdx = FFI->CreateFixedObject(RC->getSize(), FixedSlot->second); 232 } 233 CSI[i].setFrameIdx(FrameIdx); 234 } 235 236 FFI->setCalleeSavedInfo(CSI); 237} 238 239/// saveCalleeSavedRegisters - Insert spill code for any callee saved registers 240/// that are modified in the function. 241/// 242void PEI::saveCalleeSavedRegisters(MachineFunction &Fn) { 243 // Get callee saved register information. 244 MachineFrameInfo *FFI = Fn.getFrameInfo(); 245 const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo(); 246 247 // Early exit if no callee saved registers are modified! 248 if (CSI.empty()) 249 return; 250 251 const TargetInstrInfo &TII = *Fn.getTarget().getInstrInfo(); 252 253 // Now that we have a stack slot for each register to be saved, insert spill 254 // code into the entry block. 255 MachineBasicBlock *MBB = Fn.begin(); 256 MachineBasicBlock::iterator I = MBB->begin(); 257 258 if (!TII.spillCalleeSavedRegisters(*MBB, I, CSI)) { 259 for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 260 // Add the callee-saved register as live-in. It's killed at the spill. 261 MBB->addLiveIn(CSI[i].getReg()); 262 263 // Insert the spill to the stack frame. 264 TII.storeRegToStackSlot(*MBB, I, CSI[i].getReg(), true, 265 CSI[i].getFrameIdx(), CSI[i].getRegClass()); 266 } 267 } 268 269 // Add code to restore the callee-save registers in each exiting block. 270 for (MachineFunction::iterator FI = Fn.begin(), E = Fn.end(); FI != E; ++FI) 271 // If last instruction is a return instruction, add an epilogue. 272 if (!FI->empty() && FI->back().getDesc().isReturn()) { 273 MBB = FI; 274 I = MBB->end(); --I; 275 276 // Skip over all terminator instructions, which are part of the return 277 // sequence. 278 MachineBasicBlock::iterator I2 = I; 279 while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 280 I = I2; 281 282 bool AtStart = I == MBB->begin(); 283 MachineBasicBlock::iterator BeforeI = I; 284 if (!AtStart) 285 --BeforeI; 286 287 // Restore all registers immediately before the return and any terminators 288 // that preceed it. 289 if (!TII.restoreCalleeSavedRegisters(*MBB, I, CSI)) { 290 for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 291 TII.loadRegFromStackSlot(*MBB, I, CSI[i].getReg(), 292 CSI[i].getFrameIdx(), 293 CSI[i].getRegClass()); 294 assert(I != MBB->begin() && 295 "loadRegFromStackSlot didn't insert any code!"); 296 // Insert in reverse order. loadRegFromStackSlot can insert multiple 297 // instructions. 298 if (AtStart) 299 I = MBB->begin(); 300 else { 301 I = BeforeI; 302 ++I; 303 } 304 } 305 } 306 } 307} 308 309/// AdjustStackOffset - Helper function used to adjust the stack frame offset. 310static inline void 311AdjustStackOffset(MachineFrameInfo *FFI, int FrameIdx, 312 bool StackGrowsDown, int64_t &Offset, 313 unsigned &MaxAlign) { 314 // If stack grows down, we need to add size of find the lowest address of the 315 // object. 316 if (StackGrowsDown) 317 Offset += FFI->getObjectSize(FrameIdx); 318 319 unsigned Align = FFI->getObjectAlignment(FrameIdx); 320 321 // If the alignment of this object is greater than that of the stack, then 322 // increase the stack alignment to match. 323 MaxAlign = std::max(MaxAlign, Align); 324 325 // Adjust to alignment boundary. 326 Offset = (Offset + Align - 1) / Align * Align; 327 328 if (StackGrowsDown) { 329 FFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset 330 } else { 331 FFI->setObjectOffset(FrameIdx, Offset); 332 Offset += FFI->getObjectSize(FrameIdx); 333 } 334} 335 336/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the 337/// abstract stack objects. 338/// 339void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) { 340 const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo(); 341 342 bool StackGrowsDown = 343 TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 344 345 // Loop over all of the stack objects, assigning sequential addresses... 346 MachineFrameInfo *FFI = Fn.getFrameInfo(); 347 348 unsigned MaxAlign = FFI->getMaxAlignment(); 349 350 // Start at the beginning of the local area. 351 // The Offset is the distance from the stack top in the direction 352 // of stack growth -- so it's always nonnegative. 353 int64_t Offset = TFI.getOffsetOfLocalArea(); 354 if (StackGrowsDown) 355 Offset = -Offset; 356 assert(Offset >= 0 357 && "Local area offset should be in direction of stack growth"); 358 359 // If there are fixed sized objects that are preallocated in the local area, 360 // non-fixed objects can't be allocated right at the start of local area. 361 // We currently don't support filling in holes in between fixed sized objects, 362 // so we adjust 'Offset' to point to the end of last fixed sized 363 // preallocated object. 364 for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) { 365 int64_t FixedOff; 366 if (StackGrowsDown) { 367 // The maximum distance from the stack pointer is at lower address of 368 // the object -- which is given by offset. For down growing stack 369 // the offset is negative, so we negate the offset to get the distance. 370 FixedOff = -FFI->getObjectOffset(i); 371 } else { 372 // The maximum distance from the start pointer is at the upper 373 // address of the object. 374 FixedOff = FFI->getObjectOffset(i) + FFI->getObjectSize(i); 375 } 376 if (FixedOff > Offset) Offset = FixedOff; 377 } 378 379 // First assign frame offsets to stack objects that are used to spill 380 // callee saved registers. 381 if (StackGrowsDown) { 382 for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) { 383 // If stack grows down, we need to add size of find the lowest 384 // address of the object. 385 Offset += FFI->getObjectSize(i); 386 387 unsigned Align = FFI->getObjectAlignment(i); 388 // If the alignment of this object is greater than that of the stack, then 389 // increase the stack alignment to match. 390 MaxAlign = std::max(MaxAlign, Align); 391 // Adjust to alignment boundary 392 Offset = (Offset+Align-1)/Align*Align; 393 394 FFI->setObjectOffset(i, -Offset); // Set the computed offset 395 } 396 } else { 397 int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex; 398 for (int i = MaxCSFI; i >= MinCSFI ; --i) { 399 unsigned Align = FFI->getObjectAlignment(i); 400 // If the alignment of this object is greater than that of the stack, then 401 // increase the stack alignment to match. 402 MaxAlign = std::max(MaxAlign, Align); 403 // Adjust to alignment boundary 404 Offset = (Offset+Align-1)/Align*Align; 405 406 FFI->setObjectOffset(i, Offset); 407 Offset += FFI->getObjectSize(i); 408 } 409 } 410 411 // Make sure the special register scavenging spill slot is closest to the 412 // frame pointer if a frame pointer is required. 413 const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 414 if (RS && RegInfo->hasFP(Fn)) { 415 int SFI = RS->getScavengingFrameIndex(); 416 if (SFI >= 0) 417 AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 418 } 419 420 // Make sure that the stack protector comes before the local variables on the 421 // stack. 422 if (FFI->getStackProtectorIndex() >= 0) 423 AdjustStackOffset(FFI, FFI->getStackProtectorIndex(), StackGrowsDown, 424 Offset, MaxAlign); 425 426 // Then assign frame offsets to stack objects that are not used to spill 427 // callee saved registers. 428 for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) { 429 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex) 430 continue; 431 if (RS && (int)i == RS->getScavengingFrameIndex()) 432 continue; 433 if (FFI->isDeadObjectIndex(i)) 434 continue; 435 if (FFI->getStackProtectorIndex() == (int)i) 436 continue; 437 438 AdjustStackOffset(FFI, i, StackGrowsDown, Offset, MaxAlign); 439 } 440 441 // Make sure the special register scavenging spill slot is closest to the 442 // stack pointer. 443 if (RS && !RegInfo->hasFP(Fn)) { 444 int SFI = RS->getScavengingFrameIndex(); 445 if (SFI >= 0) 446 AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 447 } 448 449 // Round up the size to a multiple of the alignment, but only if there are 450 // calls or alloca's in the function. This ensures that any calls to 451 // subroutines have their stack frames suitable aligned. 452 // Also do this if we need runtime alignment of the stack. In this case 453 // offsets will be relative to SP not FP; round up the stack size so this 454 // works. 455 if (!RegInfo->targetHandlesStackFrameRounding() && 456 (FFI->hasCalls() || FFI->hasVarSizedObjects() || 457 (RegInfo->needsStackRealignment(Fn) && 458 FFI->getObjectIndexEnd() != 0))) { 459 // If we have reserved argument space for call sites in the function 460 // immediately on entry to the current function, count it as part of the 461 // overall stack size. 462 if (RegInfo->hasReservedCallFrame(Fn)) 463 Offset += FFI->getMaxCallFrameSize(); 464 465 unsigned AlignMask = std::max(TFI.getStackAlignment(),MaxAlign) - 1; 466 Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 467 } 468 469 // Update frame info to pretend that this is part of the stack... 470 FFI->setStackSize(Offset+TFI.getOffsetOfLocalArea()); 471 472 // Remember the required stack alignment in case targets need it to perform 473 // dynamic stack alignment. 474 FFI->setMaxAlignment(MaxAlign); 475} 476 477 478/// insertPrologEpilogCode - Scan the function for modified callee saved 479/// registers, insert spill code for these callee saved registers, then add 480/// prolog and epilog code to the function. 481/// 482void PEI::insertPrologEpilogCode(MachineFunction &Fn) { 483 const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 484 485 // Add prologue to the function... 486 TRI->emitPrologue(Fn); 487 488 // Add epilogue to restore the callee-save registers in each exiting block 489 for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) { 490 // If last instruction is a return instruction, add an epilogue 491 if (!I->empty() && I->back().getDesc().isReturn()) 492 TRI->emitEpilogue(Fn, *I); 493 } 494} 495 496 497/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical 498/// register references and actual offsets. 499/// 500void PEI::replaceFrameIndices(MachineFunction &Fn) { 501 if (!Fn.getFrameInfo()->hasStackObjects()) return; // Nothing to do? 502 503 const TargetMachine &TM = Fn.getTarget(); 504 assert(TM.getRegisterInfo() && "TM::getRegisterInfo() must be implemented!"); 505 const TargetRegisterInfo &TRI = *TM.getRegisterInfo(); 506 const TargetFrameInfo *TFI = TM.getFrameInfo(); 507 bool StackGrowsDown = 508 TFI->getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 509 int FrameSetupOpcode = TRI.getCallFrameSetupOpcode(); 510 int FrameDestroyOpcode = TRI.getCallFrameDestroyOpcode(); 511 512 for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) { 513 int SPAdj = 0; // SP offset due to call frame setup / destroy. 514 if (RS) RS->enterBasicBlock(BB); 515 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) { 516 if (I->getOpcode() == TargetInstrInfo::DECLARE) { 517 // Ignore it. 518 ++I; 519 continue; 520 } 521 522 if (I->getOpcode() == FrameSetupOpcode || 523 I->getOpcode() == FrameDestroyOpcode) { 524 // Remember how much SP has been adjusted to create the call 525 // frame. 526 int Size = I->getOperand(0).getImm(); 527 528 if ((!StackGrowsDown && I->getOpcode() == FrameSetupOpcode) || 529 (StackGrowsDown && I->getOpcode() == FrameDestroyOpcode)) 530 Size = -Size; 531 532 SPAdj += Size; 533 534 MachineBasicBlock::iterator PrevI = BB->end(); 535 if (I != BB->begin()) PrevI = prior(I); 536 TRI.eliminateCallFramePseudoInstr(Fn, *BB, I); 537 538 // Visit the instructions created by eliminateCallFramePseudoInstr(). 539 if (PrevI == BB->end()) 540 I = BB->begin(); // The replaced instr was the first in the block. 541 else 542 I = next(PrevI); 543 continue; 544 } 545 546 MachineInstr *MI = I; 547 bool DoIncr = true; 548 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 549 if (MI->getOperand(i).isFI()) { 550 // Some instructions (e.g. inline asm instructions) can have 551 // multiple frame indices and/or cause eliminateFrameIndex 552 // to insert more than one instruction. We need the register 553 // scavenger to go through all of these instructions so that 554 // it can update its register information. We keep the 555 // iterator at the point before insertion so that we can 556 // revisit them in full. 557 bool AtBeginning = (I == BB->begin()); 558 if (!AtBeginning) --I; 559 560 // If this instruction has a FrameIndex operand, we need to 561 // use that target machine register info object to eliminate 562 // it. 563 TRI.eliminateFrameIndex(MI, SPAdj, RS); 564 565 // Reset the iterator if we were at the beginning of the BB. 566 if (AtBeginning) { 567 I = BB->begin(); 568 DoIncr = false; 569 } 570 571 MI = 0; 572 break; 573 } 574 575 if (DoIncr && I != BB->end()) ++I; 576 577 // Update register states. 578 if (RS && MI) RS->forward(MI); 579 } 580 581 assert(SPAdj == 0 && "Unbalanced call frame setup / destroy pairs?"); 582 } 583} 584