LLVM  4.0.0
PrologEpilogInserter.cpp
Go to the documentation of this file.
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/ADT/STLExtras.h"
20 #include "llvm/ADT/SetVector.h"
21 #include "llvm/ADT/SmallSet.h"
22 #include "llvm/ADT/Statistic.h"
29 #include "llvm/CodeGen/Passes.h"
33 #include "llvm/IR/DiagnosticInfo.h"
34 #include "llvm/IR/InlineAsm.h"
35 #include "llvm/IR/LLVMContext.h"
37 #include "llvm/Support/Debug.h"
44 #include <climits>
45 
46 using namespace llvm;
47 
48 #define DEBUG_TYPE "pei"
49 
52  unsigned &MinCSFrameIndex,
53  unsigned &MaxCXFrameIndex,
54  const MBBVector &SaveBlocks,
55  const MBBVector &RestoreBlocks);
56 
58 
59 namespace {
60 class PEI : public MachineFunctionPass {
61 public:
62  static char ID;
63  explicit PEI(const TargetMachine *TM = nullptr) : MachineFunctionPass(ID) {
65 
66  if (TM && (!TM->usesPhysRegsForPEI())) {
67  SpillCalleeSavedRegisters = [](MachineFunction &, RegScavenger *,
68  unsigned &, unsigned &, const MBBVector &,
69  const MBBVector &) {};
70  ScavengeFrameVirtualRegs = [](MachineFunction &, RegScavenger *) {};
71  } else {
72  SpillCalleeSavedRegisters = doSpillCalleeSavedRegs;
73  ScavengeFrameVirtualRegs = doScavengeFrameVirtualRegs;
74  UsesCalleeSaves = true;
75  }
76  }
77 
78  void getAnalysisUsage(AnalysisUsage &AU) const override;
79 
80  MachineFunctionProperties getRequiredProperties() const override {
82  if (UsesCalleeSaves)
84  return MFP;
85  }
86 
87  /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
88  /// frame indexes with appropriate references.
89  ///
90  bool runOnMachineFunction(MachineFunction &Fn) override;
91 
92 private:
94  unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex,
95  const MBBVector &SaveBlocks,
96  const MBBVector &RestoreBlocks)>
97  SpillCalleeSavedRegisters;
98  std::function<void(MachineFunction &MF, RegScavenger *RS)>
99  ScavengeFrameVirtualRegs;
100 
101  bool UsesCalleeSaves = false;
102 
103  RegScavenger *RS;
104 
105  // MinCSFrameIndex, MaxCSFrameIndex - Keeps the range of callee saved
106  // stack frame indexes.
107  unsigned MinCSFrameIndex = std::numeric_limits<unsigned>::max();
108  unsigned MaxCSFrameIndex = 0;
109 
110  // Save and Restore blocks of the current function. Typically there is a
111  // single save block, unless Windows EH funclets are involved.
112  MBBVector SaveBlocks;
113  MBBVector RestoreBlocks;
114 
115  // Flag to control whether to use the register scavenger to resolve
116  // frame index materialization registers. Set according to
117  // TRI->requiresFrameIndexScavenging() for the current function.
118  bool FrameIndexVirtualScavenging;
119 
120  // Flag to control whether the scavenger should be passed even though
121  // FrameIndexVirtualScavenging is used.
122  bool FrameIndexEliminationScavenging;
123 
124  void calculateCallFrameInfo(MachineFunction &Fn);
125  void calculateSaveRestoreBlocks(MachineFunction &Fn);
126 
127  void calculateFrameObjectOffsets(MachineFunction &Fn);
128  void replaceFrameIndices(MachineFunction &Fn);
129  void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &Fn,
130  int &SPAdj);
131  void insertPrologEpilogCode(MachineFunction &Fn);
132 };
133 } // namespace
134 
135 char PEI::ID = 0;
137 
138 static cl::opt<unsigned>
139 WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1),
140  cl::desc("Warn for stack size bigger than the given"
141  " number"));
142 
143 INITIALIZE_TM_PASS_BEGIN(PEI, "prologepilog", "Prologue/Epilogue Insertion",
144  false, false)
149  "Prologue/Epilogue Insertion & Frame Finalization",
150  false, false)
151 
154  return new PEI(TM);
155 }
156 
157 STATISTIC(NumScavengedRegs, "Number of frame index regs scavenged");
158 STATISTIC(NumBytesStackSpace,
159  "Number of bytes used for stack in all functions");
160 
161 void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
162  AU.setPreservesCFG();
167 }
168 
169 
170 /// StackObjSet - A set of stack object indexes
172 
173 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
174 /// frame indexes with appropriate references.
175 ///
176 bool PEI::runOnMachineFunction(MachineFunction &Fn) {
177  const Function* F = Fn.getFunction();
178  const TargetRegisterInfo *TRI = Fn.getSubtarget().getRegisterInfo();
180 
181  RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : nullptr;
182  FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(Fn);
183  FrameIndexEliminationScavenging = (RS && !FrameIndexVirtualScavenging) ||
185 
186  // Calculate the MaxCallFrameSize and AdjustsStack variables for the
187  // function's frame information. Also eliminates call frame pseudo
188  // instructions.
189  calculateCallFrameInfo(Fn);
190 
191  // Determine placement of CSR spill/restore code and prolog/epilog code:
192  // place all spills in the entry block, all restores in return blocks.
193  calculateSaveRestoreBlocks(Fn);
194 
195  // Handle CSR spilling and restoring, for targets that need it.
196  SpillCalleeSavedRegisters(Fn, RS, MinCSFrameIndex, MaxCSFrameIndex,
197  SaveBlocks, RestoreBlocks);
198 
199  // Allow the target machine to make final modifications to the function
200  // before the frame layout is finalized.
202 
203  // Calculate actual frame offsets for all abstract stack objects...
204  calculateFrameObjectOffsets(Fn);
205 
206  // Add prolog and epilog code to the function. This function is required
207  // to align the stack frame as necessary for any stack variables or
208  // called functions. Because of this, calculateCalleeSavedRegisters()
209  // must be called before this function in order to set the AdjustsStack
210  // and MaxCallFrameSize variables.
211  if (!F->hasFnAttribute(Attribute::Naked))
212  insertPrologEpilogCode(Fn);
213 
214  // Replace all MO_FrameIndex operands with physical register references
215  // and actual offsets.
216  //
217  replaceFrameIndices(Fn);
218 
219  // If register scavenging is needed, as we've enabled doing it as a
220  // post-pass, scavenge the virtual registers that frame index elimination
221  // inserted.
222  if (TRI->requiresRegisterScavenging(Fn) && FrameIndexVirtualScavenging) {
223  ScavengeFrameVirtualRegs(Fn, RS);
224 
225  // Clear any vregs created by virtual scavenging.
226  Fn.getRegInfo().clearVirtRegs();
227  }
228 
229  // Warn on stack size when we exceeds the given limit.
230  MachineFrameInfo &MFI = Fn.getFrameInfo();
231  uint64_t StackSize = MFI.getStackSize();
232  if (WarnStackSize.getNumOccurrences() > 0 && WarnStackSize < StackSize) {
233  DiagnosticInfoStackSize DiagStackSize(*F, StackSize);
234  F->getContext().diagnose(DiagStackSize);
235  }
236 
237  delete RS;
238  SaveBlocks.clear();
239  RestoreBlocks.clear();
240  MFI.setSavePoint(nullptr);
241  MFI.setRestorePoint(nullptr);
242  return true;
243 }
244 
245 /// Calculate the MaxCallFrameSize and AdjustsStack
246 /// variables for the function's frame information and eliminate call frame
247 /// pseudo instructions.
248 void PEI::calculateCallFrameInfo(MachineFunction &Fn) {
249  const TargetInstrInfo &TII = *Fn.getSubtarget().getInstrInfo();
251  MachineFrameInfo &MFI = Fn.getFrameInfo();
252 
253  unsigned MaxCallFrameSize = 0;
254  bool AdjustsStack = MFI.adjustsStack();
255 
256  // Get the function call frame set-up and tear-down instruction opcode
257  unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
258  unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
259 
260  // Early exit for targets which have no call frame setup/destroy pseudo
261  // instructions.
262  if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)
263  return;
264 
265  std::vector<MachineBasicBlock::iterator> FrameSDOps;
266  for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB)
267  for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I)
268  if (I->getOpcode() == FrameSetupOpcode ||
269  I->getOpcode() == FrameDestroyOpcode) {
270  assert(I->getNumOperands() >= 1 && "Call Frame Setup/Destroy Pseudo"
271  " instructions should have a single immediate argument!");
272  unsigned Size = I->getOperand(0).getImm();
273  if (Size > MaxCallFrameSize) MaxCallFrameSize = Size;
274  AdjustsStack = true;
275  FrameSDOps.push_back(I);
276  } else if (I->isInlineAsm()) {
277  // Some inline asm's need a stack frame, as indicated by operand 1.
278  unsigned ExtraInfo = I->getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
279  if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
280  AdjustsStack = true;
281  }
282 
283  MFI.setAdjustsStack(AdjustsStack);
284  MFI.setMaxCallFrameSize(MaxCallFrameSize);
285 
286  for (std::vector<MachineBasicBlock::iterator>::iterator
287  i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) {
289 
290  // If call frames are not being included as part of the stack frame, and
291  // the target doesn't indicate otherwise, remove the call frame pseudos
292  // here. The sub/add sp instruction pairs are still inserted, but we don't
293  // need to track the SP adjustment for frame index elimination.
294  if (TFI->canSimplifyCallFramePseudos(Fn))
295  TFI->eliminateCallFramePseudoInstr(Fn, *I->getParent(), I);
296  }
297 }
298 
299 /// Compute the sets of entry and return blocks for saving and restoring
300 /// callee-saved registers, and placing prolog and epilog code.
301 void PEI::calculateSaveRestoreBlocks(MachineFunction &Fn) {
302  const MachineFrameInfo &MFI = Fn.getFrameInfo();
303 
304  // Even when we do not change any CSR, we still want to insert the
305  // prologue and epilogue of the function.
306  // So set the save points for those.
307 
308  // Use the points found by shrink-wrapping, if any.
309  if (MFI.getSavePoint()) {
310  SaveBlocks.push_back(MFI.getSavePoint());
311  assert(MFI.getRestorePoint() && "Both restore and save must be set");
312  MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
313  // If RestoreBlock does not have any successor and is not a return block
314  // then the end point is unreachable and we do not need to insert any
315  // epilogue.
316  if (!RestoreBlock->succ_empty() || RestoreBlock->isReturnBlock())
317  RestoreBlocks.push_back(RestoreBlock);
318  return;
319  }
320 
321  // Save refs to entry and return blocks.
322  SaveBlocks.push_back(&Fn.front());
323  for (MachineBasicBlock &MBB : Fn) {
324  if (MBB.isEHFuncletEntry())
325  SaveBlocks.push_back(&MBB);
326  if (MBB.isReturnBlock())
327  RestoreBlocks.push_back(&MBB);
328  }
329 }
330 
332  const BitVector &SavedRegs,
333  unsigned &MinCSFrameIndex,
334  unsigned &MaxCSFrameIndex) {
335  if (SavedRegs.empty())
336  return;
337 
338  const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
339  const MCPhysReg *CSRegs = RegInfo->getCalleeSavedRegs(&F);
340 
341  std::vector<CalleeSavedInfo> CSI;
342  for (unsigned i = 0; CSRegs[i]; ++i) {
343  unsigned Reg = CSRegs[i];
344  if (SavedRegs.test(Reg))
345  CSI.push_back(CalleeSavedInfo(Reg));
346  }
347 
349  MachineFrameInfo &MFI = F.getFrameInfo();
350  if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI)) {
351  // If target doesn't implement this, use generic code.
352 
353  if (CSI.empty())
354  return; // Early exit if no callee saved registers are modified!
355 
356  unsigned NumFixedSpillSlots;
357  const TargetFrameLowering::SpillSlot *FixedSpillSlots =
358  TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
359 
360  // Now that we know which registers need to be saved and restored, allocate
361  // stack slots for them.
362  for (auto &CS : CSI) {
363  unsigned Reg = CS.getReg();
364  const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
365 
366  int FrameIdx;
367  if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {
368  CS.setFrameIdx(FrameIdx);
369  continue;
370  }
371 
372  // Check to see if this physreg must be spilled to a particular stack slot
373  // on this target.
374  const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
375  while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
376  FixedSlot->Reg != Reg)
377  ++FixedSlot;
378 
379  if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
380  // Nope, just spill it anywhere convenient.
381  unsigned Align = RC->getAlignment();
382  unsigned StackAlign = TFI->getStackAlignment();
383 
384  // We may not be able to satisfy the desired alignment specification of
385  // the TargetRegisterClass if the stack alignment is smaller. Use the
386  // min.
387  Align = std::min(Align, StackAlign);
388  FrameIdx = MFI.CreateStackObject(RC->getSize(), Align, true);
389  if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
390  if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
391  } else {
392  // Spill it to the stack where we must.
393  FrameIdx =
394  MFI.CreateFixedSpillStackObject(RC->getSize(), FixedSlot->Offset);
395  }
396 
397  CS.setFrameIdx(FrameIdx);
398  }
399  }
400 
401  MFI.setCalleeSavedInfo(CSI);
402 }
403 
404 /// Helper function to update the liveness information for the callee-saved
405 /// registers.
406 static void updateLiveness(MachineFunction &MF) {
407  MachineFrameInfo &MFI = MF.getFrameInfo();
408  // Visited will contain all the basic blocks that are in the region
409  // where the callee saved registers are alive:
410  // - Anything that is not Save or Restore -> LiveThrough.
411  // - Save -> LiveIn.
412  // - Restore -> LiveOut.
413  // The live-out is not attached to the block, so no need to keep
414  // Restore in this set.
417  MachineBasicBlock *Entry = &MF.front();
418  MachineBasicBlock *Save = MFI.getSavePoint();
419 
420  if (!Save)
421  Save = Entry;
422 
423  if (Entry != Save) {
424  WorkList.push_back(Entry);
425  Visited.insert(Entry);
426  }
427  Visited.insert(Save);
428 
429  MachineBasicBlock *Restore = MFI.getRestorePoint();
430  if (Restore)
431  // By construction Restore cannot be visited, otherwise it
432  // means there exists a path to Restore that does not go
433  // through Save.
434  WorkList.push_back(Restore);
435 
436  while (!WorkList.empty()) {
437  const MachineBasicBlock *CurBB = WorkList.pop_back_val();
438  // By construction, the region that is after the save point is
439  // dominated by the Save and post-dominated by the Restore.
440  if (CurBB == Save && Save != Restore)
441  continue;
442  // Enqueue all the successors not already visited.
443  // Those are by construction either before Save or after Restore.
444  for (MachineBasicBlock *SuccBB : CurBB->successors())
445  if (Visited.insert(SuccBB).second)
446  WorkList.push_back(SuccBB);
447  }
448 
449  const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
450 
451  for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
452  for (MachineBasicBlock *MBB : Visited) {
453  MCPhysReg Reg = CSI[i].getReg();
454  // Add the callee-saved register as live-in.
455  // It's killed at the spill.
456  if (!MBB->isLiveIn(Reg))
457  MBB->addLiveIn(Reg);
458  }
459  }
460 }
461 
462 /// insertCSRSpillsAndRestores - Insert spill and restore code for
463 /// callee saved registers used in the function.
464 ///
466  const MBBVector &SaveBlocks,
467  const MBBVector &RestoreBlocks) {
468  // Get callee saved register information.
469  MachineFrameInfo &MFI = Fn.getFrameInfo();
470  const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
471 
472  MFI.setCalleeSavedInfoValid(true);
473 
474  // Early exit if no callee saved registers are modified!
475  if (CSI.empty())
476  return;
477 
478  const TargetInstrInfo &TII = *Fn.getSubtarget().getInstrInfo();
480  const TargetRegisterInfo *TRI = Fn.getSubtarget().getRegisterInfo();
482 
483  // Spill using target interface.
484  for (MachineBasicBlock *SaveBlock : SaveBlocks) {
485  I = SaveBlock->begin();
486  if (!TFI->spillCalleeSavedRegisters(*SaveBlock, I, CSI, TRI)) {
487  for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
488  // Insert the spill to the stack frame.
489  unsigned Reg = CSI[i].getReg();
490  const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
491  TII.storeRegToStackSlot(*SaveBlock, I, Reg, true, CSI[i].getFrameIdx(),
492  RC, TRI);
493  }
494  }
495  // Update the live-in information of all the blocks up to the save point.
496  updateLiveness(Fn);
497  }
498 
499  // Restore using target interface.
500  for (MachineBasicBlock *MBB : RestoreBlocks) {
501  I = MBB->end();
502 
503  // Skip over all terminator instructions, which are part of the return
504  // sequence.
506  while (I2 != MBB->begin() && (--I2)->isTerminator())
507  I = I2;
508 
509  bool AtStart = I == MBB->begin();
510  MachineBasicBlock::iterator BeforeI = I;
511  if (!AtStart)
512  --BeforeI;
513 
514  // Restore all registers immediately before the return and any
515  // terminators that precede it.
516  if (!TFI->restoreCalleeSavedRegisters(*MBB, I, CSI, TRI)) {
517  for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
518  unsigned Reg = CSI[i].getReg();
519  const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
520  TII.loadRegFromStackSlot(*MBB, I, Reg, CSI[i].getFrameIdx(), RC, TRI);
521  assert(I != MBB->begin() &&
522  "loadRegFromStackSlot didn't insert any code!");
523  // Insert in reverse order. loadRegFromStackSlot can insert
524  // multiple instructions.
525  if (AtStart)
526  I = MBB->begin();
527  else {
528  I = BeforeI;
529  ++I;
530  }
531  }
532  }
533  }
534 }
535 
537  unsigned &MinCSFrameIndex,
538  unsigned &MaxCSFrameIndex,
539  const MBBVector &SaveBlocks,
540  const MBBVector &RestoreBlocks) {
541  const Function *F = Fn.getFunction();
543  MinCSFrameIndex = std::numeric_limits<unsigned>::max();
544  MaxCSFrameIndex = 0;
545 
546  // Determine which of the registers in the callee save list should be saved.
547  BitVector SavedRegs;
548  TFI->determineCalleeSaves(Fn, SavedRegs, RS);
549 
550  // Assign stack slots for any callee-saved registers that must be spilled.
551  assignCalleeSavedSpillSlots(Fn, SavedRegs, MinCSFrameIndex, MaxCSFrameIndex);
552 
553  // Add the code to save and restore the callee saved registers.
554  if (!F->hasFnAttribute(Attribute::Naked))
555  insertCSRSpillsAndRestores(Fn, SaveBlocks, RestoreBlocks);
556 }
557 
558 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
559 static inline void
561  bool StackGrowsDown, int64_t &Offset,
562  unsigned &MaxAlign, unsigned Skew) {
563  // If the stack grows down, add the object size to find the lowest address.
564  if (StackGrowsDown)
565  Offset += MFI.getObjectSize(FrameIdx);
566 
567  unsigned Align = MFI.getObjectAlignment(FrameIdx);
568 
569  // If the alignment of this object is greater than that of the stack, then
570  // increase the stack alignment to match.
571  MaxAlign = std::max(MaxAlign, Align);
572 
573  // Adjust to alignment boundary.
574  Offset = alignTo(Offset, Align, Skew);
575 
576  if (StackGrowsDown) {
577  DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset << "]\n");
578  MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
579  } else {
580  DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset << "]\n");
581  MFI.setObjectOffset(FrameIdx, Offset);
582  Offset += MFI.getObjectSize(FrameIdx);
583  }
584 }
585 
586 /// Compute which bytes of fixed and callee-save stack area are unused and keep
587 /// track of them in StackBytesFree.
588 ///
589 static inline void
590 computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown,
591  unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex,
592  int64_t FixedCSEnd, BitVector &StackBytesFree) {
593  // Avoid undefined int64_t -> int conversion below in extreme case.
594  if (FixedCSEnd > std::numeric_limits<int>::max())
595  return;
596 
597  StackBytesFree.resize(FixedCSEnd, true);
598 
599  SmallVector<int, 16> AllocatedFrameSlots;
600  // Add fixed objects.
601  for (int i = MFI.getObjectIndexBegin(); i != 0; ++i)
602  AllocatedFrameSlots.push_back(i);
603  // Add callee-save objects.
604  for (int i = MinCSFrameIndex; i <= (int)MaxCSFrameIndex; ++i)
605  AllocatedFrameSlots.push_back(i);
606 
607  for (int i : AllocatedFrameSlots) {
608  // These are converted from int64_t, but they should always fit in int
609  // because of the FixedCSEnd check above.
610  int ObjOffset = MFI.getObjectOffset(i);
611  int ObjSize = MFI.getObjectSize(i);
612  int ObjStart, ObjEnd;
613  if (StackGrowsDown) {
614  // ObjOffset is negative when StackGrowsDown is true.
615  ObjStart = -ObjOffset - ObjSize;
616  ObjEnd = -ObjOffset;
617  } else {
618  ObjStart = ObjOffset;
619  ObjEnd = ObjOffset + ObjSize;
620  }
621  // Ignore fixed holes that are in the previous stack frame.
622  if (ObjEnd > 0)
623  StackBytesFree.reset(ObjStart, ObjEnd);
624  }
625 }
626 
627 /// Assign frame object to an unused portion of the stack in the fixed stack
628 /// object range. Return true if the allocation was successful.
629 ///
630 static inline bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx,
631  bool StackGrowsDown, unsigned MaxAlign,
632  BitVector &StackBytesFree) {
633  if (MFI.isVariableSizedObjectIndex(FrameIdx))
634  return false;
635 
636  if (StackBytesFree.none()) {
637  // clear it to speed up later scavengeStackSlot calls to
638  // StackBytesFree.none()
639  StackBytesFree.clear();
640  return false;
641  }
642 
643  unsigned ObjAlign = MFI.getObjectAlignment(FrameIdx);
644  if (ObjAlign > MaxAlign)
645  return false;
646 
647  int64_t ObjSize = MFI.getObjectSize(FrameIdx);
648  int FreeStart;
649  for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;
650  FreeStart = StackBytesFree.find_next(FreeStart)) {
651 
652  // Check that free space has suitable alignment.
653  unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;
654  if (alignTo(ObjStart, ObjAlign) != ObjStart)
655  continue;
656 
657  if (FreeStart + ObjSize > StackBytesFree.size())
658  return false;
659 
660  bool AllBytesFree = true;
661  for (unsigned Byte = 0; Byte < ObjSize; ++Byte)
662  if (!StackBytesFree.test(FreeStart + Byte)) {
663  AllBytesFree = false;
664  break;
665  }
666  if (AllBytesFree)
667  break;
668  }
669 
670  if (FreeStart == -1)
671  return false;
672 
673  if (StackGrowsDown) {
674  int ObjStart = -(FreeStart + ObjSize);
675  DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP[" << ObjStart
676  << "]\n");
677  MFI.setObjectOffset(FrameIdx, ObjStart);
678  } else {
679  DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP[" << FreeStart
680  << "]\n");
681  MFI.setObjectOffset(FrameIdx, FreeStart);
682  }
683 
684  StackBytesFree.reset(FreeStart, FreeStart + ObjSize);
685  return true;
686 }
687 
688 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
689 /// those required to be close to the Stack Protector) to stack offsets.
690 static void
691 AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
692  SmallSet<int, 16> &ProtectedObjs,
693  MachineFrameInfo &MFI, bool StackGrowsDown,
694  int64_t &Offset, unsigned &MaxAlign, unsigned Skew) {
695 
696  for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
697  E = UnassignedObjs.end(); I != E; ++I) {
698  int i = *I;
699  AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign, Skew);
700  ProtectedObjs.insert(i);
701  }
702 }
703 
704 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
705 /// abstract stack objects.
706 ///
707 void PEI::calculateFrameObjectOffsets(MachineFunction &Fn) {
709  StackProtector *SP = &getAnalysis<StackProtector>();
710 
711  bool StackGrowsDown =
713 
714  // Loop over all of the stack objects, assigning sequential addresses...
715  MachineFrameInfo &MFI = Fn.getFrameInfo();
716 
717  // Start at the beginning of the local area.
718  // The Offset is the distance from the stack top in the direction
719  // of stack growth -- so it's always nonnegative.
720  int LocalAreaOffset = TFI.getOffsetOfLocalArea();
721  if (StackGrowsDown)
722  LocalAreaOffset = -LocalAreaOffset;
723  assert(LocalAreaOffset >= 0
724  && "Local area offset should be in direction of stack growth");
725  int64_t Offset = LocalAreaOffset;
726 
727  // Skew to be applied to alignment.
728  unsigned Skew = TFI.getStackAlignmentSkew(Fn);
729 
730  // If there are fixed sized objects that are preallocated in the local area,
731  // non-fixed objects can't be allocated right at the start of local area.
732  // Adjust 'Offset' to point to the end of last fixed sized preallocated
733  // object.
734  for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
735  int64_t FixedOff;
736  if (StackGrowsDown) {
737  // The maximum distance from the stack pointer is at lower address of
738  // the object -- which is given by offset. For down growing stack
739  // the offset is negative, so we negate the offset to get the distance.
740  FixedOff = -MFI.getObjectOffset(i);
741  } else {
742  // The maximum distance from the start pointer is at the upper
743  // address of the object.
744  FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
745  }
746  if (FixedOff > Offset) Offset = FixedOff;
747  }
748 
749  // First assign frame offsets to stack objects that are used to spill
750  // callee saved registers.
751  if (StackGrowsDown) {
752  for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) {
753  // If the stack grows down, we need to add the size to find the lowest
754  // address of the object.
755  Offset += MFI.getObjectSize(i);
756 
757  unsigned Align = MFI.getObjectAlignment(i);
758  // Adjust to alignment boundary
759  Offset = alignTo(Offset, Align, Skew);
760 
761  DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << -Offset << "]\n");
762  MFI.setObjectOffset(i, -Offset); // Set the computed offset
763  }
764  } else if (MaxCSFrameIndex >= MinCSFrameIndex) {
765  // Be careful about underflow in comparisons agains MinCSFrameIndex.
766  for (unsigned i = MaxCSFrameIndex; i != MinCSFrameIndex - 1; --i) {
767  unsigned Align = MFI.getObjectAlignment(i);
768  // Adjust to alignment boundary
769  Offset = alignTo(Offset, Align, Skew);
770 
771  DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << Offset << "]\n");
772  MFI.setObjectOffset(i, Offset);
773  Offset += MFI.getObjectSize(i);
774  }
775  }
776 
777  // FixedCSEnd is the stack offset to the end of the fixed and callee-save
778  // stack area.
779  int64_t FixedCSEnd = Offset;
780  unsigned MaxAlign = MFI.getMaxAlignment();
781 
782  // Make sure the special register scavenging spill slot is closest to the
783  // incoming stack pointer if a frame pointer is required and is closer
784  // to the incoming rather than the final stack pointer.
785  const TargetRegisterInfo *RegInfo = Fn.getSubtarget().getRegisterInfo();
786  bool EarlyScavengingSlots = (TFI.hasFP(Fn) &&
787  TFI.isFPCloseToIncomingSP() &&
788  RegInfo->useFPForScavengingIndex(Fn) &&
789  !RegInfo->needsStackRealignment(Fn));
790  if (RS && EarlyScavengingSlots) {
791  SmallVector<int, 2> SFIs;
792  RS->getScavengingFrameIndices(SFIs);
793  for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
794  IE = SFIs.end(); I != IE; ++I)
795  AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
796  }
797 
798  // FIXME: Once this is working, then enable flag will change to a target
799  // check for whether the frame is large enough to want to use virtual
800  // frame index registers. Functions which don't want/need this optimization
801  // will continue to use the existing code path.
803  unsigned Align = MFI.getLocalFrameMaxAlign();
804 
805  // Adjust to alignment boundary.
806  Offset = alignTo(Offset, Align, Skew);
807 
808  DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
809 
810  // Resolve offsets for objects in the local block.
811  for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
812  std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
813  int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
814  DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" <<
815  FIOffset << "]\n");
816  MFI.setObjectOffset(Entry.first, FIOffset);
817  }
818  // Allocate the local block
819  Offset += MFI.getLocalFrameSize();
820 
821  MaxAlign = std::max(Align, MaxAlign);
822  }
823 
824  // Retrieve the Exception Handler registration node.
825  int EHRegNodeFrameIndex = INT_MAX;
826  if (const WinEHFuncInfo *FuncInfo = Fn.getWinEHFuncInfo())
827  EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;
828 
829  // Make sure that the stack protector comes before the local variables on the
830  // stack.
831  SmallSet<int, 16> ProtectedObjs;
832  if (MFI.getStackProtectorIndex() >= 0) {
833  StackObjSet LargeArrayObjs;
834  StackObjSet SmallArrayObjs;
835  StackObjSet AddrOfObjs;
836 
837  AdjustStackOffset(MFI, MFI.getStackProtectorIndex(), StackGrowsDown,
838  Offset, MaxAlign, Skew);
839 
840  // Assign large stack objects first.
841  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
842  if (MFI.isObjectPreAllocated(i) &&
844  continue;
845  if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
846  continue;
847  if (RS && RS->isScavengingFrameIndex((int)i))
848  continue;
849  if (MFI.isDeadObjectIndex(i))
850  continue;
851  if (MFI.getStackProtectorIndex() == (int)i ||
852  EHRegNodeFrameIndex == (int)i)
853  continue;
854 
855  switch (SP->getSSPLayout(MFI.getObjectAllocation(i))) {
857  continue;
859  SmallArrayObjs.insert(i);
860  continue;
862  AddrOfObjs.insert(i);
863  continue;
865  LargeArrayObjs.insert(i);
866  continue;
867  }
868  llvm_unreachable("Unexpected SSPLayoutKind.");
869  }
870 
871  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
872  Offset, MaxAlign, Skew);
873  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
874  Offset, MaxAlign, Skew);
875  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
876  Offset, MaxAlign, Skew);
877  }
878 
879  SmallVector<int, 8> ObjectsToAllocate;
880 
881  // Then prepare to assign frame offsets to stack objects that are not used to
882  // spill callee saved registers.
883  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
885  continue;
886  if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
887  continue;
888  if (RS && RS->isScavengingFrameIndex((int)i))
889  continue;
890  if (MFI.isDeadObjectIndex(i))
891  continue;
892  if (MFI.getStackProtectorIndex() == (int)i ||
893  EHRegNodeFrameIndex == (int)i)
894  continue;
895  if (ProtectedObjs.count(i))
896  continue;
897 
898  // Add the objects that we need to allocate to our working set.
899  ObjectsToAllocate.push_back(i);
900  }
901 
902  // Allocate the EH registration node first if one is present.
903  if (EHRegNodeFrameIndex != INT_MAX)
904  AdjustStackOffset(MFI, EHRegNodeFrameIndex, StackGrowsDown, Offset,
905  MaxAlign, Skew);
906 
907  // Give the targets a chance to order the objects the way they like it.
908  if (Fn.getTarget().getOptLevel() != CodeGenOpt::None &&
910  TFI.orderFrameObjects(Fn, ObjectsToAllocate);
911 
912  // Keep track of which bytes in the fixed and callee-save range are used so we
913  // can use the holes when allocating later stack objects. Only do this if
914  // stack protector isn't being used and the target requests it and we're
915  // optimizing.
916  BitVector StackBytesFree;
917  if (!ObjectsToAllocate.empty() &&
920  computeFreeStackSlots(MFI, StackGrowsDown, MinCSFrameIndex, MaxCSFrameIndex,
921  FixedCSEnd, StackBytesFree);
922 
923  // Now walk the objects and actually assign base offsets to them.
924  for (auto &Object : ObjectsToAllocate)
925  if (!scavengeStackSlot(MFI, Object, StackGrowsDown, MaxAlign,
926  StackBytesFree))
927  AdjustStackOffset(MFI, Object, StackGrowsDown, Offset, MaxAlign, Skew);
928 
929  // Make sure the special register scavenging spill slot is closest to the
930  // stack pointer.
931  if (RS && !EarlyScavengingSlots) {
932  SmallVector<int, 2> SFIs;
933  RS->getScavengingFrameIndices(SFIs);
934  for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
935  IE = SFIs.end(); I != IE; ++I)
936  AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
937  }
938 
939  if (!TFI.targetHandlesStackFrameRounding()) {
940  // If we have reserved argument space for call sites in the function
941  // immediately on entry to the current function, count it as part of the
942  // overall stack size.
943  if (MFI.adjustsStack() && TFI.hasReservedCallFrame(Fn))
944  Offset += MFI.getMaxCallFrameSize();
945 
946  // Round up the size to a multiple of the alignment. If the function has
947  // any calls or alloca's, align to the target's StackAlignment value to
948  // ensure that the callee's frame or the alloca data is suitably aligned;
949  // otherwise, for leaf functions, align to the TransientStackAlignment
950  // value.
951  unsigned StackAlign;
952  if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
953  (RegInfo->needsStackRealignment(Fn) && MFI.getObjectIndexEnd() != 0))
954  StackAlign = TFI.getStackAlignment();
955  else
956  StackAlign = TFI.getTransientStackAlignment();
957 
958  // If the frame pointer is eliminated, all frame offsets will be relative to
959  // SP not FP. Align to MaxAlign so this works.
960  StackAlign = std::max(StackAlign, MaxAlign);
961  Offset = alignTo(Offset, StackAlign, Skew);
962  }
963 
964  // Update frame info to pretend that this is part of the stack...
965  int64_t StackSize = Offset - LocalAreaOffset;
966  MFI.setStackSize(StackSize);
967  NumBytesStackSpace += StackSize;
968 }
969 
970 /// insertPrologEpilogCode - Scan the function for modified callee saved
971 /// registers, insert spill code for these callee saved registers, then add
972 /// prolog and epilog code to the function.
973 ///
974 void PEI::insertPrologEpilogCode(MachineFunction &Fn) {
976 
977  // Add prologue to the function...
978  for (MachineBasicBlock *SaveBlock : SaveBlocks)
979  TFI.emitPrologue(Fn, *SaveBlock);
980 
981  // Add epilogue to restore the callee-save registers in each exiting block.
982  for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
983  TFI.emitEpilogue(Fn, *RestoreBlock);
984 
985  for (MachineBasicBlock *SaveBlock : SaveBlocks)
986  TFI.inlineStackProbe(Fn, *SaveBlock);
987 
988  // Emit additional code that is required to support segmented stacks, if
989  // we've been asked for it. This, when linked with a runtime with support
990  // for segmented stacks (libgcc is one), will result in allocating stack
991  // space in small chunks instead of one large contiguous block.
992  if (Fn.shouldSplitStack()) {
993  for (MachineBasicBlock *SaveBlock : SaveBlocks)
994  TFI.adjustForSegmentedStacks(Fn, *SaveBlock);
995  }
996 
997  // Emit additional code that is required to explicitly handle the stack in
998  // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
999  // approach is rather similar to that of Segmented Stacks, but it uses a
1000  // different conditional check and another BIF for allocating more stack
1001  // space.
1003  for (MachineBasicBlock *SaveBlock : SaveBlocks)
1004  TFI.adjustForHiPEPrologue(Fn, *SaveBlock);
1005 }
1006 
1007 /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
1008 /// register references and actual offsets.
1009 ///
1010 void PEI::replaceFrameIndices(MachineFunction &Fn) {
1011  const TargetFrameLowering &TFI = *Fn.getSubtarget().getFrameLowering();
1012  if (!TFI.needsFrameIndexResolution(Fn)) return;
1013 
1014  // Store SPAdj at exit of a basic block.
1015  SmallVector<int, 8> SPState;
1016  SPState.resize(Fn.getNumBlockIDs());
1018 
1019  // Iterate over the reachable blocks in DFS order.
1020  for (auto DFI = df_ext_begin(&Fn, Reachable), DFE = df_ext_end(&Fn, Reachable);
1021  DFI != DFE; ++DFI) {
1022  int SPAdj = 0;
1023  // Check the exit state of the DFS stack predecessor.
1024  if (DFI.getPathLength() >= 2) {
1025  MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
1026  assert(Reachable.count(StackPred) &&
1027  "DFS stack predecessor is already visited.\n");
1028  SPAdj = SPState[StackPred->getNumber()];
1029  }
1030  MachineBasicBlock *BB = *DFI;
1031  replaceFrameIndices(BB, Fn, SPAdj);
1032  SPState[BB->getNumber()] = SPAdj;
1033  }
1034 
1035  // Handle the unreachable blocks.
1036  for (auto &BB : Fn) {
1037  if (Reachable.count(&BB))
1038  // Already handled in DFS traversal.
1039  continue;
1040  int SPAdj = 0;
1041  replaceFrameIndices(&BB, Fn, SPAdj);
1042  }
1043 }
1044 
1045 void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &Fn,
1046  int &SPAdj) {
1048  "getRegisterInfo() must be implemented!");
1049  const TargetInstrInfo &TII = *Fn.getSubtarget().getInstrInfo();
1050  const TargetRegisterInfo &TRI = *Fn.getSubtarget().getRegisterInfo();
1052  unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
1053  unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
1054 
1055  if (RS && FrameIndexEliminationScavenging)
1056  RS->enterBasicBlock(*BB);
1057 
1058  bool InsideCallSequence = false;
1059 
1060  for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
1061 
1062  if (I->getOpcode() == FrameSetupOpcode ||
1063  I->getOpcode() == FrameDestroyOpcode) {
1064  InsideCallSequence = (I->getOpcode() == FrameSetupOpcode);
1065  SPAdj += TII.getSPAdjust(*I);
1066 
1067  I = TFI->eliminateCallFramePseudoInstr(Fn, *BB, I);
1068  continue;
1069  }
1070 
1071  MachineInstr &MI = *I;
1072  bool DoIncr = true;
1073  bool DidFinishLoop = true;
1074  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1075  if (!MI.getOperand(i).isFI())
1076  continue;
1077 
1078  // Frame indices in debug values are encoded in a target independent
1079  // way with simply the frame index and offset rather than any
1080  // target-specific addressing mode.
1081  if (MI.isDebugValue()) {
1082  assert(i == 0 && "Frame indices can only appear as the first "
1083  "operand of a DBG_VALUE machine instruction");
1084  unsigned Reg;
1085  MachineOperand &Offset = MI.getOperand(1);
1086  Offset.setImm(
1087  Offset.getImm() +
1088  TFI->getFrameIndexReference(Fn, MI.getOperand(0).getIndex(), Reg));
1089  MI.getOperand(0).ChangeToRegister(Reg, false /*isDef*/);
1090  continue;
1091  }
1092 
1093  // TODO: This code should be commoned with the code for
1094  // PATCHPOINT. There's no good reason for the difference in
1095  // implementation other than historical accident. The only
1096  // remaining difference is the unconditional use of the stack
1097  // pointer as the base register.
1098  if (MI.getOpcode() == TargetOpcode::STATEPOINT) {
1099  assert((!MI.isDebugValue() || i == 0) &&
1100  "Frame indicies can only appear as the first operand of a "
1101  "DBG_VALUE machine instruction");
1102  unsigned Reg;
1103  MachineOperand &Offset = MI.getOperand(i + 1);
1104  int refOffset = TFI->getFrameIndexReferencePreferSP(
1105  Fn, MI.getOperand(i).getIndex(), Reg, /*IgnoreSPUpdates*/ false);
1106  Offset.setImm(Offset.getImm() + refOffset);
1107  MI.getOperand(i).ChangeToRegister(Reg, false /*isDef*/);
1108  continue;
1109  }
1110 
1111  // Some instructions (e.g. inline asm instructions) can have
1112  // multiple frame indices and/or cause eliminateFrameIndex
1113  // to insert more than one instruction. We need the register
1114  // scavenger to go through all of these instructions so that
1115  // it can update its register information. We keep the
1116  // iterator at the point before insertion so that we can
1117  // revisit them in full.
1118  bool AtBeginning = (I == BB->begin());
1119  if (!AtBeginning) --I;
1120 
1121  // If this instruction has a FrameIndex operand, we need to
1122  // use that target machine register info object to eliminate
1123  // it.
1124  TRI.eliminateFrameIndex(MI, SPAdj, i,
1125  FrameIndexEliminationScavenging ? RS : nullptr);
1126 
1127  // Reset the iterator if we were at the beginning of the BB.
1128  if (AtBeginning) {
1129  I = BB->begin();
1130  DoIncr = false;
1131  }
1132 
1133  DidFinishLoop = false;
1134  break;
1135  }
1136 
1137  // If we are looking at a call sequence, we need to keep track of
1138  // the SP adjustment made by each instruction in the sequence.
1139  // This includes both the frame setup/destroy pseudos (handled above),
1140  // as well as other instructions that have side effects w.r.t the SP.
1141  // Note that this must come after eliminateFrameIndex, because
1142  // if I itself referred to a frame index, we shouldn't count its own
1143  // adjustment.
1144  if (DidFinishLoop && InsideCallSequence)
1145  SPAdj += TII.getSPAdjust(MI);
1146 
1147  if (DoIncr && I != BB->end()) ++I;
1148 
1149  // Update register states.
1150  if (RS && FrameIndexEliminationScavenging && DidFinishLoop)
1151  RS->forward(MI);
1152  }
1153 }
1154 
1155 /// doScavengeFrameVirtualRegs - Replace all frame index virtual registers
1156 /// with physical registers. Use the register scavenger to find an
1157 /// appropriate register to use.
1158 ///
1159 /// FIXME: Iterating over the instruction stream is unnecessary. We can simply
1160 /// iterate over the vreg use list, which at this point only contains machine
1161 /// operands for which eliminateFrameIndex need a new scratch reg.
1162 static void
1164  // Run through the instructions and find any virtual registers.
1166  for (MachineBasicBlock &MBB : MF) {
1167  RS->enterBasicBlock(MBB);
1168 
1169  int SPAdj = 0;
1170 
1171  // The instruction stream may change in the loop, so check MBB.end()
1172  // directly.
1173  for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ) {
1174  // We might end up here again with a NULL iterator if we scavenged a
1175  // register for which we inserted spill code for definition by what was
1176  // originally the first instruction in MBB.
1177  if (I == MachineBasicBlock::iterator(nullptr))
1178  I = MBB.begin();
1179 
1180  const MachineInstr &MI = *I;
1181  MachineBasicBlock::iterator J = std::next(I);
1183  I == MBB.begin() ? MachineBasicBlock::iterator(nullptr)
1184  : std::prev(I);
1185 
1186  // RS should process this instruction before we might scavenge at this
1187  // location. This is because we might be replacing a virtual register
1188  // defined by this instruction, and if so, registers killed by this
1189  // instruction are available, and defined registers are not.
1190  RS->forward(I);
1191 
1192  for (const MachineOperand &MO : MI.operands()) {
1193  if (!MO.isReg())
1194  continue;
1195  unsigned Reg = MO.getReg();
1197  continue;
1198 
1199  // When we first encounter a new virtual register, it
1200  // must be a definition.
1201  assert(MO.isDef() && "frame index virtual missing def!");
1202  // Scavenge a new scratch register
1203  const TargetRegisterClass *RC = MRI.getRegClass(Reg);
1204  unsigned ScratchReg = RS->scavengeRegister(RC, J, SPAdj);
1205 
1206  ++NumScavengedRegs;
1207 
1208  // Replace this reference to the virtual register with the
1209  // scratch register.
1210  assert(ScratchReg && "Missing scratch register!");
1211  MRI.replaceRegWith(Reg, ScratchReg);
1212 
1213  // Because this instruction was processed by the RS before this
1214  // register was allocated, make sure that the RS now records the
1215  // register as being used.
1216  RS->setRegUsed(ScratchReg);
1217  }
1218 
1219  // If the scavenger needed to use one of its spill slots, the
1220  // spill code will have been inserted in between I and J. This is a
1221  // problem because we need the spill code before I: Move I to just
1222  // prior to J.
1223  if (I != std::prev(J)) {
1224  MBB.splice(J, &MBB, I);
1225 
1226  // Before we move I, we need to prepare the RS to visit I again.
1227  // Specifically, RS will assert if it sees uses of registers that
1228  // it believes are undefined. Because we have already processed
1229  // register kills in I, when it visits I again, it will believe that
1230  // those registers are undefined. To avoid this situation, unprocess
1231  // the instruction I.
1232  assert(RS->getCurrentPosition() == I &&
1233  "The register scavenger has an unexpected position");
1234  I = P;
1235  RS->unprocess(P);
1236  } else
1237  ++I;
1238  }
1239  }
1240 }
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:193
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
virtual void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &objectsToAllocate) const
Order the symbols in the local stack frame.
virtual bool hasReservedSpillSlot(const MachineFunction &MF, unsigned Reg, int &FrameIdx) const
Return true if target has reserved a spill slot in the stack frame of the given function for the spec...
void setSavePoint(MachineBasicBlock *NewSave)
int find_first() const
find_first - Returns the index of the first set bit, -1 if none of the bits are set.
Definition: BitVector.h:157
void setRestorePoint(MachineBasicBlock *NewRestore)
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:119
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign, unsigned Skew)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:226
void setCalleeSavedInfoValid(bool v)
STATISTIC(NumFunctions,"Total number of functions")
size_t i
bool none() const
none - Returns true if none of the bits are set.
Definition: BitVector.h:151
static void computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown, unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex, int64_t FixedCSEnd, BitVector &StackBytesFree)
Compute which bytes of fixed and callee-save stack area are unused and keep track of them in StackByt...
void ChangeToRegister(unsigned Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isDebug=false)
ChangeToRegister - Replace this operand with a new register operand of the specified value...
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
static void updateLiveness(MachineFunction &MF)
Helper function to update the liveness information for the callee-saved registers.
MachineBasicBlock * getRestorePoint() const
int find_next(unsigned Prev) const
find_next - Returns the index of the next set bit following the "Prev" bit.
Definition: BitVector.h:166
static bool isVirtualRegister(unsigned Reg)
Return true if the specified register number is in the virtual register namespace.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
INITIALIZE_TM_PASS_BEGIN(PEI,"prologepilog","Prologue/Epilogue Insertion", false, false) INITIALIZE_TM_PASS_END(PEI
virtual void adjustForHiPEPrologue(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in the assembly prologue to ex...
virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const
Return the skew that has to be applied to stack alignment under certain conditions (e...
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
MachineInstrBundleIterator< MachineInstr > iterator
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:664
SmallVector< MachineBasicBlock *, 4 > MBBVector
virtual bool requiresFrameIndexScavenging(const MachineFunction &MF) const
Returns true if the target requires post PEI scavenging of registers for materializing frame index co...
virtual const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const
getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...
iterator_range< mop_iterator > operands()
Definition: MachineInstr.h:301
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:93
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
void clearVirtRegs()
clearVirtRegs - Remove all virtual registers (after physreg assignment).
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:165
iterator_range< succ_iterator > successors()
unsigned getMaxAlignment() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
Prologue Epilogue Insertion &Frame false
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects...
virtual bool targetHandlesStackFrameRounding() const
targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...
int64_t getLocalFrameSize() const
Get the size of the local object blob.
unsigned getSize() const
Return the size of the register in bytes, which is also the size of a stack slot allocated to hold a ...
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
virtual void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Replace a StackProbe stub (if any) with the actual probe code inline.
unsigned getCallFrameDestroyOpcode() const
Did not trigger a stack protector.
void clear()
clear - Clear all bits.
Definition: BitVector.h:188
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const HexagonInstrInfo * TII
virtual bool hasFP(const MachineFunction &MF) const =0
hasFP - Return true if the specified function should have a dedicated frame pointer register...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
const TargetRegisterClass * getRegClass(unsigned Reg) const
Return the register class of the specified virtual register.
Reg
All possible values of the reg field in the ModR/M byte.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
The address of this allocation is exposed and triggered protection.
virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const std::vector< CalleeSavedInfo > &CSI, const TargetRegisterInfo *TRI) const
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool Immutable=false)
Create a spill slot at a fixed location on the stack.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
unsigned getNumOperands() const
Access to explicit operands of the instruction.
Definition: MachineInstr.h:277
MachineBasicBlock::iterator getCurrentPosition() const
void forward()
Move the internal MBB iterator and update register states.
const MachineBasicBlock & front() const
bool isVariableSizedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a variable sized object.
#define F(x, y, z)
Definition: MD5.cpp:51
int getObjectIndexBegin() const
Return the minimum frame object index.
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
unsigned getCallFrameSetupOpcode() const
These methods return the opcode of the frame setup/destroy instructions if they exist (-1 otherwise)...
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
MachineBasicBlock * MBB
virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, unsigned &FrameReg, bool IgnoreSPUpdates) const
Same as getFrameIndexReference, except that the stack pointer (as opposed to the frame pointer) will ...
unsigned getLocalFrameMaxAlign() const
Return the required alignment of the local object blob.
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:83
virtual bool enableStackSlotScavenging(const MachineFunction &MF) const
Returns true if the stack slot holes in the fixed and callee-save stack area should be used when allo...
virtual void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj, unsigned FIOperandNum, RegScavenger *RS=nullptr) const =0
This method must be overriden to eliminate abstract frame indices from instructions which may use the...
virtual bool useFPForScavengingIndex(const MachineFunction &MF) const
Returns true if the target wants to use frame pointer based accesses to spill to the scavenger emerge...
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
int64_t getImm() const
static cl::opt< unsigned > WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1), cl::desc("Warn for stack size bigger than the given"" number"))
virtual MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
virtual const MCPhysReg * getCalleeSavedRegs(const MachineFunction *MF) const =0
Return a null-terminated list of all of the callee-saved registers on this target.
virtual int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
unsigned getTransientStackAlignment() const
getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...
int64_t getLocalFrameObjectCount() const
Return the number of objects allocated into the local object block.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:273
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
virtual bool requiresRegisterScavenging(const MachineFunction &MF) const
Returns true if the target requires (and can make use of) the register scavenger. ...
TargetInstrInfo - Interface to description of machine instruction set.
std::pair< int, int64_t > getLocalFrameObjectMap(int i) const
Get the local offset mapping for a for an object.
bool isDebugValue() const
Definition: MachineInstr.h:777
virtual void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
void addLiveIn(MCPhysReg PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
This file declares the machine register scavenger class.
bool getUseLocalStackAllocationBlock() const
Get whether the local allocation blob should be allocated together or let PEI allocate the locals in ...
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
unsigned const MachineRegisterInfo * MRI
void initializePEIPass(PassRegistry &)
virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const std::vector< CalleeSavedInfo > &CSI, const TargetRegisterInfo *TRI) const
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
unsigned getAlignment() const
Return the minimum required alignment for a register of this class.
df_ext_iterator< T, SetTy > df_ext_end(const T &G, SetTy &S)
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void setStackSize(uint64_t Size)
Set the size of the stack.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:36
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:279
void unprocess()
Invert the behavior of forward() on the current instruction (undo the changes to the available regist...
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:116
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
#define INITIALIZE_TM_PASS_END(passName, arg, name, cfg, analysis)
Target machine pass initializer for passes with dependencies.
virtual void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, unsigned DestReg, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI) const
Load the specified register of the given register class from the specified stack frame index...
SmallSetVector< int, 8 > StackObjSet
StackObjSet - A set of stack object indexes.
Represent the analysis usage information of a pass.
df_ext_iterator< T, SetTy > df_ext_begin(const T &G, SetTy &S)
static void doScavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger *RS)
doScavengeFrameVirtualRegs - Replace all frame index virtual registers with physical registers...
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
BitVector & reset()
Definition: BitVector.h:260
uint32_t Offset
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
void setImm(int64_t immVal)
static bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, unsigned MaxAlign, BitVector &StackBytesFree)
Assign frame object to an unused portion of the stack in the fixed stack object range.
SSPLayoutKind getSSPLayout(const AllocaInst *AI) const
static void assignCalleeSavedSpillSlots(MachineFunction &F, const BitVector &SavedRegs, unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex)
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:80
static void insertCSRSpillsAndRestores(MachineFunction &Fn, const MBBVector &SaveBlocks, const MBBVector &RestoreBlocks)
insertCSRSpillsAndRestores - Insert spill and restore code for callee saved registers used in the fun...
virtual void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, unsigned SrcReg, bool isKill, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI) const
Store the specified register of the given register class to the specified stack frame index...
MachineFunctionPass * createPrologEpilogInserterPass(const TargetMachine *TM)
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction. ...
virtual bool hasReservedCallFrame(const MachineFunction &MF) const
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required, we reserve argument space for call sites in the function immediately on entry to the current function.
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
virtual const TargetFrameLowering * getFrameLowering() const
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
static void doSpillCalleeSavedRegs(MachineFunction &MF, RegScavenger *RS, unsigned &MinCSFrameIndex, unsigned &MaxCXFrameIndex, const MBBVector &SaveBlocks, const MBBVector &RestoreBlocks)
Iterator for intrusive lists based on ilist_node.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
virtual bool requiresFrameIndexReplacementScavenging(const MachineFunction &MF) const
Returns true if the target requires using the RegScavenger directly for frame elimination despite usi...
virtual void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
MachineOperand class - Representation of each machine instruction operand.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
unsigned getObjectAlignment(int ObjectIdx) const
Return the alignment of the specified stack object.
bool test(unsigned Idx) const
Definition: BitVector.h:323
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
Prologue Epilogue Insertion &Frame Finalization
unsigned getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call...
Information about stack frame layout on the target.
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const
canSimplifyCallFramePseudos - When possible, it's best to simplify the call frame pseudo ops before d...
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
const TargetRegisterClass * getMinimalPhysRegClass(unsigned Reg, MVT VT=MVT::Other) const
Returns the Register Class of a physical register of the given type, picking the most sub register cl...
void replaceRegWith(unsigned FromReg, unsigned ToReg)
replaceRegWith - Replace all instances of FromReg with ToReg in the machine function.
int getStackProtectorIndex() const
Return the index for the stack protector object.
char & PrologEpilogCodeInserterID
PrologEpilogCodeInserter - This pass inserts prolog and epilog code, and eliminates abstract frame re...
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
MachineFunctionProperties & set(Property P)
MachineBasicBlock * getSavePoint() const
Representation of each machine instruction.
Definition: MachineInstr.h:52
void setCalleeSavedInfo(const std::vector< CalleeSavedInfo > &CSI)
Used by prolog/epilog inserter to set the function's callee saved information.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
void enterBasicBlock(MachineBasicBlock &MBB)
Start tracking liveness from the begin of basic block MBB.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:226
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
void push_back(MachineInstr *MI)
#define I(x, y, z)
Definition: MD5.cpp:54
virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to have the function use segmented stacks.
void setMaxCallFrameSize(unsigned S)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling...
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
int CreateStackObject(uint64_t Size, unsigned Alignment, bool isSS, const AllocaInst *Alloca=nullptr)
Create a new statically sized stack object, returning a nonnegative identifier to represent it...
virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const
assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void setRegUsed(unsigned Reg, LaneBitmask LaneMask=LaneBitmask::getAll())
Tell the scavenger a register is used.
aarch64 promote const
virtual const TargetInstrInfo * getInstrInfo() const
#define DEBUG(X)
Definition: Debug.h:100
Primary interface to the complete machine description for the target machine.
print Print MemDeps of function
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
IRTranslator LLVM IR MI
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
bool needsStackRealignment(const MachineFunction &MF) const
True if storage within the function requires the stack pointer to be aligned more than the normal cal...
int getObjectIndexEnd() const
Return one past the maximum frame object index.
const AllocaInst * getObjectAllocation(int ObjectIdx) const
Return the underlying Alloca of the specified stack object if it exists.
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, unsigned &MaxAlign, unsigned Skew)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
Array or nested array >= SSP-buffer-size.
Properties which a MachineFunction may have at a given point in time.
Array or nested array < SSP-buffer-size.
virtual bool isFPCloseToIncomingSP() const
isFPCloseToIncomingSP - Return true if the frame pointer is close to the incoming stack pointer...
unsigned scavengeRegister(const TargetRegisterClass *RegClass, MachineBasicBlock::iterator I, int SPAdj)
Make a register of the specific register class available and do the appropriate bookkeeping.
void resize(size_type N)
Definition: SmallVector.h:352