LLVM  12.0.0git
PrologEpilogInserter.cpp
Go to the documentation of this file.
1 //===- PrologEpilogInserter.cpp - Insert Prolog/Epilog code in function ---===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass is responsible for finalizing the functions frame layout, saving
10 // callee saved registers, and for emitting prolog & epilog code for the
11 // function.
12 //
13 // This pass must be run after register allocation. After this pass is
14 // executed, it is illegal to construct MO_FrameIndex operands.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/BitVector.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SetVector.h"
23 #include "llvm/ADT/SmallPtrSet.h"
24 #include "llvm/ADT/SmallSet.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/Statistic.h"
47 #include "llvm/IR/Attributes.h"
48 #include "llvm/IR/CallingConv.h"
50 #include "llvm/IR/DiagnosticInfo.h"
51 #include "llvm/IR/Function.h"
52 #include "llvm/IR/InlineAsm.h"
53 #include "llvm/IR/LLVMContext.h"
54 #include "llvm/InitializePasses.h"
55 #include "llvm/MC/MCRegisterInfo.h"
56 #include "llvm/Pass.h"
57 #include "llvm/Support/CodeGen.h"
59 #include "llvm/Support/Debug.h"
65 #include <algorithm>
66 #include <cassert>
67 #include <cstdint>
68 #include <functional>
69 #include <limits>
70 #include <utility>
71 #include <vector>
72 
73 using namespace llvm;
74 
75 #define DEBUG_TYPE "prologepilog"
76 
78 
79 STATISTIC(NumLeafFuncWithSpills, "Number of leaf functions with CSRs");
80 STATISTIC(NumFuncSeen, "Number of functions seen in PEI");
81 
82 
83 namespace {
84 
85 class PEI : public MachineFunctionPass {
86 public:
87  static char ID;
88 
89  PEI() : MachineFunctionPass(ID) {
91  }
92 
93  void getAnalysisUsage(AnalysisUsage &AU) const override;
94 
95  /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
96  /// frame indexes with appropriate references.
97  bool runOnMachineFunction(MachineFunction &MF) override;
98 
99 private:
100  RegScavenger *RS;
101 
102  // MinCSFrameIndex, MaxCSFrameIndex - Keeps the range of callee saved
103  // stack frame indexes.
104  unsigned MinCSFrameIndex = std::numeric_limits<unsigned>::max();
105  unsigned MaxCSFrameIndex = 0;
106 
107  // Save and Restore blocks of the current function. Typically there is a
108  // single save block, unless Windows EH funclets are involved.
109  MBBVector SaveBlocks;
110  MBBVector RestoreBlocks;
111 
112  // Flag to control whether to use the register scavenger to resolve
113  // frame index materialization registers. Set according to
114  // TRI->requiresFrameIndexScavenging() for the current function.
115  bool FrameIndexVirtualScavenging;
116 
117  // Flag to control whether the scavenger should be passed even though
118  // FrameIndexVirtualScavenging is used.
119  bool FrameIndexEliminationScavenging;
120 
121  // Emit remarks.
122  MachineOptimizationRemarkEmitter *ORE = nullptr;
123 
124  void calculateCallFrameInfo(MachineFunction &MF);
125  void calculateSaveRestoreBlocks(MachineFunction &MF);
126  void spillCalleeSavedRegs(MachineFunction &MF);
127 
128  void calculateFrameObjectOffsets(MachineFunction &MF);
129  void replaceFrameIndices(MachineFunction &MF);
130  void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
131  int &SPAdj);
132  void insertPrologEpilogCode(MachineFunction &MF);
133 };
134 
135 } // end anonymous namespace
136 
137 char PEI::ID = 0;
138 
140 
141 static cl::opt<unsigned>
142 WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1),
143  cl::desc("Warn for stack size bigger than the given"
144  " number"));
145 
146 INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false,
147  false)
152  "Prologue/Epilogue Insertion & Frame Finalization", false,
153  false)
154 
156  return new PEI();
157 }
158 
159 STATISTIC(NumBytesStackSpace,
160  "Number of bytes used for stack in all functions");
161 
162 void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
163  AU.setPreservesCFG();
168 }
169 
170 /// StackObjSet - A set of stack object indexes
172 
173 using SavedDbgValuesMap =
175 
176 /// Stash DBG_VALUEs that describe parameters and which are placed at the start
177 /// of the block. Later on, after the prologue code has been emitted, the
178 /// stashed DBG_VALUEs will be reinserted at the start of the block.
180  SavedDbgValuesMap &EntryDbgValues) {
181  SmallVector<const MachineInstr *, 4> FrameIndexValues;
182 
183  for (auto &MI : MBB) {
184  if (!MI.isDebugInstr())
185  break;
186  if (!MI.isDebugValue() || !MI.getDebugVariable()->isParameter())
187  continue;
188  if (MI.getDebugOperand(0).isFI()) {
189  // We can only emit valid locations for frame indices after the frame
190  // setup, so do not stash away them.
191  FrameIndexValues.push_back(&MI);
192  continue;
193  }
194  const DILocalVariable *Var = MI.getDebugVariable();
195  const DIExpression *Expr = MI.getDebugExpression();
196  auto Overlaps = [Var, Expr](const MachineInstr *DV) {
197  return Var == DV->getDebugVariable() &&
198  Expr->fragmentsOverlap(DV->getDebugExpression());
199  };
200  // See if the debug value overlaps with any preceding debug value that will
201  // not be stashed. If that is the case, then we can't stash this value, as
202  // we would then reorder the values at reinsertion.
203  if (llvm::none_of(FrameIndexValues, Overlaps))
204  EntryDbgValues[&MBB].push_back(&MI);
205  }
206 
207  // Remove stashed debug values from the block.
208  if (EntryDbgValues.count(&MBB))
209  for (auto *MI : EntryDbgValues[&MBB])
210  MI->removeFromParent();
211 }
212 
213 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
214 /// frame indexes with appropriate references.
215 bool PEI::runOnMachineFunction(MachineFunction &MF) {
216  NumFuncSeen++;
217  const Function &F = MF.getFunction();
220 
221  RS = TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : nullptr;
222  FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(MF);
223  ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
224 
225  // Calculate the MaxCallFrameSize and AdjustsStack variables for the
226  // function's frame information. Also eliminates call frame pseudo
227  // instructions.
228  calculateCallFrameInfo(MF);
229 
230  // Determine placement of CSR spill/restore code and prolog/epilog code:
231  // place all spills in the entry block, all restores in return blocks.
232  calculateSaveRestoreBlocks(MF);
233 
234  // Stash away DBG_VALUEs that should not be moved by insertion of prolog code.
235  SavedDbgValuesMap EntryDbgValues;
236  for (MachineBasicBlock *SaveBlock : SaveBlocks)
237  stashEntryDbgValues(*SaveBlock, EntryDbgValues);
238 
239  // Handle CSR spilling and restoring, for targets that need it.
240  if (MF.getTarget().usesPhysRegsForValues())
241  spillCalleeSavedRegs(MF);
242 
243  // Allow the target machine to make final modifications to the function
244  // before the frame layout is finalized.
246 
247  // Calculate actual frame offsets for all abstract stack objects...
248  calculateFrameObjectOffsets(MF);
249 
250  // Add prolog and epilog code to the function. This function is required
251  // to align the stack frame as necessary for any stack variables or
252  // called functions. Because of this, calculateCalleeSavedRegisters()
253  // must be called before this function in order to set the AdjustsStack
254  // and MaxCallFrameSize variables.
255  if (!F.hasFnAttribute(Attribute::Naked))
256  insertPrologEpilogCode(MF);
257 
258  // Reinsert stashed debug values at the start of the entry blocks.
259  for (auto &I : EntryDbgValues)
260  I.first->insert(I.first->begin(), I.second.begin(), I.second.end());
261 
262  // Allow the target machine to make final modifications to the function
263  // before the frame layout is finalized.
265 
266  // Replace all MO_FrameIndex operands with physical register references
267  // and actual offsets.
268  //
269  replaceFrameIndices(MF);
270 
271  // If register scavenging is needed, as we've enabled doing it as a
272  // post-pass, scavenge the virtual registers that frame index elimination
273  // inserted.
274  if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)
275  scavengeFrameVirtualRegs(MF, *RS);
276 
277  // Warn on stack size when we exceeds the given limit.
278  MachineFrameInfo &MFI = MF.getFrameInfo();
279  uint64_t StackSize = MFI.getStackSize();
280  if (WarnStackSize.getNumOccurrences() > 0 && WarnStackSize < StackSize) {
281  DiagnosticInfoStackSize DiagStackSize(F, StackSize);
282  F.getContext().diagnose(DiagStackSize);
283  }
284  ORE->emit([&]() {
285  return MachineOptimizationRemarkAnalysis(DEBUG_TYPE, "StackSize",
286  MF.getFunction().getSubprogram(),
287  &MF.front())
288  << ore::NV("NumStackBytes", StackSize) << " stack bytes in function";
289  });
290 
291  delete RS;
292  SaveBlocks.clear();
293  RestoreBlocks.clear();
294  MFI.setSavePoint(nullptr);
295  MFI.setRestorePoint(nullptr);
296  return true;
297 }
298 
299 /// Calculate the MaxCallFrameSize and AdjustsStack
300 /// variables for the function's frame information and eliminate call frame
301 /// pseudo instructions.
302 void PEI::calculateCallFrameInfo(MachineFunction &MF) {
303  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
305  MachineFrameInfo &MFI = MF.getFrameInfo();
306 
307  unsigned MaxCallFrameSize = 0;
308  bool AdjustsStack = MFI.adjustsStack();
309 
310  // Get the function call frame set-up and tear-down instruction opcode
311  unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
312  unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
313 
314  // Early exit for targets which have no call frame setup/destroy pseudo
315  // instructions.
316  if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)
317  return;
318 
319  std::vector<MachineBasicBlock::iterator> FrameSDOps;
320  for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); BB != E; ++BB)
321  for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I)
322  if (TII.isFrameInstr(*I)) {
323  unsigned Size = TII.getFrameSize(*I);
324  if (Size > MaxCallFrameSize) MaxCallFrameSize = Size;
325  AdjustsStack = true;
326  FrameSDOps.push_back(I);
327  } else if (I->isInlineAsm()) {
328  // Some inline asm's need a stack frame, as indicated by operand 1.
329  unsigned ExtraInfo = I->getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
330  if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
331  AdjustsStack = true;
332  }
333 
335  (MFI.getMaxCallFrameSize() == MaxCallFrameSize &&
336  MFI.adjustsStack() == AdjustsStack));
337  MFI.setAdjustsStack(AdjustsStack);
338  MFI.setMaxCallFrameSize(MaxCallFrameSize);
339 
340  for (std::vector<MachineBasicBlock::iterator>::iterator
341  i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) {
343 
344  // If call frames are not being included as part of the stack frame, and
345  // the target doesn't indicate otherwise, remove the call frame pseudos
346  // here. The sub/add sp instruction pairs are still inserted, but we don't
347  // need to track the SP adjustment for frame index elimination.
348  if (TFI->canSimplifyCallFramePseudos(MF))
349  TFI->eliminateCallFramePseudoInstr(MF, *I->getParent(), I);
350  }
351 }
352 
353 /// Compute the sets of entry and return blocks for saving and restoring
354 /// callee-saved registers, and placing prolog and epilog code.
355 void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
356  const MachineFrameInfo &MFI = MF.getFrameInfo();
357 
358  // Even when we do not change any CSR, we still want to insert the
359  // prologue and epilogue of the function.
360  // So set the save points for those.
361 
362  // Use the points found by shrink-wrapping, if any.
363  if (MFI.getSavePoint()) {
364  SaveBlocks.push_back(MFI.getSavePoint());
365  assert(MFI.getRestorePoint() && "Both restore and save must be set");
366  MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
367  // If RestoreBlock does not have any successor and is not a return block
368  // then the end point is unreachable and we do not need to insert any
369  // epilogue.
370  if (!RestoreBlock->succ_empty() || RestoreBlock->isReturnBlock())
371  RestoreBlocks.push_back(RestoreBlock);
372  return;
373  }
374 
375  // Save refs to entry and return blocks.
376  SaveBlocks.push_back(&MF.front());
377  for (MachineBasicBlock &MBB : MF) {
378  if (MBB.isEHFuncletEntry())
379  SaveBlocks.push_back(&MBB);
380  if (MBB.isReturnBlock())
381  RestoreBlocks.push_back(&MBB);
382  }
383 }
384 
386  const BitVector &SavedRegs,
387  unsigned &MinCSFrameIndex,
388  unsigned &MaxCSFrameIndex) {
389  if (SavedRegs.empty())
390  return;
391 
392  const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
393  const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();
394 
395  std::vector<CalleeSavedInfo> CSI;
396  for (unsigned i = 0; CSRegs[i]; ++i) {
397  unsigned Reg = CSRegs[i];
398  if (SavedRegs.test(Reg))
399  CSI.push_back(CalleeSavedInfo(Reg));
400  }
401 
403  MachineFrameInfo &MFI = F.getFrameInfo();
404  if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI)) {
405  // If target doesn't implement this, use generic code.
406 
407  if (CSI.empty())
408  return; // Early exit if no callee saved registers are modified!
409 
410  unsigned NumFixedSpillSlots;
411  const TargetFrameLowering::SpillSlot *FixedSpillSlots =
412  TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
413 
414  // Now that we know which registers need to be saved and restored, allocate
415  // stack slots for them.
416  for (auto &CS : CSI) {
417  // If the target has spilled this register to another register, we don't
418  // need to allocate a stack slot.
419  if (CS.isSpilledToReg())
420  continue;
421 
422  unsigned Reg = CS.getReg();
423  const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
424 
425  int FrameIdx;
426  if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {
427  CS.setFrameIdx(FrameIdx);
428  continue;
429  }
430 
431  // Check to see if this physreg must be spilled to a particular stack slot
432  // on this target.
433  const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
434  while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
435  FixedSlot->Reg != Reg)
436  ++FixedSlot;
437 
438  unsigned Size = RegInfo->getSpillSize(*RC);
439  if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
440  // Nope, just spill it anywhere convenient.
441  Align Alignment(RegInfo->getSpillAlignment(*RC));
442  // We may not be able to satisfy the desired alignment specification of
443  // the TargetRegisterClass if the stack alignment is smaller. Use the
444  // min.
445  Alignment = std::min(Alignment, TFI->getStackAlign());
446  FrameIdx = MFI.CreateStackObject(Size, Alignment, true);
447  if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
448  if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
449  } else {
450  // Spill it to the stack where we must.
451  FrameIdx = MFI.CreateFixedSpillStackObject(Size, FixedSlot->Offset);
452  }
453 
454  CS.setFrameIdx(FrameIdx);
455  }
456  }
457 
458  MFI.setCalleeSavedInfo(CSI);
459 }
460 
461 /// Helper function to update the liveness information for the callee-saved
462 /// registers.
463 static void updateLiveness(MachineFunction &MF) {
464  MachineFrameInfo &MFI = MF.getFrameInfo();
465  // Visited will contain all the basic blocks that are in the region
466  // where the callee saved registers are alive:
467  // - Anything that is not Save or Restore -> LiveThrough.
468  // - Save -> LiveIn.
469  // - Restore -> LiveOut.
470  // The live-out is not attached to the block, so no need to keep
471  // Restore in this set.
474  MachineBasicBlock *Entry = &MF.front();
475  MachineBasicBlock *Save = MFI.getSavePoint();
476 
477  if (!Save)
478  Save = Entry;
479 
480  if (Entry != Save) {
481  WorkList.push_back(Entry);
482  Visited.insert(Entry);
483  }
484  Visited.insert(Save);
485 
486  MachineBasicBlock *Restore = MFI.getRestorePoint();
487  if (Restore)
488  // By construction Restore cannot be visited, otherwise it
489  // means there exists a path to Restore that does not go
490  // through Save.
491  WorkList.push_back(Restore);
492 
493  while (!WorkList.empty()) {
494  const MachineBasicBlock *CurBB = WorkList.pop_back_val();
495  // By construction, the region that is after the save point is
496  // dominated by the Save and post-dominated by the Restore.
497  if (CurBB == Save && Save != Restore)
498  continue;
499  // Enqueue all the successors not already visited.
500  // Those are by construction either before Save or after Restore.
501  for (MachineBasicBlock *SuccBB : CurBB->successors())
502  if (Visited.insert(SuccBB).second)
503  WorkList.push_back(SuccBB);
504  }
505 
506  const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
507 
509  for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
510  for (MachineBasicBlock *MBB : Visited) {
511  MCPhysReg Reg = CSI[i].getReg();
512  // Add the callee-saved register as live-in.
513  // It's killed at the spill.
514  if (!MRI.isReserved(Reg) && !MBB->isLiveIn(Reg))
515  MBB->addLiveIn(Reg);
516  }
517  // If callee-saved register is spilled to another register rather than
518  // spilling to stack, the destination register has to be marked as live for
519  // each MBB between the prologue and epilogue so that it is not clobbered
520  // before it is reloaded in the epilogue. The Visited set contains all
521  // blocks outside of the region delimited by prologue/epilogue.
522  if (CSI[i].isSpilledToReg()) {
523  for (MachineBasicBlock &MBB : MF) {
524  if (Visited.count(&MBB))
525  continue;
526  MCPhysReg DstReg = CSI[i].getDstReg();
527  if (!MBB.isLiveIn(DstReg))
528  MBB.addLiveIn(DstReg);
529  }
530  }
531  }
532 
533 }
534 
535 /// Insert restore code for the callee-saved registers used in the function.
536 static void insertCSRSaves(MachineBasicBlock &SaveBlock,
538  MachineFunction &MF = *SaveBlock.getParent();
539  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
542 
543  MachineBasicBlock::iterator I = SaveBlock.begin();
544  if (!TFI->spillCalleeSavedRegisters(SaveBlock, I, CSI, TRI)) {
545  for (const CalleeSavedInfo &CS : CSI) {
546  // Insert the spill to the stack frame.
547  unsigned Reg = CS.getReg();
548 
549  if (CS.isSpilledToReg()) {
550  BuildMI(SaveBlock, I, DebugLoc(),
551  TII.get(TargetOpcode::COPY), CS.getDstReg())
552  .addReg(Reg, getKillRegState(true));
553  } else {
554  const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
555  TII.storeRegToStackSlot(SaveBlock, I, Reg, true, CS.getFrameIdx(), RC,
556  TRI);
557  }
558  }
559  }
560 }
561 
562 /// Insert restore code for the callee-saved registers used in the function.
563 static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
564  std::vector<CalleeSavedInfo> &CSI) {
565  MachineFunction &MF = *RestoreBlock.getParent();
566  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
569 
570  // Restore all registers immediately before the return and any
571  // terminators that precede it.
573 
574  if (!TFI->restoreCalleeSavedRegisters(RestoreBlock, I, CSI, TRI)) {
575  for (const CalleeSavedInfo &CI : reverse(CSI)) {
576  unsigned Reg = CI.getReg();
577  if (CI.isSpilledToReg()) {
578  BuildMI(RestoreBlock, I, DebugLoc(), TII.get(TargetOpcode::COPY), Reg)
579  .addReg(CI.getDstReg(), getKillRegState(true));
580  } else {
581  const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
582  TII.loadRegFromStackSlot(RestoreBlock, I, Reg, CI.getFrameIdx(), RC, TRI);
583  assert(I != RestoreBlock.begin() &&
584  "loadRegFromStackSlot didn't insert any code!");
585  // Insert in reverse order. loadRegFromStackSlot can insert
586  // multiple instructions.
587  }
588  }
589  }
590 }
591 
592 void PEI::spillCalleeSavedRegs(MachineFunction &MF) {
593  // We can't list this requirement in getRequiredProperties because some
594  // targets (WebAssembly) use virtual registers past this point, and the pass
595  // pipeline is set up without giving the passes a chance to look at the
596  // TargetMachine.
597  // FIXME: Find a way to express this in getRequiredProperties.
600 
601  const Function &F = MF.getFunction();
603  MachineFrameInfo &MFI = MF.getFrameInfo();
604  MinCSFrameIndex = std::numeric_limits<unsigned>::max();
605  MaxCSFrameIndex = 0;
606 
607  // Determine which of the registers in the callee save list should be saved.
608  BitVector SavedRegs;
609  TFI->determineCalleeSaves(MF, SavedRegs, RS);
610 
611  // Assign stack slots for any callee-saved registers that must be spilled.
612  assignCalleeSavedSpillSlots(MF, SavedRegs, MinCSFrameIndex, MaxCSFrameIndex);
613 
614  // Add the code to save and restore the callee saved registers.
615  if (!F.hasFnAttribute(Attribute::Naked)) {
616  MFI.setCalleeSavedInfoValid(true);
617 
618  std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
619  if (!CSI.empty()) {
620  if (!MFI.hasCalls())
621  NumLeafFuncWithSpills++;
622 
623  for (MachineBasicBlock *SaveBlock : SaveBlocks) {
624  insertCSRSaves(*SaveBlock, CSI);
625  // Update the live-in information of all the blocks up to the save
626  // point.
627  updateLiveness(MF);
628  }
629  for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
630  insertCSRRestores(*RestoreBlock, CSI);
631  }
632  }
633 }
634 
635 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
636 static inline void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx,
637  bool StackGrowsDown, int64_t &Offset,
638  Align &MaxAlign, unsigned Skew) {
639  // If the stack grows down, add the object size to find the lowest address.
640  if (StackGrowsDown)
641  Offset += MFI.getObjectSize(FrameIdx);
642 
643  Align Alignment = MFI.getObjectAlign(FrameIdx);
644 
645  // If the alignment of this object is greater than that of the stack, then
646  // increase the stack alignment to match.
647  MaxAlign = std::max(MaxAlign, Alignment);
648 
649  // Adjust to alignment boundary.
650  Offset = alignTo(Offset, Alignment, Skew);
651 
652  if (StackGrowsDown) {
653  LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset
654  << "]\n");
655  MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
656  } else {
657  LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset
658  << "]\n");
659  MFI.setObjectOffset(FrameIdx, Offset);
660  Offset += MFI.getObjectSize(FrameIdx);
661  }
662 }
663 
664 /// Compute which bytes of fixed and callee-save stack area are unused and keep
665 /// track of them in StackBytesFree.
666 static inline void
667 computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown,
668  unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex,
669  int64_t FixedCSEnd, BitVector &StackBytesFree) {
670  // Avoid undefined int64_t -> int conversion below in extreme case.
671  if (FixedCSEnd > std::numeric_limits<int>::max())
672  return;
673 
674  StackBytesFree.resize(FixedCSEnd, true);
675 
676  SmallVector<int, 16> AllocatedFrameSlots;
677  // Add fixed objects.
678  for (int i = MFI.getObjectIndexBegin(); i != 0; ++i)
679  // StackSlot scavenging is only implemented for the default stack.
680  if (MFI.getStackID(i) == TargetStackID::Default)
681  AllocatedFrameSlots.push_back(i);
682  // Add callee-save objects.
683  for (int i = MinCSFrameIndex; i <= (int)MaxCSFrameIndex; ++i)
684  if (MFI.getStackID(i) == TargetStackID::Default)
685  AllocatedFrameSlots.push_back(i);
686 
687  for (int i : AllocatedFrameSlots) {
688  // These are converted from int64_t, but they should always fit in int
689  // because of the FixedCSEnd check above.
690  int ObjOffset = MFI.getObjectOffset(i);
691  int ObjSize = MFI.getObjectSize(i);
692  int ObjStart, ObjEnd;
693  if (StackGrowsDown) {
694  // ObjOffset is negative when StackGrowsDown is true.
695  ObjStart = -ObjOffset - ObjSize;
696  ObjEnd = -ObjOffset;
697  } else {
698  ObjStart = ObjOffset;
699  ObjEnd = ObjOffset + ObjSize;
700  }
701  // Ignore fixed holes that are in the previous stack frame.
702  if (ObjEnd > 0)
703  StackBytesFree.reset(ObjStart, ObjEnd);
704  }
705 }
706 
707 /// Assign frame object to an unused portion of the stack in the fixed stack
708 /// object range. Return true if the allocation was successful.
709 static inline bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx,
710  bool StackGrowsDown, Align MaxAlign,
711  BitVector &StackBytesFree) {
712  if (MFI.isVariableSizedObjectIndex(FrameIdx))
713  return false;
714 
715  if (StackBytesFree.none()) {
716  // clear it to speed up later scavengeStackSlot calls to
717  // StackBytesFree.none()
718  StackBytesFree.clear();
719  return false;
720  }
721 
722  Align ObjAlign = MFI.getObjectAlign(FrameIdx);
723  if (ObjAlign > MaxAlign)
724  return false;
725 
726  int64_t ObjSize = MFI.getObjectSize(FrameIdx);
727  int FreeStart;
728  for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;
729  FreeStart = StackBytesFree.find_next(FreeStart)) {
730 
731  // Check that free space has suitable alignment.
732  unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;
733  if (alignTo(ObjStart, ObjAlign) != ObjStart)
734  continue;
735 
736  if (FreeStart + ObjSize > StackBytesFree.size())
737  return false;
738 
739  bool AllBytesFree = true;
740  for (unsigned Byte = 0; Byte < ObjSize; ++Byte)
741  if (!StackBytesFree.test(FreeStart + Byte)) {
742  AllBytesFree = false;
743  break;
744  }
745  if (AllBytesFree)
746  break;
747  }
748 
749  if (FreeStart == -1)
750  return false;
751 
752  if (StackGrowsDown) {
753  int ObjStart = -(FreeStart + ObjSize);
754  LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
755  << ObjStart << "]\n");
756  MFI.setObjectOffset(FrameIdx, ObjStart);
757  } else {
758  LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
759  << FreeStart << "]\n");
760  MFI.setObjectOffset(FrameIdx, FreeStart);
761  }
762 
763  StackBytesFree.reset(FreeStart, FreeStart + ObjSize);
764  return true;
765 }
766 
767 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
768 /// those required to be close to the Stack Protector) to stack offsets.
769 static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
770  SmallSet<int, 16> &ProtectedObjs,
771  MachineFrameInfo &MFI, bool StackGrowsDown,
772  int64_t &Offset, Align &MaxAlign,
773  unsigned Skew) {
774 
775  for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
776  E = UnassignedObjs.end(); I != E; ++I) {
777  int i = *I;
778  AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign, Skew);
779  ProtectedObjs.insert(i);
780  }
781 }
782 
783 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
784 /// abstract stack objects.
785 void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
787 
788  bool StackGrowsDown =
790 
791  // Loop over all of the stack objects, assigning sequential addresses...
792  MachineFrameInfo &MFI = MF.getFrameInfo();
793 
794  // Start at the beginning of the local area.
795  // The Offset is the distance from the stack top in the direction
796  // of stack growth -- so it's always nonnegative.
797  int LocalAreaOffset = TFI.getOffsetOfLocalArea();
798  if (StackGrowsDown)
799  LocalAreaOffset = -LocalAreaOffset;
800  assert(LocalAreaOffset >= 0
801  && "Local area offset should be in direction of stack growth");
802  int64_t Offset = LocalAreaOffset;
803 
804  // Skew to be applied to alignment.
805  unsigned Skew = TFI.getStackAlignmentSkew(MF);
806 
807 #ifdef EXPENSIVE_CHECKS
808  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i)
809  if (!MFI.isDeadObjectIndex(i) &&
811  assert(MFI.getObjectAlign(i) <= MFI.getMaxAlign() &&
812  "MaxAlignment is invalid");
813 #endif
814 
815  // If there are fixed sized objects that are preallocated in the local area,
816  // non-fixed objects can't be allocated right at the start of local area.
817  // Adjust 'Offset' to point to the end of last fixed sized preallocated
818  // object.
819  for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
820  if (MFI.getStackID(i) !=
821  TargetStackID::Default) // Only allocate objects on the default stack.
822  continue;
823 
824  int64_t FixedOff;
825  if (StackGrowsDown) {
826  // The maximum distance from the stack pointer is at lower address of
827  // the object -- which is given by offset. For down growing stack
828  // the offset is negative, so we negate the offset to get the distance.
829  FixedOff = -MFI.getObjectOffset(i);
830  } else {
831  // The maximum distance from the start pointer is at the upper
832  // address of the object.
833  FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
834  }
835  if (FixedOff > Offset) Offset = FixedOff;
836  }
837 
838  // First assign frame offsets to stack objects that are used to spill
839  // callee saved registers.
840  if (StackGrowsDown) {
841  for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) {
842  if (MFI.getStackID(i) !=
843  TargetStackID::Default) // Only allocate objects on the default stack.
844  continue;
845 
846  // If the stack grows down, we need to add the size to find the lowest
847  // address of the object.
848  Offset += MFI.getObjectSize(i);
849 
850  // Adjust to alignment boundary
851  Offset = alignTo(Offset, MFI.getObjectAlign(i), Skew);
852 
853  LLVM_DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << -Offset << "]\n");
854  MFI.setObjectOffset(i, -Offset); // Set the computed offset
855  }
856  } else if (MaxCSFrameIndex >= MinCSFrameIndex) {
857  // Be careful about underflow in comparisons agains MinCSFrameIndex.
858  for (unsigned i = MaxCSFrameIndex; i != MinCSFrameIndex - 1; --i) {
859  if (MFI.getStackID(i) !=
860  TargetStackID::Default) // Only allocate objects on the default stack.
861  continue;
862 
863  if (MFI.isDeadObjectIndex(i))
864  continue;
865 
866  // Adjust to alignment boundary
867  Offset = alignTo(Offset, MFI.getObjectAlign(i), Skew);
868 
869  LLVM_DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << Offset << "]\n");
870  MFI.setObjectOffset(i, Offset);
871  Offset += MFI.getObjectSize(i);
872  }
873  }
874 
875  // FixedCSEnd is the stack offset to the end of the fixed and callee-save
876  // stack area.
877  int64_t FixedCSEnd = Offset;
878  Align MaxAlign = MFI.getMaxAlign();
879 
880  // Make sure the special register scavenging spill slot is closest to the
881  // incoming stack pointer if a frame pointer is required and is closer
882  // to the incoming rather than the final stack pointer.
883  const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
884  bool EarlyScavengingSlots = (TFI.hasFP(MF) &&
885  TFI.isFPCloseToIncomingSP() &&
886  RegInfo->useFPForScavengingIndex(MF) &&
887  !RegInfo->needsStackRealignment(MF));
888  if (RS && EarlyScavengingSlots) {
889  SmallVector<int, 2> SFIs;
890  RS->getScavengingFrameIndices(SFIs);
891  for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
892  IE = SFIs.end(); I != IE; ++I)
893  AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
894  }
895 
896  // FIXME: Once this is working, then enable flag will change to a target
897  // check for whether the frame is large enough to want to use virtual
898  // frame index registers. Functions which don't want/need this optimization
899  // will continue to use the existing code path.
901  Align Alignment = MFI.getLocalFrameMaxAlign();
902 
903  // Adjust to alignment boundary.
904  Offset = alignTo(Offset, Alignment, Skew);
905 
906  LLVM_DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
907 
908  // Resolve offsets for objects in the local block.
909  for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
910  std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
911  int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
912  LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset
913  << "]\n");
914  MFI.setObjectOffset(Entry.first, FIOffset);
915  }
916  // Allocate the local block
917  Offset += MFI.getLocalFrameSize();
918 
919  MaxAlign = std::max(Alignment, MaxAlign);
920  }
921 
922  // Retrieve the Exception Handler registration node.
923  int EHRegNodeFrameIndex = std::numeric_limits<int>::max();
924  if (const WinEHFuncInfo *FuncInfo = MF.getWinEHFuncInfo())
925  EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;
926 
927  // Make sure that the stack protector comes before the local variables on the
928  // stack.
929  SmallSet<int, 16> ProtectedObjs;
930  if (MFI.hasStackProtectorIndex()) {
931  int StackProtectorFI = MFI.getStackProtectorIndex();
932  StackObjSet LargeArrayObjs;
933  StackObjSet SmallArrayObjs;
934  StackObjSet AddrOfObjs;
935 
936  // If we need a stack protector, we need to make sure that
937  // LocalStackSlotPass didn't already allocate a slot for it.
938  // If we are told to use the LocalStackAllocationBlock, the stack protector
939  // is expected to be already pre-allocated.
941  AdjustStackOffset(MFI, StackProtectorFI, StackGrowsDown, Offset, MaxAlign,
942  Skew);
943  else if (!MFI.isObjectPreAllocated(MFI.getStackProtectorIndex()))
945  "Stack protector not pre-allocated by LocalStackSlotPass.");
946 
947  // Assign large stack objects first.
948  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
950  continue;
951  if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
952  continue;
953  if (RS && RS->isScavengingFrameIndex((int)i))
954  continue;
955  if (MFI.isDeadObjectIndex(i))
956  continue;
957  if (StackProtectorFI == (int)i || EHRegNodeFrameIndex == (int)i)
958  continue;
959  if (MFI.getStackID(i) !=
960  TargetStackID::Default) // Only allocate objects on the default stack.
961  continue;
962 
963  switch (MFI.getObjectSSPLayout(i)) {
965  continue;
967  SmallArrayObjs.insert(i);
968  continue;
970  AddrOfObjs.insert(i);
971  continue;
973  LargeArrayObjs.insert(i);
974  continue;
975  }
976  llvm_unreachable("Unexpected SSPLayoutKind.");
977  }
978 
979  // We expect **all** the protected stack objects to be pre-allocated by
980  // LocalStackSlotPass. If it turns out that PEI still has to allocate some
981  // of them, we may end up messing up the expected order of the objects.
983  !(LargeArrayObjs.empty() && SmallArrayObjs.empty() &&
984  AddrOfObjs.empty()))
985  llvm_unreachable("Found protected stack objects not pre-allocated by "
986  "LocalStackSlotPass.");
987 
988  AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
989  Offset, MaxAlign, Skew);
990  AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
991  Offset, MaxAlign, Skew);
992  AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
993  Offset, MaxAlign, Skew);
994  }
995 
996  SmallVector<int, 8> ObjectsToAllocate;
997 
998  // Then prepare to assign frame offsets to stack objects that are not used to
999  // spill callee saved registers.
1000  for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1002  continue;
1003  if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1004  continue;
1005  if (RS && RS->isScavengingFrameIndex((int)i))
1006  continue;
1007  if (MFI.isDeadObjectIndex(i))
1008  continue;
1009  if (MFI.getStackProtectorIndex() == (int)i || EHRegNodeFrameIndex == (int)i)
1010  continue;
1011  if (ProtectedObjs.count(i))
1012  continue;
1013  if (MFI.getStackID(i) !=
1014  TargetStackID::Default) // Only allocate objects on the default stack.
1015  continue;
1016 
1017  // Add the objects that we need to allocate to our working set.
1018  ObjectsToAllocate.push_back(i);
1019  }
1020 
1021  // Allocate the EH registration node first if one is present.
1022  if (EHRegNodeFrameIndex != std::numeric_limits<int>::max())
1023  AdjustStackOffset(MFI, EHRegNodeFrameIndex, StackGrowsDown, Offset,
1024  MaxAlign, Skew);
1025 
1026  // Give the targets a chance to order the objects the way they like it.
1027  if (MF.getTarget().getOptLevel() != CodeGenOpt::None &&
1029  TFI.orderFrameObjects(MF, ObjectsToAllocate);
1030 
1031  // Keep track of which bytes in the fixed and callee-save range are used so we
1032  // can use the holes when allocating later stack objects. Only do this if
1033  // stack protector isn't being used and the target requests it and we're
1034  // optimizing.
1035  BitVector StackBytesFree;
1036  if (!ObjectsToAllocate.empty() &&
1039  computeFreeStackSlots(MFI, StackGrowsDown, MinCSFrameIndex, MaxCSFrameIndex,
1040  FixedCSEnd, StackBytesFree);
1041 
1042  // Now walk the objects and actually assign base offsets to them.
1043  for (auto &Object : ObjectsToAllocate)
1044  if (!scavengeStackSlot(MFI, Object, StackGrowsDown, MaxAlign,
1045  StackBytesFree))
1046  AdjustStackOffset(MFI, Object, StackGrowsDown, Offset, MaxAlign, Skew);
1047 
1048  // Make sure the special register scavenging spill slot is closest to the
1049  // stack pointer.
1050  if (RS && !EarlyScavengingSlots) {
1051  SmallVector<int, 2> SFIs;
1052  RS->getScavengingFrameIndices(SFIs);
1053  for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
1054  IE = SFIs.end(); I != IE; ++I)
1055  AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
1056  }
1057 
1058  if (!TFI.targetHandlesStackFrameRounding()) {
1059  // If we have reserved argument space for call sites in the function
1060  // immediately on entry to the current function, count it as part of the
1061  // overall stack size.
1062  if (MFI.adjustsStack() && TFI.hasReservedCallFrame(MF))
1063  Offset += MFI.getMaxCallFrameSize();
1064 
1065  // Round up the size to a multiple of the alignment. If the function has
1066  // any calls or alloca's, align to the target's StackAlignment value to
1067  // ensure that the callee's frame or the alloca data is suitably aligned;
1068  // otherwise, for leaf functions, align to the TransientStackAlignment
1069  // value.
1070  Align StackAlign;
1071  if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
1072  (RegInfo->needsStackRealignment(MF) && MFI.getObjectIndexEnd() != 0))
1073  StackAlign = TFI.getStackAlign();
1074  else
1075  StackAlign = TFI.getTransientStackAlign();
1076 
1077  // If the frame pointer is eliminated, all frame offsets will be relative to
1078  // SP not FP. Align to MaxAlign so this works.
1079  StackAlign = std::max(StackAlign, MaxAlign);
1080  Offset = alignTo(Offset, StackAlign, Skew);
1081  }
1082 
1083  // Update frame info to pretend that this is part of the stack...
1084  int64_t StackSize = Offset - LocalAreaOffset;
1085  MFI.setStackSize(StackSize);
1086  NumBytesStackSpace += StackSize;
1087 }
1088 
1089 /// insertPrologEpilogCode - Scan the function for modified callee saved
1090 /// registers, insert spill code for these callee saved registers, then add
1091 /// prolog and epilog code to the function.
1092 void PEI::insertPrologEpilogCode(MachineFunction &MF) {
1093  const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
1094 
1095  // Add prologue to the function...
1096  for (MachineBasicBlock *SaveBlock : SaveBlocks)
1097  TFI.emitPrologue(MF, *SaveBlock);
1098 
1099  // Add epilogue to restore the callee-save registers in each exiting block.
1100  for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1101  TFI.emitEpilogue(MF, *RestoreBlock);
1102 
1103  for (MachineBasicBlock *SaveBlock : SaveBlocks)
1104  TFI.inlineStackProbe(MF, *SaveBlock);
1105 
1106  // Emit additional code that is required to support segmented stacks, if
1107  // we've been asked for it. This, when linked with a runtime with support
1108  // for segmented stacks (libgcc is one), will result in allocating stack
1109  // space in small chunks instead of one large contiguous block.
1110  if (MF.shouldSplitStack()) {
1111  for (MachineBasicBlock *SaveBlock : SaveBlocks)
1112  TFI.adjustForSegmentedStacks(MF, *SaveBlock);
1113  // Record that there are split-stack functions, so we will emit a
1114  // special section to tell the linker.
1115  MF.getMMI().setHasSplitStack(true);
1116  } else
1117  MF.getMMI().setHasNosplitStack(true);
1118 
1119  // Emit additional code that is required to explicitly handle the stack in
1120  // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
1121  // approach is rather similar to that of Segmented Stacks, but it uses a
1122  // different conditional check and another BIF for allocating more stack
1123  // space.
1125  for (MachineBasicBlock *SaveBlock : SaveBlocks)
1126  TFI.adjustForHiPEPrologue(MF, *SaveBlock);
1127 }
1128 
1129 /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
1130 /// register references and actual offsets.
1131 void PEI::replaceFrameIndices(MachineFunction &MF) {
1132  const auto &ST = MF.getSubtarget();
1133  const TargetFrameLowering &TFI = *ST.getFrameLowering();
1134  if (!TFI.needsFrameIndexResolution(MF))
1135  return;
1136 
1137  const TargetRegisterInfo *TRI = ST.getRegisterInfo();
1138 
1139  // Allow the target to determine this after knowing the frame size.
1140  FrameIndexEliminationScavenging = (RS && !FrameIndexVirtualScavenging) ||
1142 
1143  // Store SPAdj at exit of a basic block.
1144  SmallVector<int, 8> SPState;
1145  SPState.resize(MF.getNumBlockIDs());
1147 
1148  // Iterate over the reachable blocks in DFS order.
1149  for (auto DFI = df_ext_begin(&MF, Reachable), DFE = df_ext_end(&MF, Reachable);
1150  DFI != DFE; ++DFI) {
1151  int SPAdj = 0;
1152  // Check the exit state of the DFS stack predecessor.
1153  if (DFI.getPathLength() >= 2) {
1154  MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
1155  assert(Reachable.count(StackPred) &&
1156  "DFS stack predecessor is already visited.\n");
1157  SPAdj = SPState[StackPred->getNumber()];
1158  }
1159  MachineBasicBlock *BB = *DFI;
1160  replaceFrameIndices(BB, MF, SPAdj);
1161  SPState[BB->getNumber()] = SPAdj;
1162  }
1163 
1164  // Handle the unreachable blocks.
1165  for (auto &BB : MF) {
1166  if (Reachable.count(&BB))
1167  // Already handled in DFS traversal.
1168  continue;
1169  int SPAdj = 0;
1170  replaceFrameIndices(&BB, MF, SPAdj);
1171  }
1172 }
1173 
1174 void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
1175  int &SPAdj) {
1177  "getRegisterInfo() must be implemented!");
1178  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
1181 
1182  if (RS && FrameIndexEliminationScavenging)
1183  RS->enterBasicBlock(*BB);
1184 
1185  bool InsideCallSequence = false;
1186 
1187  for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
1188  if (TII.isFrameInstr(*I)) {
1189  InsideCallSequence = TII.isFrameSetup(*I);
1190  SPAdj += TII.getSPAdjust(*I);
1191  I = TFI->eliminateCallFramePseudoInstr(MF, *BB, I);
1192  continue;
1193  }
1194 
1195  MachineInstr &MI = *I;
1196  bool DoIncr = true;
1197  bool DidFinishLoop = true;
1198  for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1199  if (!MI.getOperand(i).isFI())
1200  continue;
1201 
1202  // Frame indices in debug values are encoded in a target independent
1203  // way with simply the frame index and offset rather than any
1204  // target-specific addressing mode.
1205  if (MI.isDebugValue()) {
1206  assert(i == 0 && "Frame indices can only appear as the first "
1207  "operand of a DBG_VALUE machine instruction");
1208  Register Reg;
1209  unsigned FrameIdx = MI.getOperand(0).getIndex();
1210  unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
1211 
1212  int64_t Offset =
1213  TFI->getFrameIndexReference(MF, FrameIdx, Reg);
1214  MI.getOperand(0).ChangeToRegister(Reg, false /*isDef*/);
1215  MI.getOperand(0).setIsDebug();
1216 
1217  const DIExpression *DIExpr = MI.getDebugExpression();
1218 
1219  // If we have a direct DBG_VALUE, and its location expression isn't
1220  // currently complex, then adding an offset will morph it into a
1221  // complex location that is interpreted as being a memory address.
1222  // This changes a pointer-valued variable to dereference that pointer,
1223  // which is incorrect. Fix by adding DW_OP_stack_value.
1224  unsigned PrependFlags = DIExpression::ApplyOffset;
1225  if (!MI.isIndirectDebugValue() && !DIExpr->isComplex())
1226  PrependFlags |= DIExpression::StackValue;
1227 
1228  // If we have DBG_VALUE that is indirect and has a Implicit location
1229  // expression need to insert a deref before prepending a Memory
1230  // location expression. Also after doing this we change the DBG_VALUE
1231  // to be direct.
1232  if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {
1233  SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
1234  bool WithStackValue = true;
1235  DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
1236  // Make the DBG_VALUE direct.
1237  MI.getDebugOffset().ChangeToRegister(0, false);
1238  }
1239  DIExpr = DIExpression::prepend(DIExpr, PrependFlags, Offset);
1240  MI.getDebugExpressionOp().setMetadata(DIExpr);
1241  continue;
1242  }
1243 
1244  // TODO: This code should be commoned with the code for
1245  // PATCHPOINT. There's no good reason for the difference in
1246  // implementation other than historical accident. The only
1247  // remaining difference is the unconditional use of the stack
1248  // pointer as the base register.
1249  if (MI.getOpcode() == TargetOpcode::STATEPOINT) {
1250  assert((!MI.isDebugValue() || i == 0) &&
1251  "Frame indicies can only appear as the first operand of a "
1252  "DBG_VALUE machine instruction");
1253  Register Reg;
1254  MachineOperand &Offset = MI.getOperand(i + 1);
1255  int refOffset = TFI->getFrameIndexReferencePreferSP(
1256  MF, MI.getOperand(i).getIndex(), Reg, /*IgnoreSPUpdates*/ false);
1257  Offset.setImm(Offset.getImm() + refOffset + SPAdj);
1258  MI.getOperand(i).ChangeToRegister(Reg, false /*isDef*/);
1259  continue;
1260  }
1261 
1262  // Some instructions (e.g. inline asm instructions) can have
1263  // multiple frame indices and/or cause eliminateFrameIndex
1264  // to insert more than one instruction. We need the register
1265  // scavenger to go through all of these instructions so that
1266  // it can update its register information. We keep the
1267  // iterator at the point before insertion so that we can
1268  // revisit them in full.
1269  bool AtBeginning = (I == BB->begin());
1270  if (!AtBeginning) --I;
1271 
1272  // If this instruction has a FrameIndex operand, we need to
1273  // use that target machine register info object to eliminate
1274  // it.
1275  TRI.eliminateFrameIndex(MI, SPAdj, i,
1276  FrameIndexEliminationScavenging ? RS : nullptr);
1277 
1278  // Reset the iterator if we were at the beginning of the BB.
1279  if (AtBeginning) {
1280  I = BB->begin();
1281  DoIncr = false;
1282  }
1283 
1284  DidFinishLoop = false;
1285  break;
1286  }
1287 
1288  // If we are looking at a call sequence, we need to keep track of
1289  // the SP adjustment made by each instruction in the sequence.
1290  // This includes both the frame setup/destroy pseudos (handled above),
1291  // as well as other instructions that have side effects w.r.t the SP.
1292  // Note that this must come after eliminateFrameIndex, because
1293  // if I itself referred to a frame index, we shouldn't count its own
1294  // adjustment.
1295  if (DidFinishLoop && InsideCallSequence)
1296  SPAdj += TII.getSPAdjust(MI);
1297 
1298  if (DoIncr && I != BB->end()) ++I;
1299 
1300  // Update register states.
1301  if (RS && FrameIndexEliminationScavenging && DidFinishLoop)
1302  RS->forward(MI);
1303  }
1304 }
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:372
virtual bool usesPhysRegsForValues() const
True if the target uses physical regs (as nearly all targets do).
virtual bool hasReservedSpillSlot(const MachineFunction &MF, Register 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)
void setRestorePoint(MachineBasicBlock *NewRestore)
virtual bool requiresRegisterScavenging(const MachineFunction &MF) const
Returns true if the target requires (and can make use of) the register scavenger. ...
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
bool isReserved(Register PhysReg) const
isReserved - Returns true when PhysReg is a reserved register.
virtual void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, Register 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...
void setCalleeSavedInfoValid(bool v)
static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B)
Check if fragments overlap between a pair of FragmentInfos.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:167
Align getMaxAlign() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
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...
bool hasStackProtectorIndex() const
Did not trigger a stack protector.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID&#39;s allocated.
static void updateLiveness(MachineFunction &MF)
Helper function to update the liveness information for the callee-saved registers.
const MachineFunctionProperties & getProperties() const
Get the function properties.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
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...
static void insertCSRSaves(MachineBasicBlock &SaveBlock, ArrayRef< CalleeSavedInfo > CSI)
Insert restore code for the callee-saved registers used in the function.
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const
canSimplifyCallFramePseudos - When possible, it&#39;s best to simplify the call frame pseudo ops before d...
int64_t getLocalFrameSize() const
Get the size of the local object blob.
unsigned Reg
bool test(unsigned Idx) const
Definition: BitVector.h:502
const MachineOperand & getDebugOffset() const
Return the operand containing the offset to be used if this DBG_VALUE instruction is indirect; will b...
Definition: MachineInstr.h:414
static bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, Align MaxAlign, BitVector &StackBytesFree)
Assign frame object to an unused portion of the stack in the fixed stack object range.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:330
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...
STATISTIC(NumFunctions, "Total number of functions")
unsigned const TargetRegisterInfo * TRI
A debug info location.
Definition: DebugLoc.h:33
F(f)
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
MachineModuleInfo & getMMI() const
unsigned getCallFrameDestroyOpcode() const
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:92
unsigned getSpillSize(const TargetRegisterClass &RC) const
Return the size in bytes of the stack slot allocated to hold a spilled copy of a register from class ...
iterator_range< succ_iterator > successors()
Function & getFunction()
Return the LLVM function that this machine code represents.
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
bool isVariableSizedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a variable sized object.
MachineBasicBlock & MBB
static DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
unsigned getSpillAlignment(const TargetRegisterClass &RC) const
Return the minimum required alignment in bytes for a spill slot for a register of this class...
virtual const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const
getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...
AnalysisUsage & addRequired()
void clear()
clear - Removes all bits from the bitvector. Does not change capacity.
Definition: BitVector.h:367
std::pair< int, int64_t > getLocalFrameObjectMap(int i) const
Get the local offset mapping for a for an object.
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction. ...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const HexagonInstrInfo * TII
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:459
MachineBasicBlock * getRestorePoint() const
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:332
virtual bool hasFP(const MachineFunction &MF) const =0
hasFP - Return true if the specified function should have a dedicated frame pointer register...
virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const
assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.
The address of this allocation is exposed and triggered protection.
virtual bool requiresFrameIndexScavenging(const MachineFunction &MF) const
Returns true if the target requires post PEI scavenging of registers for materializing frame index co...
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
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"))
int find_next(unsigned Prev) const
find_next - Returns the index of the next set bit following the "Prev" bit.
Definition: BitVector.h:340
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1505
This file contains the simple types necessary to represent the attributes associated with functions a...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:456
MachineFunctionPass * createPrologEpilogInserterPass()
virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const
Return the skew that has to be applied to stack alignment under certain conditions (e...
void scavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger &RS)
Replaces all frame index virtual registers with physical registers.
Diagnostic information for optimization analysis remarks.
bool getUseLocalStackAllocationBlock() const
Get whether the local allocation blob should be allocated together or let PEI allocate the locals in ...
static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign, unsigned Skew)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
virtual bool targetHandlesStackFrameRounding() const
targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:82
int getObjectIndexBegin() const
Return the minimum frame object index.
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
int getObjectIndexEnd() const
Return one past the maximum frame object index.
SSPLayoutKind getObjectSSPLayout(int ObjectIdx) const
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...
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they&#39;re not in a MachineFuncti...
virtual const TargetInstrInfo * getInstrInfo() const
static void stashEntryDbgValues(MachineBasicBlock &MBB, SavedDbgValuesMap &EntryDbgValues)
Stash DBG_VALUEs that describe parameters and which are placed at the start of the block...
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
unsigned getKillRegState(bool B)
virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to have the function use segmented stacks.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:19
TargetInstrInfo - Interface to description of machine instruction set.
Array or nested array >= SSP-buffer-size.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign, unsigned Skew)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
virtual void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
MachineOperand & getDebugExpressionOp()
Return the operand for the complex address expression referenced by this DBG_VALUE instruction...
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:434
This file declares the machine register scavenger class.
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
unsigned const MachineRegisterInfo * MRI
void initializePEIPass(PassRegistry &)
virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
virtual int getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1528
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.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void setStackSize(uint64_t Size)
Set the size of the stack.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:134
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
virtual void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, Register 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...
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:364
int getStackProtectorIndex() const
Return the index for the stack protector object.
virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, Register &FrameReg, bool IgnoreSPUpdates) const
Same as getFrameIndexReference, except that the stack pointer (as opposed to the frame pointer) will ...
unsigned getCallFrameSetupOpcode() const
These methods return the opcode of the frame setup/destroy instructions if they exist (-1 otherwise)...
bool isImplicit() const
Return whether this is an implicit location description.
Represent the analysis usage information of a pass.
df_ext_iterator< T, SetTy > df_ext_begin(const T &G, SetTy &S)
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:305
Align getTransientStackAlign() const
getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...
BitVector & reset()
Definition: BitVector.h:439
constexpr double e
Definition: MathExtras.h:58
void setImm(int64_t immVal)
static DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)
Prepend DIExpr with the given opcodes and optionally turn it into a stack value.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:375
static void assignCalleeSavedSpillSlots(MachineFunction &F, const BitVector &SavedRegs, unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex)
INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false, false) INITIALIZE_PASS_END(PEI
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn&#39;t already there.
Definition: SmallSet.h:180
Align getObjectAlign(int ObjectIdx) const
Return the alignment of the specified stack object.
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:252
Used in the streaming interface as the general argument type.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
const MachineBasicBlock & front() const
typename vector_type::const_iterator const_iterator
Definition: SetVector.h:49
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
void setCalleeSavedInfo(std::vector< CalleeSavedInfo > CSI)
Used by prolog/epilog inserter to set the function&#39;s callee saved information.
bool isComplex() const
Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:302
Iterator for intrusive lists based on ilist_node.
const TargetRegisterClass * getMinimalPhysRegClass(MCRegister Reg, MVT VT=MVT::Other) const
Returns the Register Class of a physical register of the given type, picking the most sub register cl...
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:439
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:350
unsigned getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call...
The optimization diagnostic interface.
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:219
virtual void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
bool isDebugValue() const
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:883
Prologue Epilogue Insertion &Frame Finalization
bool isFrameInstr(const MachineInstr &I) const
Returns true if the argument is a frame pseudo instruction.
Information about stack frame layout on the target.
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:420
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling...
static void insertCSRRestores(MachineBasicBlock &RestoreBlock, std::vector< CalleeSavedInfo > &CSI)
Insert restore code for the callee-saved registers used in the function.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
int64_t getFrameSize(const MachineInstr &I) const
Returns size of the frame associated with the given frame instruction.
int64_t getImm() const
virtual void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS=nullptr) const
processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...
void setMetadata(const MDNode *MD)
DWARF expression.
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...
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
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...
typename SuperClass::iterator iterator
Definition: SmallVector.h:365
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.
bool none() const
none - Returns true if none of the bits are set.
Definition: BitVector.h:202
#define DEBUG_TYPE
virtual bool isFPCloseToIncomingSP() const
isFPCloseToIncomingSP - Return true if the frame pointer is close to the incoming stack pointer...
Representation of each machine instruction.
Definition: MachineInstr.h:62
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...
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:158
virtual bool requiresFrameIndexReplacementScavenging(const MachineFunction &MF) const
Returns true if the target requires using the RegScavenger directly for frame elimination despite usi...
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
const MCInstrDesc & get(unsigned Opcode) const
Return the machine instruction descriptor that corresponds to the specified instruction opcode...
Definition: MCInstrInfo.h:62
TargetOptions Options
void push_back(MachineInstr *MI)
#define I(x, y, z)
Definition: MD5.cpp:59
void setMaxCallFrameSize(unsigned S)
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:72
void ChangeToRegister(Register 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...
virtual const TargetFrameLowering * getFrameLowering() const
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:170
uint32_t Size
Definition: Profile.cpp:46
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:145
virtual void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Replace a StackProbe stub (if any) with the actual probe code inline.
uint8_t getStackID(int ObjectIdx) const
Align getLocalFrameMaxAlign() const
Return the required alignment of the local object blob.
MachineBasicBlock * getSavePoint() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasProperty(Property P) const
int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)
Create a new statically sized stack object, returning a nonnegative identifier to represent 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...
Array or nested array < SSP-buffer-size.
virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
virtual void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &objectsToAllocate) const
Order the symbols in the local stack frame.
bool isMaxCallFrameSizeComputed() const
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
IRTranslator LLVM IR MI
auto reverse(ContainerTy &&C, std::enable_if_t< has_rbegin< ContainerTy >::value > *=nullptr)
Definition: STLExtras.h:341
void setIsDebug(bool Val=true)
#define LLVM_DEBUG(X)
Definition: Debug.h:122
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:466
int64_t getLocalFrameObjectCount() const
Return the number of objects allocated into the local object block.
bool isIndirectDebugValue() const
A DBG_VALUE is indirect iff the location operand is a register and the offset operand is an immediate...
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects...
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
bool hasCalls() const
Return true if the current function has any function calls.
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
void resize(size_type N)
Definition: SmallVector.h:390