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