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"
20 #include "llvm/ADT/DepthFirstIterator.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"
27 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
28 #include "llvm/CodeGen/MachineBasicBlock.h"
29 #include "llvm/CodeGen/MachineDominators.h"
30 #include "llvm/CodeGen/MachineFrameInfo.h"
31 #include "llvm/CodeGen/MachineFunction.h"
32 #include "llvm/CodeGen/MachineFunctionPass.h"
33 #include "llvm/CodeGen/MachineInstr.h"
34 #include "llvm/CodeGen/MachineInstrBuilder.h"
35 #include "llvm/CodeGen/MachineLoopInfo.h"
36 #include "llvm/CodeGen/MachineModuleInfo.h"
37 #include "llvm/CodeGen/MachineOperand.h"
38 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
39 #include "llvm/CodeGen/MachineRegisterInfo.h"
40 #include "llvm/CodeGen/RegisterScavenging.h"
41 #include "llvm/CodeGen/TargetFrameLowering.h"
42 #include "llvm/CodeGen/TargetInstrInfo.h"
43 #include "llvm/CodeGen/TargetOpcodes.h"
44 #include "llvm/CodeGen/TargetRegisterInfo.h"
45 #include "llvm/CodeGen/TargetSubtargetInfo.h"
46 #include "llvm/CodeGen/WinEHFuncInfo.h"
47 #include "llvm/IR/Attributes.h"
48 #include "llvm/IR/CallingConv.h"
49 #include "llvm/IR/DebugInfoMetadata.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"
58 #include "llvm/Support/CommandLine.h"
59 #include "llvm/Support/Debug.h"
60 #include "llvm/Support/ErrorHandling.h"
61 #include "llvm/Support/MathExtras.h"
62 #include "llvm/Support/raw_ostream.h"
63 #include "llvm/Target/TargetMachine.h"
64 #include "llvm/Target/TargetOptions.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
77 using MBBVector = SmallVector<MachineBasicBlock *, 4>;
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
PEI()89 PEI() : MachineFunctionPass(ID) {
90 initializePEIPass(*PassRegistry::getPassRegistry());
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
139 char &llvm::PrologEpilogCodeInserterID = PEI::ID;
140
141 static cl::opt<unsigned>
142 WarnStackSize("warn-stack-size", cl::Hidden, cl::init((unsigned)-1),
143 cl::desc("Warn for stack size bigger than the given"
144 " number"));
145
146 INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false,
147 false)
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)148 INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
149 INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
150 INITIALIZE_PASS_DEPENDENCY(MachineOptimizationRemarkEmitterPass)
151 INITIALIZE_PASS_END(PEI, DEBUG_TYPE,
152 "Prologue/Epilogue Insertion & Frame Finalization", false,
153 false)
154
155 MachineFunctionPass *llvm::createPrologEpilogInserterPass() {
156 return new PEI();
157 }
158
159 STATISTIC(NumBytesStackSpace,
160 "Number of bytes used for stack in all functions");
161
getAnalysisUsage(AnalysisUsage & AU) const162 void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
163 AU.setPreservesCFG();
164 AU.addPreserved<MachineLoopInfo>();
165 AU.addPreserved<MachineDominatorTree>();
166 AU.addRequired<MachineOptimizationRemarkEmitterPass>();
167 MachineFunctionPass::getAnalysisUsage(AU);
168 }
169
170 /// StackObjSet - A set of stack object indexes
171 using StackObjSet = SmallSetVector<int, 8>;
172
173 using SavedDbgValuesMap =
174 SmallDenseMap<MachineBasicBlock *, SmallVector<MachineInstr *, 4>, 4>;
175
176 /// Stash DBG_VALUEs that describe parameters and which are placed at the start
177 /// of the block. Later on, after the prologue code has been emitted, the
178 /// stashed DBG_VALUEs will be reinserted at the start of the block.
stashEntryDbgValues(MachineBasicBlock & MBB,SavedDbgValuesMap & EntryDbgValues)179 static void stashEntryDbgValues(MachineBasicBlock &MBB,
180 SavedDbgValuesMap &EntryDbgValues) {
181 SmallVector<const MachineInstr *, 4> FrameIndexValues;
182
183 for (auto &MI : MBB) {
184 if (!MI.isDebugInstr())
185 break;
186 if (!MI.isDebugValue() || !MI.getDebugVariable()->isParameter())
187 continue;
188 if (MI.getDebugOperand(0).isFI()) {
189 // We can only emit valid locations for frame indices after the frame
190 // setup, so do not stash away them.
191 FrameIndexValues.push_back(&MI);
192 continue;
193 }
194 const DILocalVariable *Var = MI.getDebugVariable();
195 const DIExpression *Expr = MI.getDebugExpression();
196 auto Overlaps = [Var, Expr](const MachineInstr *DV) {
197 return Var == DV->getDebugVariable() &&
198 Expr->fragmentsOverlap(DV->getDebugExpression());
199 };
200 // See if the debug value overlaps with any preceding debug value that will
201 // not be stashed. If that is the case, then we can't stash this value, as
202 // we would then reorder the values at reinsertion.
203 if (llvm::none_of(FrameIndexValues, Overlaps))
204 EntryDbgValues[&MBB].push_back(&MI);
205 }
206
207 // Remove stashed debug values from the block.
208 if (EntryDbgValues.count(&MBB))
209 for (auto *MI : EntryDbgValues[&MBB])
210 MI->removeFromParent();
211 }
212
213 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
214 /// frame indexes with appropriate references.
runOnMachineFunction(MachineFunction & MF)215 bool PEI::runOnMachineFunction(MachineFunction &MF) {
216 NumFuncSeen++;
217 const Function &F = MF.getFunction();
218 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
219 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
220
221 RS = TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : nullptr;
222 FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(MF);
223 ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
224
225 // Calculate the MaxCallFrameSize and AdjustsStack variables for the
226 // function's frame information. Also eliminates call frame pseudo
227 // instructions.
228 calculateCallFrameInfo(MF);
229
230 // Determine placement of CSR spill/restore code and prolog/epilog code:
231 // place all spills in the entry block, all restores in return blocks.
232 calculateSaveRestoreBlocks(MF);
233
234 // Stash away DBG_VALUEs that should not be moved by insertion of prolog code.
235 SavedDbgValuesMap EntryDbgValues;
236 for (MachineBasicBlock *SaveBlock : SaveBlocks)
237 stashEntryDbgValues(*SaveBlock, EntryDbgValues);
238
239 // Handle CSR spilling and restoring, for targets that need it.
240 if (MF.getTarget().usesPhysRegsForValues())
241 spillCalleeSavedRegs(MF);
242
243 // Allow the target machine to make final modifications to the function
244 // before the frame layout is finalized.
245 TFI->processFunctionBeforeFrameFinalized(MF, RS);
246
247 // Calculate actual frame offsets for all abstract stack objects...
248 calculateFrameObjectOffsets(MF);
249
250 // Add prolog and epilog code to the function. This function is required
251 // to align the stack frame as necessary for any stack variables or
252 // called functions. Because of this, calculateCalleeSavedRegisters()
253 // must be called before this function in order to set the AdjustsStack
254 // and MaxCallFrameSize variables.
255 if (!F.hasFnAttribute(Attribute::Naked))
256 insertPrologEpilogCode(MF);
257
258 // Reinsert stashed debug values at the start of the entry blocks.
259 for (auto &I : EntryDbgValues)
260 I.first->insert(I.first->begin(), I.second.begin(), I.second.end());
261
262 // Allow the target machine to make final modifications to the function
263 // before the frame layout is finalized.
264 TFI->processFunctionBeforeFrameIndicesReplaced(MF, RS);
265
266 // Replace all MO_FrameIndex operands with physical register references
267 // and actual offsets.
268 //
269 replaceFrameIndices(MF);
270
271 // If register scavenging is needed, as we've enabled doing it as a
272 // post-pass, scavenge the virtual registers that frame index elimination
273 // inserted.
274 if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)
275 scavengeFrameVirtualRegs(MF, *RS);
276
277 // Warn on stack size when we exceeds the given limit.
278 MachineFrameInfo &MFI = MF.getFrameInfo();
279 uint64_t StackSize = MFI.getStackSize();
280 if (WarnStackSize.getNumOccurrences() > 0 && WarnStackSize < StackSize) {
281 DiagnosticInfoStackSize DiagStackSize(F, StackSize);
282 F.getContext().diagnose(DiagStackSize);
283 }
284 ORE->emit([&]() {
285 return MachineOptimizationRemarkAnalysis(DEBUG_TYPE, "StackSize",
286 MF.getFunction().getSubprogram(),
287 &MF.front())
288 << ore::NV("NumStackBytes", StackSize) << " stack bytes in function";
289 });
290
291 delete RS;
292 SaveBlocks.clear();
293 RestoreBlocks.clear();
294 MFI.setSavePoint(nullptr);
295 MFI.setRestorePoint(nullptr);
296 return true;
297 }
298
299 /// Calculate the MaxCallFrameSize and AdjustsStack
300 /// variables for the function's frame information and eliminate call frame
301 /// pseudo instructions.
calculateCallFrameInfo(MachineFunction & MF)302 void PEI::calculateCallFrameInfo(MachineFunction &MF) {
303 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
304 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
305 MachineFrameInfo &MFI = MF.getFrameInfo();
306
307 unsigned MaxCallFrameSize = 0;
308 bool AdjustsStack = MFI.adjustsStack();
309
310 // Get the function call frame set-up and tear-down instruction opcode
311 unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
312 unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
313
314 // Early exit for targets which have no call frame setup/destroy pseudo
315 // instructions.
316 if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)
317 return;
318
319 std::vector<MachineBasicBlock::iterator> FrameSDOps;
320 for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); BB != E; ++BB)
321 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I)
322 if (TII.isFrameInstr(*I)) {
323 unsigned Size = TII.getFrameSize(*I);
324 if (Size > MaxCallFrameSize) MaxCallFrameSize = Size;
325 AdjustsStack = true;
326 FrameSDOps.push_back(I);
327 } else if (I->isInlineAsm()) {
328 // Some inline asm's need a stack frame, as indicated by operand 1.
329 unsigned ExtraInfo = I->getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
330 if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
331 AdjustsStack = true;
332 }
333
334 assert(!MFI.isMaxCallFrameSizeComputed() ||
335 (MFI.getMaxCallFrameSize() == MaxCallFrameSize &&
336 MFI.adjustsStack() == AdjustsStack));
337 MFI.setAdjustsStack(AdjustsStack);
338 MFI.setMaxCallFrameSize(MaxCallFrameSize);
339
340 for (std::vector<MachineBasicBlock::iterator>::iterator
341 i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) {
342 MachineBasicBlock::iterator I = *i;
343
344 // If call frames are not being included as part of the stack frame, and
345 // the target doesn't indicate otherwise, remove the call frame pseudos
346 // here. The sub/add sp instruction pairs are still inserted, but we don't
347 // need to track the SP adjustment for frame index elimination.
348 if (TFI->canSimplifyCallFramePseudos(MF))
349 TFI->eliminateCallFramePseudoInstr(MF, *I->getParent(), I);
350 }
351 }
352
353 /// Compute the sets of entry and return blocks for saving and restoring
354 /// callee-saved registers, and placing prolog and epilog code.
calculateSaveRestoreBlocks(MachineFunction & MF)355 void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
356 const MachineFrameInfo &MFI = MF.getFrameInfo();
357
358 // Even when we do not change any CSR, we still want to insert the
359 // prologue and epilogue of the function.
360 // So set the save points for those.
361
362 // Use the points found by shrink-wrapping, if any.
363 if (MFI.getSavePoint()) {
364 SaveBlocks.push_back(MFI.getSavePoint());
365 assert(MFI.getRestorePoint() && "Both restore and save must be set");
366 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
367 // If RestoreBlock does not have any successor and is not a return block
368 // then the end point is unreachable and we do not need to insert any
369 // epilogue.
370 if (!RestoreBlock->succ_empty() || RestoreBlock->isReturnBlock())
371 RestoreBlocks.push_back(RestoreBlock);
372 return;
373 }
374
375 // Save refs to entry and return blocks.
376 SaveBlocks.push_back(&MF.front());
377 for (MachineBasicBlock &MBB : MF) {
378 if (MBB.isEHFuncletEntry())
379 SaveBlocks.push_back(&MBB);
380 if (MBB.isReturnBlock())
381 RestoreBlocks.push_back(&MBB);
382 }
383 }
384
assignCalleeSavedSpillSlots(MachineFunction & F,const BitVector & SavedRegs,unsigned & MinCSFrameIndex,unsigned & MaxCSFrameIndex)385 static void assignCalleeSavedSpillSlots(MachineFunction &F,
386 const BitVector &SavedRegs,
387 unsigned &MinCSFrameIndex,
388 unsigned &MaxCSFrameIndex) {
389 if (SavedRegs.empty())
390 return;
391
392 const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
393 const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();
394
395 std::vector<CalleeSavedInfo> CSI;
396 for (unsigned i = 0; CSRegs[i]; ++i) {
397 unsigned Reg = CSRegs[i];
398 if (SavedRegs.test(Reg))
399 CSI.push_back(CalleeSavedInfo(Reg));
400 }
401
402 const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering();
403 MachineFrameInfo &MFI = F.getFrameInfo();
404 if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI)) {
405 // If target doesn't implement this, use generic code.
406
407 if (CSI.empty())
408 return; // Early exit if no callee saved registers are modified!
409
410 unsigned NumFixedSpillSlots;
411 const TargetFrameLowering::SpillSlot *FixedSpillSlots =
412 TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
413
414 // Now that we know which registers need to be saved and restored, allocate
415 // stack slots for them.
416 for (auto &CS : CSI) {
417 // If the target has spilled this register to another register, we don't
418 // need to allocate a stack slot.
419 if (CS.isSpilledToReg())
420 continue;
421
422 unsigned Reg = CS.getReg();
423 const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
424
425 int FrameIdx;
426 if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {
427 CS.setFrameIdx(FrameIdx);
428 continue;
429 }
430
431 // Check to see if this physreg must be spilled to a particular stack slot
432 // on this target.
433 const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
434 while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
435 FixedSlot->Reg != Reg)
436 ++FixedSlot;
437
438 unsigned Size = RegInfo->getSpillSize(*RC);
439 if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
440 // Nope, just spill it anywhere convenient.
441 Align Alignment(RegInfo->getSpillAlignment(*RC));
442 // We may not be able to satisfy the desired alignment specification of
443 // the TargetRegisterClass if the stack alignment is smaller. Use the
444 // min.
445 Alignment = std::min(Alignment, TFI->getStackAlign());
446 FrameIdx = MFI.CreateStackObject(Size, Alignment, true);
447 if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
448 if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
449 } else {
450 // Spill it to the stack where we must.
451 FrameIdx = MFI.CreateFixedSpillStackObject(Size, FixedSlot->Offset);
452 }
453
454 CS.setFrameIdx(FrameIdx);
455 }
456 }
457
458 MFI.setCalleeSavedInfo(CSI);
459 }
460
461 /// Helper function to update the liveness information for the callee-saved
462 /// registers.
updateLiveness(MachineFunction & MF)463 static void updateLiveness(MachineFunction &MF) {
464 MachineFrameInfo &MFI = MF.getFrameInfo();
465 // Visited will contain all the basic blocks that are in the region
466 // where the callee saved registers are alive:
467 // - Anything that is not Save or Restore -> LiveThrough.
468 // - Save -> LiveIn.
469 // - Restore -> LiveOut.
470 // The live-out is not attached to the block, so no need to keep
471 // Restore in this set.
472 SmallPtrSet<MachineBasicBlock *, 8> Visited;
473 SmallVector<MachineBasicBlock *, 8> WorkList;
474 MachineBasicBlock *Entry = &MF.front();
475 MachineBasicBlock *Save = MFI.getSavePoint();
476
477 if (!Save)
478 Save = Entry;
479
480 if (Entry != Save) {
481 WorkList.push_back(Entry);
482 Visited.insert(Entry);
483 }
484 Visited.insert(Save);
485
486 MachineBasicBlock *Restore = MFI.getRestorePoint();
487 if (Restore)
488 // By construction Restore cannot be visited, otherwise it
489 // means there exists a path to Restore that does not go
490 // through Save.
491 WorkList.push_back(Restore);
492
493 while (!WorkList.empty()) {
494 const MachineBasicBlock *CurBB = WorkList.pop_back_val();
495 // By construction, the region that is after the save point is
496 // dominated by the Save and post-dominated by the Restore.
497 if (CurBB == Save && Save != Restore)
498 continue;
499 // Enqueue all the successors not already visited.
500 // Those are by construction either before Save or after Restore.
501 for (MachineBasicBlock *SuccBB : CurBB->successors())
502 if (Visited.insert(SuccBB).second)
503 WorkList.push_back(SuccBB);
504 }
505
506 const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
507
508 MachineRegisterInfo &MRI = MF.getRegInfo();
509 for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
510 for (MachineBasicBlock *MBB : Visited) {
511 MCPhysReg Reg = CSI[i].getReg();
512 // Add the callee-saved register as live-in.
513 // It's killed at the spill.
514 if (!MRI.isReserved(Reg) && !MBB->isLiveIn(Reg))
515 MBB->addLiveIn(Reg);
516 }
517 // If callee-saved register is spilled to another register rather than
518 // spilling to stack, the destination register has to be marked as live for
519 // each MBB between the prologue and epilogue so that it is not clobbered
520 // before it is reloaded in the epilogue. The Visited set contains all
521 // blocks outside of the region delimited by prologue/epilogue.
522 if (CSI[i].isSpilledToReg()) {
523 for (MachineBasicBlock &MBB : MF) {
524 if (Visited.count(&MBB))
525 continue;
526 MCPhysReg DstReg = CSI[i].getDstReg();
527 if (!MBB.isLiveIn(DstReg))
528 MBB.addLiveIn(DstReg);
529 }
530 }
531 }
532
533 }
534
535 /// Insert restore code for the callee-saved registers used in the function.
insertCSRSaves(MachineBasicBlock & SaveBlock,ArrayRef<CalleeSavedInfo> CSI)536 static void insertCSRSaves(MachineBasicBlock &SaveBlock,
537 ArrayRef<CalleeSavedInfo> CSI) {
538 MachineFunction &MF = *SaveBlock.getParent();
539 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
540 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
541 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
542
543 MachineBasicBlock::iterator I = SaveBlock.begin();
544 if (!TFI->spillCalleeSavedRegisters(SaveBlock, I, CSI, TRI)) {
545 for (const CalleeSavedInfo &CS : CSI) {
546 // Insert the spill to the stack frame.
547 unsigned Reg = CS.getReg();
548
549 if (CS.isSpilledToReg()) {
550 BuildMI(SaveBlock, I, DebugLoc(),
551 TII.get(TargetOpcode::COPY), CS.getDstReg())
552 .addReg(Reg, getKillRegState(true));
553 } else {
554 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
555 TII.storeRegToStackSlot(SaveBlock, I, Reg, true, CS.getFrameIdx(), RC,
556 TRI);
557 }
558 }
559 }
560 }
561
562 /// Insert restore code for the callee-saved registers used in the function.
insertCSRRestores(MachineBasicBlock & RestoreBlock,std::vector<CalleeSavedInfo> & CSI)563 static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
564 std::vector<CalleeSavedInfo> &CSI) {
565 MachineFunction &MF = *RestoreBlock.getParent();
566 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
567 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
568 const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
569
570 // Restore all registers immediately before the return and any
571 // terminators that precede it.
572 MachineBasicBlock::iterator I = RestoreBlock.getFirstTerminator();
573
574 if (!TFI->restoreCalleeSavedRegisters(RestoreBlock, I, CSI, TRI)) {
575 for (const CalleeSavedInfo &CI : reverse(CSI)) {
576 unsigned Reg = CI.getReg();
577 if (CI.isSpilledToReg()) {
578 BuildMI(RestoreBlock, I, DebugLoc(), TII.get(TargetOpcode::COPY), Reg)
579 .addReg(CI.getDstReg(), getKillRegState(true));
580 } else {
581 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
582 TII.loadRegFromStackSlot(RestoreBlock, I, Reg, CI.getFrameIdx(), RC, TRI);
583 assert(I != RestoreBlock.begin() &&
584 "loadRegFromStackSlot didn't insert any code!");
585 // Insert in reverse order. loadRegFromStackSlot can insert
586 // multiple instructions.
587 }
588 }
589 }
590 }
591
spillCalleeSavedRegs(MachineFunction & MF)592 void PEI::spillCalleeSavedRegs(MachineFunction &MF) {
593 // We can't list this requirement in getRequiredProperties because some
594 // targets (WebAssembly) use virtual registers past this point, and the pass
595 // pipeline is set up without giving the passes a chance to look at the
596 // TargetMachine.
597 // FIXME: Find a way to express this in getRequiredProperties.
598 assert(MF.getProperties().hasProperty(
599 MachineFunctionProperties::Property::NoVRegs));
600
601 const Function &F = MF.getFunction();
602 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
603 MachineFrameInfo &MFI = MF.getFrameInfo();
604 MinCSFrameIndex = std::numeric_limits<unsigned>::max();
605 MaxCSFrameIndex = 0;
606
607 // Determine which of the registers in the callee save list should be saved.
608 BitVector SavedRegs;
609 TFI->determineCalleeSaves(MF, SavedRegs, RS);
610
611 // Assign stack slots for any callee-saved registers that must be spilled.
612 assignCalleeSavedSpillSlots(MF, SavedRegs, MinCSFrameIndex, MaxCSFrameIndex);
613
614 // Add the code to save and restore the callee saved registers.
615 if (!F.hasFnAttribute(Attribute::Naked)) {
616 MFI.setCalleeSavedInfoValid(true);
617
618 std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
619 if (!CSI.empty()) {
620 if (!MFI.hasCalls())
621 NumLeafFuncWithSpills++;
622
623 for (MachineBasicBlock *SaveBlock : SaveBlocks)
624 insertCSRSaves(*SaveBlock, CSI);
625
626 // Update the live-in information of all the blocks up to the save point.
627 updateLiveness(MF);
628
629 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
630 insertCSRRestores(*RestoreBlock, CSI);
631 }
632 }
633 }
634
635 /// AdjustStackOffset - Helper function used to adjust the stack frame offset.
AdjustStackOffset(MachineFrameInfo & MFI,int FrameIdx,bool StackGrowsDown,int64_t & Offset,Align & MaxAlign,unsigned Skew)636 static inline void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx,
637 bool StackGrowsDown, int64_t &Offset,
638 Align &MaxAlign, unsigned Skew) {
639 // If the stack grows down, add the object size to find the lowest address.
640 if (StackGrowsDown)
641 Offset += MFI.getObjectSize(FrameIdx);
642
643 Align Alignment = MFI.getObjectAlign(FrameIdx);
644
645 // If the alignment of this object is greater than that of the stack, then
646 // increase the stack alignment to match.
647 MaxAlign = std::max(MaxAlign, Alignment);
648
649 // Adjust to alignment boundary.
650 Offset = alignTo(Offset, Alignment, Skew);
651
652 if (StackGrowsDown) {
653 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset
654 << "]\n");
655 MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
656 } else {
657 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset
658 << "]\n");
659 MFI.setObjectOffset(FrameIdx, Offset);
660 Offset += MFI.getObjectSize(FrameIdx);
661 }
662 }
663
664 /// Compute which bytes of fixed and callee-save stack area are unused and keep
665 /// track of them in StackBytesFree.
666 static inline void
computeFreeStackSlots(MachineFrameInfo & MFI,bool StackGrowsDown,unsigned MinCSFrameIndex,unsigned MaxCSFrameIndex,int64_t FixedCSEnd,BitVector & StackBytesFree)667 computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown,
668 unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex,
669 int64_t FixedCSEnd, BitVector &StackBytesFree) {
670 // Avoid undefined int64_t -> int conversion below in extreme case.
671 if (FixedCSEnd > std::numeric_limits<int>::max())
672 return;
673
674 StackBytesFree.resize(FixedCSEnd, true);
675
676 SmallVector<int, 16> AllocatedFrameSlots;
677 // Add fixed objects.
678 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i)
679 // StackSlot scavenging is only implemented for the default stack.
680 if (MFI.getStackID(i) == TargetStackID::Default)
681 AllocatedFrameSlots.push_back(i);
682 // Add callee-save objects.
683 for (int i = MinCSFrameIndex; i <= (int)MaxCSFrameIndex; ++i)
684 if (MFI.getStackID(i) == TargetStackID::Default)
685 AllocatedFrameSlots.push_back(i);
686
687 for (int i : AllocatedFrameSlots) {
688 // These are converted from int64_t, but they should always fit in int
689 // because of the FixedCSEnd check above.
690 int ObjOffset = MFI.getObjectOffset(i);
691 int ObjSize = MFI.getObjectSize(i);
692 int ObjStart, ObjEnd;
693 if (StackGrowsDown) {
694 // ObjOffset is negative when StackGrowsDown is true.
695 ObjStart = -ObjOffset - ObjSize;
696 ObjEnd = -ObjOffset;
697 } else {
698 ObjStart = ObjOffset;
699 ObjEnd = ObjOffset + ObjSize;
700 }
701 // Ignore fixed holes that are in the previous stack frame.
702 if (ObjEnd > 0)
703 StackBytesFree.reset(ObjStart, ObjEnd);
704 }
705 }
706
707 /// Assign frame object to an unused portion of the stack in the fixed stack
708 /// object range. Return true if the allocation was successful.
scavengeStackSlot(MachineFrameInfo & MFI,int FrameIdx,bool StackGrowsDown,Align MaxAlign,BitVector & StackBytesFree)709 static inline bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx,
710 bool StackGrowsDown, Align MaxAlign,
711 BitVector &StackBytesFree) {
712 if (MFI.isVariableSizedObjectIndex(FrameIdx))
713 return false;
714
715 if (StackBytesFree.none()) {
716 // clear it to speed up later scavengeStackSlot calls to
717 // StackBytesFree.none()
718 StackBytesFree.clear();
719 return false;
720 }
721
722 Align ObjAlign = MFI.getObjectAlign(FrameIdx);
723 if (ObjAlign > MaxAlign)
724 return false;
725
726 int64_t ObjSize = MFI.getObjectSize(FrameIdx);
727 int FreeStart;
728 for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;
729 FreeStart = StackBytesFree.find_next(FreeStart)) {
730
731 // Check that free space has suitable alignment.
732 unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;
733 if (alignTo(ObjStart, ObjAlign) != ObjStart)
734 continue;
735
736 if (FreeStart + ObjSize > StackBytesFree.size())
737 return false;
738
739 bool AllBytesFree = true;
740 for (unsigned Byte = 0; Byte < ObjSize; ++Byte)
741 if (!StackBytesFree.test(FreeStart + Byte)) {
742 AllBytesFree = false;
743 break;
744 }
745 if (AllBytesFree)
746 break;
747 }
748
749 if (FreeStart == -1)
750 return false;
751
752 if (StackGrowsDown) {
753 int ObjStart = -(FreeStart + ObjSize);
754 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
755 << ObjStart << "]\n");
756 MFI.setObjectOffset(FrameIdx, ObjStart);
757 } else {
758 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
759 << FreeStart << "]\n");
760 MFI.setObjectOffset(FrameIdx, FreeStart);
761 }
762
763 StackBytesFree.reset(FreeStart, FreeStart + ObjSize);
764 return true;
765 }
766
767 /// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
768 /// those required to be close to the Stack Protector) to stack offsets.
AssignProtectedObjSet(const StackObjSet & UnassignedObjs,SmallSet<int,16> & ProtectedObjs,MachineFrameInfo & MFI,bool StackGrowsDown,int64_t & Offset,Align & MaxAlign,unsigned Skew)769 static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
770 SmallSet<int, 16> &ProtectedObjs,
771 MachineFrameInfo &MFI, bool StackGrowsDown,
772 int64_t &Offset, Align &MaxAlign,
773 unsigned Skew) {
774
775 for (StackObjSet::const_iterator I = UnassignedObjs.begin(),
776 E = UnassignedObjs.end(); I != E; ++I) {
777 int i = *I;
778 AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign, Skew);
779 ProtectedObjs.insert(i);
780 }
781 }
782
783 /// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
784 /// abstract stack objects.
calculateFrameObjectOffsets(MachineFunction & MF)785 void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
786 const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
787
788 bool StackGrowsDown =
789 TFI.getStackGrowthDirection() == TargetFrameLowering::StackGrowsDown;
790
791 // Loop over all of the stack objects, assigning sequential addresses...
792 MachineFrameInfo &MFI = MF.getFrameInfo();
793
794 // Start at the beginning of the local area.
795 // The Offset is the distance from the stack top in the direction
796 // of stack growth -- so it's always nonnegative.
797 int LocalAreaOffset = TFI.getOffsetOfLocalArea();
798 if (StackGrowsDown)
799 LocalAreaOffset = -LocalAreaOffset;
800 assert(LocalAreaOffset >= 0
801 && "Local area offset should be in direction of stack growth");
802 int64_t Offset = LocalAreaOffset;
803
804 // Skew to be applied to alignment.
805 unsigned Skew = TFI.getStackAlignmentSkew(MF);
806
807 #ifdef EXPENSIVE_CHECKS
808 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i)
809 if (!MFI.isDeadObjectIndex(i) &&
810 MFI.getStackID(i) == TargetStackID::Default)
811 assert(MFI.getObjectAlign(i) <= MFI.getMaxAlign() &&
812 "MaxAlignment is invalid");
813 #endif
814
815 // If there are fixed sized objects that are preallocated in the local area,
816 // non-fixed objects can't be allocated right at the start of local area.
817 // Adjust 'Offset' to point to the end of last fixed sized preallocated
818 // object.
819 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
820 if (MFI.getStackID(i) !=
821 TargetStackID::Default) // Only allocate objects on the default stack.
822 continue;
823
824 int64_t FixedOff;
825 if (StackGrowsDown) {
826 // The maximum distance from the stack pointer is at lower address of
827 // the object -- which is given by offset. For down growing stack
828 // the offset is negative, so we negate the offset to get the distance.
829 FixedOff = -MFI.getObjectOffset(i);
830 } else {
831 // The maximum distance from the start pointer is at the upper
832 // address of the object.
833 FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
834 }
835 if (FixedOff > Offset) Offset = FixedOff;
836 }
837
838 // First assign frame offsets to stack objects that are used to spill
839 // callee saved registers.
840 if (StackGrowsDown) {
841 for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) {
842 if (MFI.getStackID(i) !=
843 TargetStackID::Default) // Only allocate objects on the default stack.
844 continue;
845
846 // If the stack grows down, we need to add the size to find the lowest
847 // address of the object.
848 Offset += MFI.getObjectSize(i);
849
850 // Adjust to alignment boundary
851 Offset = alignTo(Offset, MFI.getObjectAlign(i), Skew);
852
853 LLVM_DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << -Offset << "]\n");
854 MFI.setObjectOffset(i, -Offset); // Set the computed offset
855 }
856 } else if (MaxCSFrameIndex >= MinCSFrameIndex) {
857 // Be careful about underflow in comparisons agains MinCSFrameIndex.
858 for (unsigned i = MaxCSFrameIndex; i != MinCSFrameIndex - 1; --i) {
859 if (MFI.getStackID(i) !=
860 TargetStackID::Default) // Only allocate objects on the default stack.
861 continue;
862
863 if (MFI.isDeadObjectIndex(i))
864 continue;
865
866 // Adjust to alignment boundary
867 Offset = alignTo(Offset, MFI.getObjectAlign(i), Skew);
868
869 LLVM_DEBUG(dbgs() << "alloc FI(" << i << ") at SP[" << Offset << "]\n");
870 MFI.setObjectOffset(i, Offset);
871 Offset += MFI.getObjectSize(i);
872 }
873 }
874
875 // FixedCSEnd is the stack offset to the end of the fixed and callee-save
876 // stack area.
877 int64_t FixedCSEnd = Offset;
878 Align MaxAlign = MFI.getMaxAlign();
879
880 // Make sure the special register scavenging spill slot is closest to the
881 // incoming stack pointer if a frame pointer is required and is closer
882 // to the incoming rather than the final stack pointer.
883 const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
884 bool EarlyScavengingSlots = (TFI.hasFP(MF) &&
885 TFI.isFPCloseToIncomingSP() &&
886 RegInfo->useFPForScavengingIndex(MF) &&
887 !RegInfo->needsStackRealignment(MF));
888 if (RS && EarlyScavengingSlots) {
889 SmallVector<int, 2> SFIs;
890 RS->getScavengingFrameIndices(SFIs);
891 for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
892 IE = SFIs.end(); I != IE; ++I)
893 AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
894 }
895
896 // FIXME: Once this is working, then enable flag will change to a target
897 // check for whether the frame is large enough to want to use virtual
898 // frame index registers. Functions which don't want/need this optimization
899 // will continue to use the existing code path.
900 if (MFI.getUseLocalStackAllocationBlock()) {
901 Align Alignment = MFI.getLocalFrameMaxAlign();
902
903 // Adjust to alignment boundary.
904 Offset = alignTo(Offset, Alignment, Skew);
905
906 LLVM_DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
907
908 // Resolve offsets for objects in the local block.
909 for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
910 std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
911 int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
912 LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset
913 << "]\n");
914 MFI.setObjectOffset(Entry.first, FIOffset);
915 }
916 // Allocate the local block
917 Offset += MFI.getLocalFrameSize();
918
919 MaxAlign = std::max(Alignment, MaxAlign);
920 }
921
922 // Retrieve the Exception Handler registration node.
923 int EHRegNodeFrameIndex = std::numeric_limits<int>::max();
924 if (const WinEHFuncInfo *FuncInfo = MF.getWinEHFuncInfo())
925 EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;
926
927 // Make sure that the stack protector comes before the local variables on the
928 // stack.
929 SmallSet<int, 16> ProtectedObjs;
930 if (MFI.hasStackProtectorIndex()) {
931 int StackProtectorFI = MFI.getStackProtectorIndex();
932 StackObjSet LargeArrayObjs;
933 StackObjSet SmallArrayObjs;
934 StackObjSet AddrOfObjs;
935
936 // If we need a stack protector, we need to make sure that
937 // LocalStackSlotPass didn't already allocate a slot for it.
938 // If we are told to use the LocalStackAllocationBlock, the stack protector
939 // is expected to be already pre-allocated.
940 if (!MFI.getUseLocalStackAllocationBlock())
941 AdjustStackOffset(MFI, StackProtectorFI, StackGrowsDown, Offset, MaxAlign,
942 Skew);
943 else if (!MFI.isObjectPreAllocated(MFI.getStackProtectorIndex()))
944 llvm_unreachable(
945 "Stack protector not pre-allocated by LocalStackSlotPass.");
946
947 // Assign large stack objects first.
948 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
949 if (MFI.isObjectPreAllocated(i) && MFI.getUseLocalStackAllocationBlock())
950 continue;
951 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
952 continue;
953 if (RS && RS->isScavengingFrameIndex((int)i))
954 continue;
955 if (MFI.isDeadObjectIndex(i))
956 continue;
957 if (StackProtectorFI == (int)i || EHRegNodeFrameIndex == (int)i)
958 continue;
959 if (MFI.getStackID(i) !=
960 TargetStackID::Default) // Only allocate objects on the default stack.
961 continue;
962
963 switch (MFI.getObjectSSPLayout(i)) {
964 case MachineFrameInfo::SSPLK_None:
965 continue;
966 case MachineFrameInfo::SSPLK_SmallArray:
967 SmallArrayObjs.insert(i);
968 continue;
969 case MachineFrameInfo::SSPLK_AddrOf:
970 AddrOfObjs.insert(i);
971 continue;
972 case MachineFrameInfo::SSPLK_LargeArray:
973 LargeArrayObjs.insert(i);
974 continue;
975 }
976 llvm_unreachable("Unexpected SSPLayoutKind.");
977 }
978
979 // We expect **all** the protected stack objects to be pre-allocated by
980 // LocalStackSlotPass. If it turns out that PEI still has to allocate some
981 // of them, we may end up messing up the expected order of the objects.
982 if (MFI.getUseLocalStackAllocationBlock() &&
983 !(LargeArrayObjs.empty() && SmallArrayObjs.empty() &&
984 AddrOfObjs.empty()))
985 llvm_unreachable("Found protected stack objects not pre-allocated by "
986 "LocalStackSlotPass.");
987
988 AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
989 Offset, MaxAlign, Skew);
990 AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
991 Offset, MaxAlign, Skew);
992 AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
993 Offset, MaxAlign, Skew);
994 }
995
996 SmallVector<int, 8> ObjectsToAllocate;
997
998 // Then prepare to assign frame offsets to stack objects that are not used to
999 // spill callee saved registers.
1000 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1001 if (MFI.isObjectPreAllocated(i) && MFI.getUseLocalStackAllocationBlock())
1002 continue;
1003 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1004 continue;
1005 if (RS && RS->isScavengingFrameIndex((int)i))
1006 continue;
1007 if (MFI.isDeadObjectIndex(i))
1008 continue;
1009 if (MFI.getStackProtectorIndex() == (int)i || EHRegNodeFrameIndex == (int)i)
1010 continue;
1011 if (ProtectedObjs.count(i))
1012 continue;
1013 if (MFI.getStackID(i) !=
1014 TargetStackID::Default) // Only allocate objects on the default stack.
1015 continue;
1016
1017 // Add the objects that we need to allocate to our working set.
1018 ObjectsToAllocate.push_back(i);
1019 }
1020
1021 // Allocate the EH registration node first if one is present.
1022 if (EHRegNodeFrameIndex != std::numeric_limits<int>::max())
1023 AdjustStackOffset(MFI, EHRegNodeFrameIndex, StackGrowsDown, Offset,
1024 MaxAlign, Skew);
1025
1026 // Give the targets a chance to order the objects the way they like it.
1027 if (MF.getTarget().getOptLevel() != CodeGenOpt::None &&
1028 MF.getTarget().Options.StackSymbolOrdering)
1029 TFI.orderFrameObjects(MF, ObjectsToAllocate);
1030
1031 // Keep track of which bytes in the fixed and callee-save range are used so we
1032 // can use the holes when allocating later stack objects. Only do this if
1033 // stack protector isn't being used and the target requests it and we're
1034 // optimizing.
1035 BitVector StackBytesFree;
1036 if (!ObjectsToAllocate.empty() &&
1037 MF.getTarget().getOptLevel() != CodeGenOpt::None &&
1038 MFI.getStackProtectorIndex() < 0 && TFI.enableStackSlotScavenging(MF))
1039 computeFreeStackSlots(MFI, StackGrowsDown, MinCSFrameIndex, MaxCSFrameIndex,
1040 FixedCSEnd, StackBytesFree);
1041
1042 // Now walk the objects and actually assign base offsets to them.
1043 for (auto &Object : ObjectsToAllocate)
1044 if (!scavengeStackSlot(MFI, Object, StackGrowsDown, MaxAlign,
1045 StackBytesFree))
1046 AdjustStackOffset(MFI, Object, StackGrowsDown, Offset, MaxAlign, Skew);
1047
1048 // Make sure the special register scavenging spill slot is closest to the
1049 // stack pointer.
1050 if (RS && !EarlyScavengingSlots) {
1051 SmallVector<int, 2> SFIs;
1052 RS->getScavengingFrameIndices(SFIs);
1053 for (SmallVectorImpl<int>::iterator I = SFIs.begin(),
1054 IE = SFIs.end(); I != IE; ++I)
1055 AdjustStackOffset(MFI, *I, StackGrowsDown, Offset, MaxAlign, Skew);
1056 }
1057
1058 if (!TFI.targetHandlesStackFrameRounding()) {
1059 // If we have reserved argument space for call sites in the function
1060 // immediately on entry to the current function, count it as part of the
1061 // overall stack size.
1062 if (MFI.adjustsStack() && TFI.hasReservedCallFrame(MF))
1063 Offset += MFI.getMaxCallFrameSize();
1064
1065 // Round up the size to a multiple of the alignment. If the function has
1066 // any calls or alloca's, align to the target's StackAlignment value to
1067 // ensure that the callee's frame or the alloca data is suitably aligned;
1068 // otherwise, for leaf functions, align to the TransientStackAlignment
1069 // value.
1070 Align StackAlign;
1071 if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
1072 (RegInfo->needsStackRealignment(MF) && MFI.getObjectIndexEnd() != 0))
1073 StackAlign = TFI.getStackAlign();
1074 else
1075 StackAlign = TFI.getTransientStackAlign();
1076
1077 // If the frame pointer is eliminated, all frame offsets will be relative to
1078 // SP not FP. Align to MaxAlign so this works.
1079 StackAlign = std::max(StackAlign, MaxAlign);
1080 int64_t OffsetBeforeAlignment = Offset;
1081 Offset = alignTo(Offset, StackAlign, Skew);
1082
1083 // If we have increased the offset to fulfill the alignment constrants,
1084 // then the scavenging spill slots may become harder to reach from the
1085 // stack pointer, float them so they stay close.
1086 if (OffsetBeforeAlignment != Offset && RS && !EarlyScavengingSlots) {
1087 SmallVector<int, 2> SFIs;
1088 RS->getScavengingFrameIndices(SFIs);
1089 LLVM_DEBUG(if (!SFIs.empty()) llvm::dbgs()
1090 << "Adjusting emergency spill slots!\n";);
1091 int64_t Delta = Offset - OffsetBeforeAlignment;
1092 for (SmallVectorImpl<int>::iterator I = SFIs.begin(), IE = SFIs.end();
1093 I != IE; ++I) {
1094 LLVM_DEBUG(llvm::dbgs() << "Adjusting offset of emergency spill slot #"
1095 << *I << " from " << MFI.getObjectOffset(*I););
1096 MFI.setObjectOffset(*I, MFI.getObjectOffset(*I) - Delta);
1097 LLVM_DEBUG(llvm::dbgs() << " to " << MFI.getObjectOffset(*I) << "\n";);
1098 }
1099 }
1100 }
1101
1102 // Update frame info to pretend that this is part of the stack...
1103 int64_t StackSize = Offset - LocalAreaOffset;
1104 MFI.setStackSize(StackSize);
1105 NumBytesStackSpace += StackSize;
1106 }
1107
1108 /// insertPrologEpilogCode - Scan the function for modified callee saved
1109 /// registers, insert spill code for these callee saved registers, then add
1110 /// prolog and epilog code to the function.
insertPrologEpilogCode(MachineFunction & MF)1111 void PEI::insertPrologEpilogCode(MachineFunction &MF) {
1112 const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
1113
1114 // Add prologue to the function...
1115 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1116 TFI.emitPrologue(MF, *SaveBlock);
1117
1118 // Add epilogue to restore the callee-save registers in each exiting block.
1119 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1120 TFI.emitEpilogue(MF, *RestoreBlock);
1121
1122 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1123 TFI.inlineStackProbe(MF, *SaveBlock);
1124
1125 // Emit additional code that is required to support segmented stacks, if
1126 // we've been asked for it. This, when linked with a runtime with support
1127 // for segmented stacks (libgcc is one), will result in allocating stack
1128 // space in small chunks instead of one large contiguous block.
1129 if (MF.shouldSplitStack()) {
1130 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1131 TFI.adjustForSegmentedStacks(MF, *SaveBlock);
1132 // Record that there are split-stack functions, so we will emit a
1133 // special section to tell the linker.
1134 MF.getMMI().setHasSplitStack(true);
1135 } else
1136 MF.getMMI().setHasNosplitStack(true);
1137
1138 // Emit additional code that is required to explicitly handle the stack in
1139 // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
1140 // approach is rather similar to that of Segmented Stacks, but it uses a
1141 // different conditional check and another BIF for allocating more stack
1142 // space.
1143 if (MF.getFunction().getCallingConv() == CallingConv::HiPE)
1144 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1145 TFI.adjustForHiPEPrologue(MF, *SaveBlock);
1146 }
1147
1148 /// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
1149 /// register references and actual offsets.
replaceFrameIndices(MachineFunction & MF)1150 void PEI::replaceFrameIndices(MachineFunction &MF) {
1151 const auto &ST = MF.getSubtarget();
1152 const TargetFrameLowering &TFI = *ST.getFrameLowering();
1153 if (!TFI.needsFrameIndexResolution(MF))
1154 return;
1155
1156 const TargetRegisterInfo *TRI = ST.getRegisterInfo();
1157
1158 // Allow the target to determine this after knowing the frame size.
1159 FrameIndexEliminationScavenging = (RS && !FrameIndexVirtualScavenging) ||
1160 TRI->requiresFrameIndexReplacementScavenging(MF);
1161
1162 // Store SPAdj at exit of a basic block.
1163 SmallVector<int, 8> SPState;
1164 SPState.resize(MF.getNumBlockIDs());
1165 df_iterator_default_set<MachineBasicBlock*> Reachable;
1166
1167 // Iterate over the reachable blocks in DFS order.
1168 for (auto DFI = df_ext_begin(&MF, Reachable), DFE = df_ext_end(&MF, Reachable);
1169 DFI != DFE; ++DFI) {
1170 int SPAdj = 0;
1171 // Check the exit state of the DFS stack predecessor.
1172 if (DFI.getPathLength() >= 2) {
1173 MachineBasicBlock *StackPred = DFI.getPath(DFI.getPathLength() - 2);
1174 assert(Reachable.count(StackPred) &&
1175 "DFS stack predecessor is already visited.\n");
1176 SPAdj = SPState[StackPred->getNumber()];
1177 }
1178 MachineBasicBlock *BB = *DFI;
1179 replaceFrameIndices(BB, MF, SPAdj);
1180 SPState[BB->getNumber()] = SPAdj;
1181 }
1182
1183 // Handle the unreachable blocks.
1184 for (auto &BB : MF) {
1185 if (Reachable.count(&BB))
1186 // Already handled in DFS traversal.
1187 continue;
1188 int SPAdj = 0;
1189 replaceFrameIndices(&BB, MF, SPAdj);
1190 }
1191 }
1192
replaceFrameIndices(MachineBasicBlock * BB,MachineFunction & MF,int & SPAdj)1193 void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
1194 int &SPAdj) {
1195 assert(MF.getSubtarget().getRegisterInfo() &&
1196 "getRegisterInfo() must be implemented!");
1197 const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
1198 const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo();
1199 const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
1200
1201 if (RS && FrameIndexEliminationScavenging)
1202 RS->enterBasicBlock(*BB);
1203
1204 bool InsideCallSequence = false;
1205
1206 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
1207 if (TII.isFrameInstr(*I)) {
1208 InsideCallSequence = TII.isFrameSetup(*I);
1209 SPAdj += TII.getSPAdjust(*I);
1210 I = TFI->eliminateCallFramePseudoInstr(MF, *BB, I);
1211 continue;
1212 }
1213
1214 MachineInstr &MI = *I;
1215 bool DoIncr = true;
1216 bool DidFinishLoop = true;
1217 for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1218 if (!MI.getOperand(i).isFI())
1219 continue;
1220
1221 // Frame indices in debug values are encoded in a target independent
1222 // way with simply the frame index and offset rather than any
1223 // target-specific addressing mode.
1224 if (MI.isDebugValue()) {
1225 assert(i == 0 && "Frame indices can only appear as the first "
1226 "operand of a DBG_VALUE machine instruction");
1227 Register Reg;
1228 unsigned FrameIdx = MI.getOperand(0).getIndex();
1229 unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
1230
1231 StackOffset Offset =
1232 TFI->getFrameIndexReference(MF, FrameIdx, Reg);
1233 MI.getOperand(0).ChangeToRegister(Reg, false /*isDef*/);
1234 MI.getOperand(0).setIsDebug();
1235
1236 const DIExpression *DIExpr = MI.getDebugExpression();
1237
1238 // If we have a direct DBG_VALUE, and its location expression isn't
1239 // currently complex, then adding an offset will morph it into a
1240 // complex location that is interpreted as being a memory address.
1241 // This changes a pointer-valued variable to dereference that pointer,
1242 // which is incorrect. Fix by adding DW_OP_stack_value.
1243 unsigned PrependFlags = DIExpression::ApplyOffset;
1244 if (!MI.isIndirectDebugValue() && !DIExpr->isComplex())
1245 PrependFlags |= DIExpression::StackValue;
1246
1247 // If we have DBG_VALUE that is indirect and has a Implicit location
1248 // expression need to insert a deref before prepending a Memory
1249 // location expression. Also after doing this we change the DBG_VALUE
1250 // to be direct.
1251 if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {
1252 SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
1253 bool WithStackValue = true;
1254 DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
1255 // Make the DBG_VALUE direct.
1256 MI.getDebugOffset().ChangeToRegister(0, false);
1257 }
1258
1259 DIExpr = TRI.prependOffsetExpression(DIExpr, PrependFlags, Offset);
1260 MI.getDebugExpressionOp().setMetadata(DIExpr);
1261 continue;
1262 }
1263
1264 // TODO: This code should be commoned with the code for
1265 // PATCHPOINT. There's no good reason for the difference in
1266 // implementation other than historical accident. The only
1267 // remaining difference is the unconditional use of the stack
1268 // pointer as the base register.
1269 if (MI.getOpcode() == TargetOpcode::STATEPOINT) {
1270 assert((!MI.isDebugValue() || i == 0) &&
1271 "Frame indicies can only appear as the first operand of a "
1272 "DBG_VALUE machine instruction");
1273 Register Reg;
1274 MachineOperand &Offset = MI.getOperand(i + 1);
1275 StackOffset refOffset = TFI->getFrameIndexReferencePreferSP(
1276 MF, MI.getOperand(i).getIndex(), Reg, /*IgnoreSPUpdates*/ false);
1277 assert(!refOffset.getScalable() &&
1278 "Frame offsets with a scalable component are not supported");
1279 Offset.setImm(Offset.getImm() + refOffset.getFixed() + SPAdj);
1280 MI.getOperand(i).ChangeToRegister(Reg, false /*isDef*/);
1281 continue;
1282 }
1283
1284 // Some instructions (e.g. inline asm instructions) can have
1285 // multiple frame indices and/or cause eliminateFrameIndex
1286 // to insert more than one instruction. We need the register
1287 // scavenger to go through all of these instructions so that
1288 // it can update its register information. We keep the
1289 // iterator at the point before insertion so that we can
1290 // revisit them in full.
1291 bool AtBeginning = (I == BB->begin());
1292 if (!AtBeginning) --I;
1293
1294 // If this instruction has a FrameIndex operand, we need to
1295 // use that target machine register info object to eliminate
1296 // it.
1297 TRI.eliminateFrameIndex(MI, SPAdj, i,
1298 FrameIndexEliminationScavenging ? RS : nullptr);
1299
1300 // Reset the iterator if we were at the beginning of the BB.
1301 if (AtBeginning) {
1302 I = BB->begin();
1303 DoIncr = false;
1304 }
1305
1306 DidFinishLoop = false;
1307 break;
1308 }
1309
1310 // If we are looking at a call sequence, we need to keep track of
1311 // the SP adjustment made by each instruction in the sequence.
1312 // This includes both the frame setup/destroy pseudos (handled above),
1313 // as well as other instructions that have side effects w.r.t the SP.
1314 // Note that this must come after eliminateFrameIndex, because
1315 // if I itself referred to a frame index, we shouldn't count its own
1316 // adjustment.
1317 if (DidFinishLoop && InsideCallSequence)
1318 SPAdj += TII.getSPAdjust(MI);
1319
1320 if (DoIncr && I != BB->end()) ++I;
1321
1322 // Update register states.
1323 if (RS && FrameIndexEliminationScavenging && DidFinishLoop)
1324 RS->forward(MI);
1325 }
1326 }
1327