Don't recalculate the stack position of the stack protector.
[oota-llvm.git] / lib / CodeGen / PrologEpilogInserter.cpp
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>
33 using namespace llvm;
34
35 namespace {
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 = getAnalysisToUpdate<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 ///
118 FunctionPass *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 ///
126 void 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 ///
242 void 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
310 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
311 /// abstract stack objects.
312 ///
313 void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
314   const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo();
315
316   bool StackGrowsDown =
317     TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown;
318
319   // Loop over all of the stack objects, assigning sequential addresses...
320   MachineFrameInfo *FFI = Fn.getFrameInfo();
321
322   unsigned MaxAlign = FFI->getMaxAlignment();
323
324   // Start at the beginning of the local area.
325   // The Offset is the distance from the stack top in the direction
326   // of stack growth -- so it's always nonnegative.
327   int64_t Offset = TFI.getOffsetOfLocalArea();
328   if (StackGrowsDown)
329     Offset = -Offset;
330   assert(Offset >= 0
331          && "Local area offset should be in direction of stack growth");
332
333   // If there are fixed sized objects that are preallocated in the local area,
334   // non-fixed objects can't be allocated right at the start of local area.
335   // We currently don't support filling in holes in between fixed sized objects,
336   // so we adjust 'Offset' to point to the end of last fixed sized
337   // preallocated object.
338   for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) {
339     int64_t FixedOff;
340     if (StackGrowsDown) {
341       // The maximum distance from the stack pointer is at lower address of
342       // the object -- which is given by offset. For down growing stack
343       // the offset is negative, so we negate the offset to get the distance.
344       FixedOff = -FFI->getObjectOffset(i);
345     } else {
346       // The maximum distance from the start pointer is at the upper
347       // address of the object.
348       FixedOff = FFI->getObjectOffset(i) + FFI->getObjectSize(i);
349     }
350     if (FixedOff > Offset) Offset = FixedOff;
351   }
352
353   // First assign frame offsets to stack objects that are used to spill
354   // callee saved registers.
355   if (StackGrowsDown) {
356     for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) {
357       // If stack grows down, we need to add size of find the lowest
358       // address of the object.
359       Offset += FFI->getObjectSize(i);
360
361       unsigned Align = FFI->getObjectAlignment(i);
362       // If the alignment of this object is greater than that of the stack, then
363       // increase the stack alignment to match.
364       MaxAlign = std::max(MaxAlign, Align);
365       // Adjust to alignment boundary
366       Offset = (Offset+Align-1)/Align*Align;
367
368       FFI->setObjectOffset(i, -Offset);        // Set the computed offset
369     }
370   } else {
371     int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex;
372     for (int i = MaxCSFI; i >= MinCSFI ; --i) {
373       unsigned Align = FFI->getObjectAlignment(i);
374       // If the alignment of this object is greater than that of the stack, then
375       // increase the stack alignment to match.
376       MaxAlign = std::max(MaxAlign, Align);
377       // Adjust to alignment boundary
378       Offset = (Offset+Align-1)/Align*Align;
379
380       FFI->setObjectOffset(i, Offset);
381       Offset += FFI->getObjectSize(i);
382     }
383   }
384
385   // Make sure the special register scavenging spill slot is closest to the
386   // frame pointer if a frame pointer is required.
387   const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo();
388   if (RS && RegInfo->hasFP(Fn)) {
389     int SFI = RS->getScavengingFrameIndex();
390     if (SFI >= 0) {
391       // If stack grows down, we need to add size of the lowest
392       // address of the object.
393       if (StackGrowsDown)
394         Offset += FFI->getObjectSize(SFI);
395
396       unsigned Align = FFI->getObjectAlignment(SFI);
397       // Adjust to alignment boundary
398       Offset = (Offset+Align-1)/Align*Align;
399
400       if (StackGrowsDown) {
401         FFI->setObjectOffset(SFI, -Offset);        // Set the computed offset
402       } else {
403         FFI->setObjectOffset(SFI, Offset);
404         Offset += FFI->getObjectSize(SFI);
405       }
406     }
407   }
408
409   // Make sure that the stack protector comes before the local variables on the
410   // stack.
411   if (FFI->getStackProtectorIndex() >= 0) {
412     int FI = FFI->getStackProtectorIndex();
413
414     // If stack grows down, we need to add size of find the lowest
415     // address of the object.
416     if (StackGrowsDown)
417       Offset += FFI->getObjectSize(FI);
418
419     unsigned Align = FFI->getObjectAlignment(FI);
420
421     // If the alignment of this object is greater than that of the stack, then
422     // increase the stack alignment to match.
423     MaxAlign = std::max(MaxAlign, Align);
424
425     // Adjust to alignment boundary.
426     Offset = (Offset + Align - 1) / Align * Align;
427
428     if (StackGrowsDown) {
429       FFI->setObjectOffset(FI, -Offset); // Set the computed offset
430     } else {
431       FFI->setObjectOffset(FI, Offset);
432       Offset += FFI->getObjectSize(FI);
433     }
434   }
435
436   // Then assign frame offsets to stack objects that are not used to spill
437   // callee saved registers.
438   for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) {
439     if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
440       continue;
441     if (RS && (int)i == RS->getScavengingFrameIndex())
442       continue;
443     if (FFI->isDeadObjectIndex(i))
444       continue;
445     if (FFI->getStackProtectorIndex() == (int)i)
446       continue;
447
448     // If stack grows down, we need to add size of find the lowest
449     // address of the object.
450     if (StackGrowsDown)
451       Offset += FFI->getObjectSize(i);
452
453     unsigned Align = FFI->getObjectAlignment(i);
454     // If the alignment of this object is greater than that of the stack, then
455     // increase the stack alignment to match.
456     MaxAlign = std::max(MaxAlign, Align);
457     // Adjust to alignment boundary
458     Offset = (Offset+Align-1)/Align*Align;
459
460     if (StackGrowsDown) {
461       FFI->setObjectOffset(i, -Offset);        // Set the computed offset
462     } else {
463       FFI->setObjectOffset(i, Offset);
464       Offset += FFI->getObjectSize(i);
465     }
466   }
467
468   // Make sure the special register scavenging spill slot is closest to the
469   // stack pointer.
470   if (RS && !RegInfo->hasFP(Fn)) {
471     int SFI = RS->getScavengingFrameIndex();
472     if (SFI >= 0) {
473       // If stack grows down, we need to add size of find the lowest
474       // address of the object.
475       if (StackGrowsDown)
476         Offset += FFI->getObjectSize(SFI);
477
478       unsigned Align = FFI->getObjectAlignment(SFI);
479       // If the alignment of this object is greater than that of the
480       // stack, then increase the stack alignment to match.
481       MaxAlign = std::max(MaxAlign, Align);
482       // Adjust to alignment boundary
483       Offset = (Offset+Align-1)/Align*Align;
484
485       if (StackGrowsDown) {
486         FFI->setObjectOffset(SFI, -Offset);        // Set the computed offset
487       } else {
488         FFI->setObjectOffset(SFI, Offset);
489         Offset += FFI->getObjectSize(SFI);
490       }
491     }
492   }
493
494   // Round up the size to a multiple of the alignment, but only if there are
495   // calls or alloca's in the function.  This ensures that any calls to
496   // subroutines have their stack frames suitable aligned.
497   // Also do this if we need runtime alignment of the stack.  In this case
498   // offsets will be relative to SP not FP; round up the stack size so this
499   // works.
500   if (!RegInfo->targetHandlesStackFrameRounding() &&
501       (FFI->hasCalls() || FFI->hasVarSizedObjects() || 
502        (RegInfo->needsStackRealignment(Fn) &&
503         FFI->getObjectIndexEnd() != 0))) {
504     // If we have reserved argument space for call sites in the function
505     // immediately on entry to the current function, count it as part of the
506     // overall stack size.
507     if (RegInfo->hasReservedCallFrame(Fn))
508       Offset += FFI->getMaxCallFrameSize();
509
510     unsigned AlignMask = std::max(TFI.getStackAlignment(),MaxAlign) - 1;
511     Offset = (Offset + AlignMask) & ~uint64_t(AlignMask);
512   }
513
514   // Update frame info to pretend that this is part of the stack...
515   FFI->setStackSize(Offset+TFI.getOffsetOfLocalArea());
516
517   // Remember the required stack alignment in case targets need it to perform
518   // dynamic stack alignment.
519   FFI->setMaxAlignment(MaxAlign);
520 }
521
522
523 /// insertPrologEpilogCode - Scan the function for modified callee saved
524 /// registers, insert spill code for these callee saved registers, then add
525 /// prolog and epilog code to the function.
526 ///
527 void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
528   const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo();
529
530   // Add prologue to the function...
531   TRI->emitPrologue(Fn);
532
533   // Add epilogue to restore the callee-save registers in each exiting block
534   for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) {
535     // If last instruction is a return instruction, add an epilogue
536     if (!I->empty() && I->back().getDesc().isReturn())
537       TRI->emitEpilogue(Fn, *I);
538   }
539 }
540
541
542 /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
543 /// register references and actual offsets.
544 ///
545 void PEI::replaceFrameIndices(MachineFunction &Fn) {
546   if (!Fn.getFrameInfo()->hasStackObjects()) return; // Nothing to do?
547
548   const TargetMachine &TM = Fn.getTarget();
549   assert(TM.getRegisterInfo() && "TM::getRegisterInfo() must be implemented!");
550   const TargetRegisterInfo &TRI = *TM.getRegisterInfo();
551   const TargetFrameInfo *TFI = TM.getFrameInfo();
552   bool StackGrowsDown =
553     TFI->getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown;
554   int FrameSetupOpcode   = TRI.getCallFrameSetupOpcode();
555   int FrameDestroyOpcode = TRI.getCallFrameDestroyOpcode();
556
557   for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) {
558     int SPAdj = 0;  // SP offset due to call frame setup / destroy.
559     if (RS) RS->enterBasicBlock(BB);
560     for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
561       MachineInstr *MI = I;
562
563       if (I->getOpcode() == TargetInstrInfo::DECLARE) {
564         // Ignore it.
565         ++I;
566         continue;
567       }
568
569       if (I->getOpcode() == FrameSetupOpcode ||
570           I->getOpcode() == FrameDestroyOpcode) {
571         // Remember how much SP has been adjusted to create the call
572         // frame.
573         int Size = I->getOperand(0).getImm();
574
575         if ((!StackGrowsDown && I->getOpcode() == FrameSetupOpcode) ||
576             (StackGrowsDown && I->getOpcode() == FrameDestroyOpcode))
577           Size = -Size;
578
579         SPAdj += Size;
580
581         MachineBasicBlock::iterator PrevI = prior(I);
582         TRI.eliminateCallFramePseudoInstr(Fn, *BB, I);
583
584         // Visit the instructions created by eliminateCallFramePseudoInstr().
585         I = next(PrevI);
586         continue;
587       }
588
589       bool DoIncr = true;
590
591       for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i)
592         if (MI->getOperand(i).isFI()) {
593           // Some instructions (e.g. inline asm instructions) can have
594           // multiple frame indices and/or cause eliminateFrameIndex
595           // to insert more than one instruction. We need the register
596           // scavenger to go through all of these instructions so that
597           // it can update its register information. We keep the
598           // iterator at the point before insertion so that we can
599           // revisit them in full.
600           bool AtBeginning = (I == BB->begin());
601           if (!AtBeginning) --I;
602
603           // If this instruction has a FrameIndex operand, we need to
604           // use that target machine register info object to eliminate
605           // it.
606           TRI.eliminateFrameIndex(MI, SPAdj, RS);
607
608           // Reset the iterator if we were at the beginning of the BB.
609           if (AtBeginning) {
610             I = BB->begin();
611             DoIncr = false;
612           }
613
614           MI = 0;
615           break;
616         }
617
618       if (DoIncr) ++I;
619
620       // Update register states.
621       if (RS && MI) RS->forward(MI);
622     }
623
624     assert(SPAdj == 0 && "Unbalanced call frame setup / destroy pairs?");
625   }
626 }