LLVM 20.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"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/ADT/SetVector.h"
23#include "llvm/ADT/SmallSet.h"
25#include "llvm/ADT/Statistic.h"
46#include "llvm/IR/Attributes.h"
47#include "llvm/IR/CallingConv.h"
50#include "llvm/IR/Function.h"
51#include "llvm/IR/InlineAsm.h"
52#include "llvm/IR/LLVMContext.h"
55#include "llvm/Pass.h"
57#include "llvm/Support/Debug.h"
63#include <algorithm>
64#include <cassert>
65#include <cstdint>
66#include <functional>
67#include <limits>
68#include <utility>
69#include <vector>
70
71using namespace llvm;
72
73#define DEBUG_TYPE "prologepilog"
74
76
77STATISTIC(NumLeafFuncWithSpills, "Number of leaf functions with CSRs");
78STATISTIC(NumFuncSeen, "Number of functions seen in PEI");
79
80
81namespace {
82
83class PEI : public MachineFunctionPass {
84public:
85 static char ID;
86
87 PEI() : MachineFunctionPass(ID) {
89 }
90
91 void getAnalysisUsage(AnalysisUsage &AU) const override;
92
93 /// runOnMachineFunction - Insert prolog/epilog code and replace abstract
94 /// frame indexes with appropriate references.
95 bool runOnMachineFunction(MachineFunction &MF) override;
96
97private:
98 RegScavenger *RS = nullptr;
99
100 // MinCSFrameIndex, MaxCSFrameIndex - Keeps the range of callee saved
101 // stack frame indexes.
102 unsigned MinCSFrameIndex = std::numeric_limits<unsigned>::max();
103 unsigned MaxCSFrameIndex = 0;
104
105 // Save and Restore blocks of the current function. Typically there is a
106 // single save block, unless Windows EH funclets are involved.
107 MBBVector SaveBlocks;
108 MBBVector RestoreBlocks;
109
110 // Flag to control whether to use the register scavenger to resolve
111 // frame index materialization registers. Set according to
112 // TRI->requiresFrameIndexScavenging() for the current function.
113 bool FrameIndexVirtualScavenging = false;
114
115 // Flag to control whether the scavenger should be passed even though
116 // FrameIndexVirtualScavenging is used.
117 bool FrameIndexEliminationScavenging = false;
118
119 // Emit remarks.
121
122 void calculateCallFrameInfo(MachineFunction &MF);
123 void calculateSaveRestoreBlocks(MachineFunction &MF);
124 void spillCalleeSavedRegs(MachineFunction &MF);
125
126 void calculateFrameObjectOffsets(MachineFunction &MF);
127 void replaceFrameIndices(MachineFunction &MF);
128 void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
129 int &SPAdj);
130 // Frame indices in debug values are encoded in a target independent
131 // way with simply the frame index and offset rather than any
132 // target-specific addressing mode.
133 bool replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,
134 unsigned OpIdx, int SPAdj = 0);
135 // Does same as replaceFrameIndices but using the backward MIR walk and
136 // backward register scavenger walk.
137 void replaceFrameIndicesBackward(MachineFunction &MF);
138 void replaceFrameIndicesBackward(MachineBasicBlock *BB, MachineFunction &MF,
139 int &SPAdj);
140
141 void insertPrologEpilogCode(MachineFunction &MF);
142 void insertZeroCallUsedRegs(MachineFunction &MF);
143};
144
145} // end anonymous namespace
146
147char PEI::ID = 0;
148
150
151INITIALIZE_PASS_BEGIN(PEI, DEBUG_TYPE, "Prologue/Epilogue Insertion", false,
152 false)
157 "Prologue/Epilogue Insertion & Frame Finalization", false,
158 false)
159
161 return new PEI();
162}
163
164STATISTIC(NumBytesStackSpace,
165 "Number of bytes used for stack in all functions");
166
167void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
168 AU.setPreservesCFG();
173}
174
175/// StackObjSet - A set of stack object indexes
177
180
181/// Stash DBG_VALUEs that describe parameters and which are placed at the start
182/// of the block. Later on, after the prologue code has been emitted, the
183/// stashed DBG_VALUEs will be reinserted at the start of the block.
185 SavedDbgValuesMap &EntryDbgValues) {
187
188 for (auto &MI : MBB) {
189 if (!MI.isDebugInstr())
190 break;
191 if (!MI.isDebugValue() || !MI.getDebugVariable()->isParameter())
192 continue;
193 if (any_of(MI.debug_operands(),
194 [](const MachineOperand &MO) { return MO.isFI(); })) {
195 // We can only emit valid locations for frame indices after the frame
196 // setup, so do not stash away them.
197 FrameIndexValues.push_back(&MI);
198 continue;
199 }
200 const DILocalVariable *Var = MI.getDebugVariable();
201 const DIExpression *Expr = MI.getDebugExpression();
202 auto Overlaps = [Var, Expr](const MachineInstr *DV) {
203 return Var == DV->getDebugVariable() &&
204 Expr->fragmentsOverlap(DV->getDebugExpression());
205 };
206 // See if the debug value overlaps with any preceding debug value that will
207 // not be stashed. If that is the case, then we can't stash this value, as
208 // we would then reorder the values at reinsertion.
209 if (llvm::none_of(FrameIndexValues, Overlaps))
210 EntryDbgValues[&MBB].push_back(&MI);
211 }
212
213 // Remove stashed debug values from the block.
214 if (EntryDbgValues.count(&MBB))
215 for (auto *MI : EntryDbgValues[&MBB])
216 MI->removeFromParent();
217}
218
219/// runOnMachineFunction - Insert prolog/epilog code and replace abstract
220/// frame indexes with appropriate references.
221bool PEI::runOnMachineFunction(MachineFunction &MF) {
222 NumFuncSeen++;
223 const Function &F = MF.getFunction();
226
227 RS = TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : nullptr;
228 FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(MF);
229 ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
230
231 // Spill frame pointer and/or base pointer registers if they are clobbered.
232 // It is placed before call frame instruction elimination so it will not mess
233 // with stack arguments.
234 TFI->spillFPBP(MF);
235
236 // Calculate the MaxCallFrameSize value for the function's frame
237 // information. Also eliminates call frame pseudo instructions.
238 calculateCallFrameInfo(MF);
239
240 // Determine placement of CSR spill/restore code and prolog/epilog code:
241 // place all spills in the entry block, all restores in return blocks.
242 calculateSaveRestoreBlocks(MF);
243
244 // Stash away DBG_VALUEs that should not be moved by insertion of prolog code.
245 SavedDbgValuesMap EntryDbgValues;
246 for (MachineBasicBlock *SaveBlock : SaveBlocks)
247 stashEntryDbgValues(*SaveBlock, EntryDbgValues);
248
249 // Handle CSR spilling and restoring, for targets that need it.
251 spillCalleeSavedRegs(MF);
252
253 // Allow the target machine to make final modifications to the function
254 // before the frame layout is finalized.
256
257 // Calculate actual frame offsets for all abstract stack objects...
258 calculateFrameObjectOffsets(MF);
259
260 // Add prolog and epilog code to the function. This function is required
261 // to align the stack frame as necessary for any stack variables or
262 // called functions. Because of this, calculateCalleeSavedRegisters()
263 // must be called before this function in order to set the AdjustsStack
264 // and MaxCallFrameSize variables.
265 if (!F.hasFnAttribute(Attribute::Naked))
266 insertPrologEpilogCode(MF);
267
268 // Reinsert stashed debug values at the start of the entry blocks.
269 for (auto &I : EntryDbgValues)
270 I.first->insert(I.first->begin(), I.second.begin(), I.second.end());
271
272 // Allow the target machine to make final modifications to the function
273 // before the frame layout is finalized.
275
276 // Replace all MO_FrameIndex operands with physical register references
277 // and actual offsets.
278 if (TFI->needsFrameIndexResolution(MF)) {
279 // Allow the target to determine this after knowing the frame size.
280 FrameIndexEliminationScavenging =
281 (RS && !FrameIndexVirtualScavenging) ||
282 TRI->requiresFrameIndexReplacementScavenging(MF);
283
284 if (TRI->eliminateFrameIndicesBackwards())
285 replaceFrameIndicesBackward(MF);
286 else
287 replaceFrameIndices(MF);
288 }
289
290 // If register scavenging is needed, as we've enabled doing it as a
291 // post-pass, scavenge the virtual registers that frame index elimination
292 // inserted.
293 if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)
295
296 // Warn on stack size when we exceeds the given limit.
297 MachineFrameInfo &MFI = MF.getFrameInfo();
298 uint64_t StackSize = MFI.getStackSize();
299
300 uint64_t Threshold = TFI->getStackThreshold();
301 if (MF.getFunction().hasFnAttribute("warn-stack-size")) {
302 bool Failed = MF.getFunction()
303 .getFnAttribute("warn-stack-size")
305 .getAsInteger(10, Threshold);
306 // Verifier should have caught this.
307 assert(!Failed && "Invalid warn-stack-size fn attr value");
308 (void)Failed;
309 }
310 uint64_t UnsafeStackSize = MFI.getUnsafeStackSize();
311 if (MF.getFunction().hasFnAttribute(Attribute::SafeStack))
312 StackSize += UnsafeStackSize;
313
314 if (StackSize > Threshold) {
315 DiagnosticInfoStackSize DiagStackSize(F, StackSize, Threshold, DS_Warning);
316 F.getContext().diagnose(DiagStackSize);
317 int64_t SpillSize = 0;
318 for (int Idx = MFI.getObjectIndexBegin(), End = MFI.getObjectIndexEnd();
319 Idx != End; ++Idx) {
321 SpillSize += MFI.getObjectSize(Idx);
322 }
323
324 [[maybe_unused]] float SpillPct =
325 static_cast<float>(SpillSize) / static_cast<float>(StackSize);
327 dbgs() << formatv("{0}/{1} ({3:P}) spills, {2}/{1} ({4:P}) variables",
328 SpillSize, StackSize, StackSize - SpillSize, SpillPct,
329 1.0f - SpillPct));
330 if (UnsafeStackSize != 0) {
331 LLVM_DEBUG(dbgs() << formatv(", {0}/{2} ({1:P}) unsafe stack",
332 UnsafeStackSize,
333 static_cast<float>(UnsafeStackSize) /
334 static_cast<float>(StackSize),
335 StackSize));
336 }
337 LLVM_DEBUG(dbgs() << "\n");
338 }
339
340 ORE->emit([&]() {
343 &MF.front())
344 << ore::NV("NumStackBytes", StackSize)
345 << " stack bytes in function '"
346 << ore::NV("Function", MF.getFunction().getName()) << "'";
347 });
348
349 // Emit any remarks implemented for the target, based on final frame layout.
350 TFI->emitRemarks(MF, ORE);
351
352 delete RS;
353 SaveBlocks.clear();
354 RestoreBlocks.clear();
355 MFI.setSavePoint(nullptr);
356 MFI.setRestorePoint(nullptr);
357 return true;
358}
359
360/// Calculate the MaxCallFrameSize variable for the function's frame
361/// information and eliminate call frame pseudo instructions.
362void PEI::calculateCallFrameInfo(MachineFunction &MF) {
365 MachineFrameInfo &MFI = MF.getFrameInfo();
366
367 // Get the function call frame set-up and tear-down instruction opcode
368 unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
369 unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
370
371 // Early exit for targets which have no call frame setup/destroy pseudo
372 // instructions.
373 if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)
374 return;
375
376 // (Re-)Compute the MaxCallFrameSize.
377 [[maybe_unused]] uint64_t MaxCFSIn =
379 std::vector<MachineBasicBlock::iterator> FrameSDOps;
380 MFI.computeMaxCallFrameSize(MF, &FrameSDOps);
381 assert(MFI.getMaxCallFrameSize() <= MaxCFSIn &&
382 "Recomputing MaxCFS gave a larger value.");
383 assert((FrameSDOps.empty() || MF.getFrameInfo().adjustsStack()) &&
384 "AdjustsStack not set in presence of a frame pseudo instruction.");
385
386 if (TFI->canSimplifyCallFramePseudos(MF)) {
387 // If call frames are not being included as part of the stack frame, and
388 // the target doesn't indicate otherwise, remove the call frame pseudos
389 // here. The sub/add sp instruction pairs are still inserted, but we don't
390 // need to track the SP adjustment for frame index elimination.
391 for (MachineBasicBlock::iterator I : FrameSDOps)
392 TFI->eliminateCallFramePseudoInstr(MF, *I->getParent(), I);
393
394 // We can't track the call frame size after call frame pseudos have been
395 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
396 for (MachineBasicBlock &MBB : MF)
398 }
399}
400
401/// Compute the sets of entry and return blocks for saving and restoring
402/// callee-saved registers, and placing prolog and epilog code.
403void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
404 const MachineFrameInfo &MFI = MF.getFrameInfo();
405
406 // Even when we do not change any CSR, we still want to insert the
407 // prologue and epilogue of the function.
408 // So set the save points for those.
409
410 // Use the points found by shrink-wrapping, if any.
411 if (MFI.getSavePoint()) {
412 SaveBlocks.push_back(MFI.getSavePoint());
413 assert(MFI.getRestorePoint() && "Both restore and save must be set");
414 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
415 // If RestoreBlock does not have any successor and is not a return block
416 // then the end point is unreachable and we do not need to insert any
417 // epilogue.
418 if (!RestoreBlock->succ_empty() || RestoreBlock->isReturnBlock())
419 RestoreBlocks.push_back(RestoreBlock);
420 return;
421 }
422
423 // Save refs to entry and return blocks.
424 SaveBlocks.push_back(&MF.front());
425 for (MachineBasicBlock &MBB : MF) {
426 if (MBB.isEHFuncletEntry())
427 SaveBlocks.push_back(&MBB);
428 if (MBB.isReturnBlock())
429 RestoreBlocks.push_back(&MBB);
430 }
431}
432
434 const BitVector &SavedRegs,
435 unsigned &MinCSFrameIndex,
436 unsigned &MaxCSFrameIndex) {
437 if (SavedRegs.empty())
438 return;
439
440 const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
441 const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();
442 BitVector CSMask(SavedRegs.size());
443
444 for (unsigned i = 0; CSRegs[i]; ++i)
445 CSMask.set(CSRegs[i]);
446
447 std::vector<CalleeSavedInfo> CSI;
448 for (unsigned i = 0; CSRegs[i]; ++i) {
449 unsigned Reg = CSRegs[i];
450 if (SavedRegs.test(Reg)) {
451 bool SavedSuper = false;
452 for (const MCPhysReg &SuperReg : RegInfo->superregs(Reg)) {
453 // Some backends set all aliases for some registers as saved, such as
454 // Mips's $fp, so they appear in SavedRegs but not CSRegs.
455 if (SavedRegs.test(SuperReg) && CSMask.test(SuperReg)) {
456 SavedSuper = true;
457 break;
458 }
459 }
460
461 if (!SavedSuper)
462 CSI.push_back(CalleeSavedInfo(Reg));
463 }
464 }
465
466 const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering();
467 MachineFrameInfo &MFI = F.getFrameInfo();
468 if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI, MinCSFrameIndex,
469 MaxCSFrameIndex)) {
470 // If target doesn't implement this, use generic code.
471
472 if (CSI.empty())
473 return; // Early exit if no callee saved registers are modified!
474
475 unsigned NumFixedSpillSlots;
476 const TargetFrameLowering::SpillSlot *FixedSpillSlots =
477 TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
478
479 // Now that we know which registers need to be saved and restored, allocate
480 // stack slots for them.
481 for (auto &CS : CSI) {
482 // If the target has spilled this register to another register, we don't
483 // need to allocate a stack slot.
484 if (CS.isSpilledToReg())
485 continue;
486
487 unsigned Reg = CS.getReg();
488 const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
489
490 int FrameIdx;
491 if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {
492 CS.setFrameIdx(FrameIdx);
493 continue;
494 }
495
496 // Check to see if this physreg must be spilled to a particular stack slot
497 // on this target.
498 const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
499 while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
500 FixedSlot->Reg != Reg)
501 ++FixedSlot;
502
503 unsigned Size = RegInfo->getSpillSize(*RC);
504 if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
505 // Nope, just spill it anywhere convenient.
506 Align Alignment = RegInfo->getSpillAlign(*RC);
507 // We may not be able to satisfy the desired alignment specification of
508 // the TargetRegisterClass if the stack alignment is smaller. Use the
509 // min.
510 Alignment = std::min(Alignment, TFI->getStackAlign());
511 FrameIdx = MFI.CreateStackObject(Size, Alignment, true);
512 if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
513 if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
514 } else {
515 // Spill it to the stack where we must.
516 FrameIdx = MFI.CreateFixedSpillStackObject(Size, FixedSlot->Offset);
517 }
518
519 CS.setFrameIdx(FrameIdx);
520 }
521 }
522
523 MFI.setCalleeSavedInfo(CSI);
524}
525
526/// Helper function to update the liveness information for the callee-saved
527/// registers.
529 MachineFrameInfo &MFI = MF.getFrameInfo();
530 // Visited will contain all the basic blocks that are in the region
531 // where the callee saved registers are alive:
532 // - Anything that is not Save or Restore -> LiveThrough.
533 // - Save -> LiveIn.
534 // - Restore -> LiveOut.
535 // The live-out is not attached to the block, so no need to keep
536 // Restore in this set.
539 MachineBasicBlock *Entry = &MF.front();
540 MachineBasicBlock *Save = MFI.getSavePoint();
541
542 if (!Save)
543 Save = Entry;
544
545 if (Entry != Save) {
546 WorkList.push_back(Entry);
547 Visited.insert(Entry);
548 }
549 Visited.insert(Save);
550
551 MachineBasicBlock *Restore = MFI.getRestorePoint();
552 if (Restore)
553 // By construction Restore cannot be visited, otherwise it
554 // means there exists a path to Restore that does not go
555 // through Save.
556 WorkList.push_back(Restore);
557
558 while (!WorkList.empty()) {
559 const MachineBasicBlock *CurBB = WorkList.pop_back_val();
560 // By construction, the region that is after the save point is
561 // dominated by the Save and post-dominated by the Restore.
562 if (CurBB == Save && Save != Restore)
563 continue;
564 // Enqueue all the successors not already visited.
565 // Those are by construction either before Save or after Restore.
566 for (MachineBasicBlock *SuccBB : CurBB->successors())
567 if (Visited.insert(SuccBB).second)
568 WorkList.push_back(SuccBB);
569 }
570
571 const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
572
574 for (const CalleeSavedInfo &I : CSI) {
575 for (MachineBasicBlock *MBB : Visited) {
576 MCPhysReg Reg = I.getReg();
577 // Add the callee-saved register as live-in.
578 // It's killed at the spill.
579 if (!MRI.isReserved(Reg) && !MBB->isLiveIn(Reg))
580 MBB->addLiveIn(Reg);
581 }
582 // If callee-saved register is spilled to another register rather than
583 // spilling to stack, the destination register has to be marked as live for
584 // each MBB between the prologue and epilogue so that it is not clobbered
585 // before it is reloaded in the epilogue. The Visited set contains all
586 // blocks outside of the region delimited by prologue/epilogue.
587 if (I.isSpilledToReg()) {
588 for (MachineBasicBlock &MBB : MF) {
589 if (Visited.count(&MBB))
590 continue;
591 MCPhysReg DstReg = I.getDstReg();
592 if (!MBB.isLiveIn(DstReg))
593 MBB.addLiveIn(DstReg);
594 }
595 }
596 }
597}
598
599/// Insert spill code for the callee-saved registers used in the function.
600static void insertCSRSaves(MachineBasicBlock &SaveBlock,
602 MachineFunction &MF = *SaveBlock.getParent();
606
607 MachineBasicBlock::iterator I = SaveBlock.begin();
608 if (!TFI->spillCalleeSavedRegisters(SaveBlock, I, CSI, TRI)) {
609 for (const CalleeSavedInfo &CS : CSI) {
610 // Insert the spill to the stack frame.
611 unsigned Reg = CS.getReg();
612
613 if (CS.isSpilledToReg()) {
614 BuildMI(SaveBlock, I, DebugLoc(),
615 TII.get(TargetOpcode::COPY), CS.getDstReg())
616 .addReg(Reg, getKillRegState(true));
617 } else {
618 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
619 TII.storeRegToStackSlot(SaveBlock, I, Reg, true, CS.getFrameIdx(), RC,
620 TRI, Register());
621 }
622 }
623 }
624}
625
626/// Insert restore code for the callee-saved registers used in the function.
627static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
628 std::vector<CalleeSavedInfo> &CSI) {
629 MachineFunction &MF = *RestoreBlock.getParent();
633
634 // Restore all registers immediately before the return and any
635 // terminators that precede it.
637
638 if (!TFI->restoreCalleeSavedRegisters(RestoreBlock, I, CSI, TRI)) {
639 for (const CalleeSavedInfo &CI : reverse(CSI)) {
640 unsigned Reg = CI.getReg();
641 if (CI.isSpilledToReg()) {
642 BuildMI(RestoreBlock, I, DebugLoc(), TII.get(TargetOpcode::COPY), Reg)
643 .addReg(CI.getDstReg(), getKillRegState(true));
644 } else {
645 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
646 TII.loadRegFromStackSlot(RestoreBlock, I, Reg, CI.getFrameIdx(), RC,
647 TRI, Register());
648 assert(I != RestoreBlock.begin() &&
649 "loadRegFromStackSlot didn't insert any code!");
650 // Insert in reverse order. loadRegFromStackSlot can insert
651 // multiple instructions.
652 }
653 }
654 }
655}
656
657void PEI::spillCalleeSavedRegs(MachineFunction &MF) {
658 // We can't list this requirement in getRequiredProperties because some
659 // targets (WebAssembly) use virtual registers past this point, and the pass
660 // pipeline is set up without giving the passes a chance to look at the
661 // TargetMachine.
662 // FIXME: Find a way to express this in getRequiredProperties.
664 MachineFunctionProperties::Property::NoVRegs));
665
666 const Function &F = MF.getFunction();
668 MachineFrameInfo &MFI = MF.getFrameInfo();
669 MinCSFrameIndex = std::numeric_limits<unsigned>::max();
670 MaxCSFrameIndex = 0;
671
672 // Determine which of the registers in the callee save list should be saved.
673 BitVector SavedRegs;
674 TFI->determineCalleeSaves(MF, SavedRegs, RS);
675
676 // Assign stack slots for any callee-saved registers that must be spilled.
677 assignCalleeSavedSpillSlots(MF, SavedRegs, MinCSFrameIndex, MaxCSFrameIndex);
678
679 // Add the code to save and restore the callee saved registers.
680 if (!F.hasFnAttribute(Attribute::Naked)) {
681 MFI.setCalleeSavedInfoValid(true);
682
683 std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
684 if (!CSI.empty()) {
685 if (!MFI.hasCalls())
686 NumLeafFuncWithSpills++;
687
688 for (MachineBasicBlock *SaveBlock : SaveBlocks)
689 insertCSRSaves(*SaveBlock, CSI);
690
691 // Update the live-in information of all the blocks up to the save point.
692 updateLiveness(MF);
693
694 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
695 insertCSRRestores(*RestoreBlock, CSI);
696 }
697 }
698}
699
700/// AdjustStackOffset - Helper function used to adjust the stack frame offset.
701static inline void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx,
702 bool StackGrowsDown, int64_t &Offset,
703 Align &MaxAlign) {
704 // If the stack grows down, add the object size to find the lowest address.
705 if (StackGrowsDown)
706 Offset += MFI.getObjectSize(FrameIdx);
707
708 Align Alignment = MFI.getObjectAlign(FrameIdx);
709
710 // If the alignment of this object is greater than that of the stack, then
711 // increase the stack alignment to match.
712 MaxAlign = std::max(MaxAlign, Alignment);
713
714 // Adjust to alignment boundary.
715 Offset = alignTo(Offset, Alignment);
716
717 if (StackGrowsDown) {
718 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset
719 << "]\n");
720 MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
721 } else {
722 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset
723 << "]\n");
724 MFI.setObjectOffset(FrameIdx, Offset);
725 Offset += MFI.getObjectSize(FrameIdx);
726 }
727}
728
729/// Compute which bytes of fixed and callee-save stack area are unused and keep
730/// track of them in StackBytesFree.
731static inline void
732computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown,
733 unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex,
734 int64_t FixedCSEnd, BitVector &StackBytesFree) {
735 // Avoid undefined int64_t -> int conversion below in extreme case.
736 if (FixedCSEnd > std::numeric_limits<int>::max())
737 return;
738
739 StackBytesFree.resize(FixedCSEnd, true);
740
741 SmallVector<int, 16> AllocatedFrameSlots;
742 // Add fixed objects.
743 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i)
744 // StackSlot scavenging is only implemented for the default stack.
746 AllocatedFrameSlots.push_back(i);
747 // Add callee-save objects if there are any.
748 if (MinCSFrameIndex <= MaxCSFrameIndex) {
749 for (int i = MinCSFrameIndex; i <= (int)MaxCSFrameIndex; ++i)
751 AllocatedFrameSlots.push_back(i);
752 }
753
754 for (int i : AllocatedFrameSlots) {
755 // These are converted from int64_t, but they should always fit in int
756 // because of the FixedCSEnd check above.
757 int ObjOffset = MFI.getObjectOffset(i);
758 int ObjSize = MFI.getObjectSize(i);
759 int ObjStart, ObjEnd;
760 if (StackGrowsDown) {
761 // ObjOffset is negative when StackGrowsDown is true.
762 ObjStart = -ObjOffset - ObjSize;
763 ObjEnd = -ObjOffset;
764 } else {
765 ObjStart = ObjOffset;
766 ObjEnd = ObjOffset + ObjSize;
767 }
768 // Ignore fixed holes that are in the previous stack frame.
769 if (ObjEnd > 0)
770 StackBytesFree.reset(ObjStart, ObjEnd);
771 }
772}
773
774/// Assign frame object to an unused portion of the stack in the fixed stack
775/// object range. Return true if the allocation was successful.
776static inline bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx,
777 bool StackGrowsDown, Align MaxAlign,
778 BitVector &StackBytesFree) {
779 if (MFI.isVariableSizedObjectIndex(FrameIdx))
780 return false;
781
782 if (StackBytesFree.none()) {
783 // clear it to speed up later scavengeStackSlot calls to
784 // StackBytesFree.none()
785 StackBytesFree.clear();
786 return false;
787 }
788
789 Align ObjAlign = MFI.getObjectAlign(FrameIdx);
790 if (ObjAlign > MaxAlign)
791 return false;
792
793 int64_t ObjSize = MFI.getObjectSize(FrameIdx);
794 int FreeStart;
795 for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;
796 FreeStart = StackBytesFree.find_next(FreeStart)) {
797
798 // Check that free space has suitable alignment.
799 unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;
800 if (alignTo(ObjStart, ObjAlign) != ObjStart)
801 continue;
802
803 if (FreeStart + ObjSize > StackBytesFree.size())
804 return false;
805
806 bool AllBytesFree = true;
807 for (unsigned Byte = 0; Byte < ObjSize; ++Byte)
808 if (!StackBytesFree.test(FreeStart + Byte)) {
809 AllBytesFree = false;
810 break;
811 }
812 if (AllBytesFree)
813 break;
814 }
815
816 if (FreeStart == -1)
817 return false;
818
819 if (StackGrowsDown) {
820 int ObjStart = -(FreeStart + ObjSize);
821 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
822 << ObjStart << "]\n");
823 MFI.setObjectOffset(FrameIdx, ObjStart);
824 } else {
825 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
826 << FreeStart << "]\n");
827 MFI.setObjectOffset(FrameIdx, FreeStart);
828 }
829
830 StackBytesFree.reset(FreeStart, FreeStart + ObjSize);
831 return true;
832}
833
834/// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
835/// those required to be close to the Stack Protector) to stack offsets.
836static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
837 SmallSet<int, 16> &ProtectedObjs,
838 MachineFrameInfo &MFI, bool StackGrowsDown,
839 int64_t &Offset, Align &MaxAlign) {
840
841 for (int i : UnassignedObjs) {
842 AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign);
843 ProtectedObjs.insert(i);
844 }
845}
846
847/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
848/// abstract stack objects.
849void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
851
852 bool StackGrowsDown =
854
855 // Loop over all of the stack objects, assigning sequential addresses...
856 MachineFrameInfo &MFI = MF.getFrameInfo();
857
858 // Start at the beginning of the local area.
859 // The Offset is the distance from the stack top in the direction
860 // of stack growth -- so it's always nonnegative.
861 int LocalAreaOffset = TFI.getOffsetOfLocalArea();
862 if (StackGrowsDown)
863 LocalAreaOffset = -LocalAreaOffset;
864 assert(LocalAreaOffset >= 0
865 && "Local area offset should be in direction of stack growth");
866 int64_t Offset = LocalAreaOffset;
867
868#ifdef EXPENSIVE_CHECKS
869 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i)
870 if (!MFI.isDeadObjectIndex(i) &&
872 assert(MFI.getObjectAlign(i) <= MFI.getMaxAlign() &&
873 "MaxAlignment is invalid");
874#endif
875
876 // If there are fixed sized objects that are preallocated in the local area,
877 // non-fixed objects can't be allocated right at the start of local area.
878 // Adjust 'Offset' to point to the end of last fixed sized preallocated
879 // object.
880 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
881 // Only allocate objects on the default stack.
883 continue;
884
885 int64_t FixedOff;
886 if (StackGrowsDown) {
887 // The maximum distance from the stack pointer is at lower address of
888 // the object -- which is given by offset. For down growing stack
889 // the offset is negative, so we negate the offset to get the distance.
890 FixedOff = -MFI.getObjectOffset(i);
891 } else {
892 // The maximum distance from the start pointer is at the upper
893 // address of the object.
894 FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
895 }
896 if (FixedOff > Offset) Offset = FixedOff;
897 }
898
899 Align MaxAlign = MFI.getMaxAlign();
900 // First assign frame offsets to stack objects that are used to spill
901 // callee saved registers.
902 if (MaxCSFrameIndex >= MinCSFrameIndex) {
903 for (unsigned i = 0; i <= MaxCSFrameIndex - MinCSFrameIndex; ++i) {
904 unsigned FrameIndex =
905 StackGrowsDown ? MinCSFrameIndex + i : MaxCSFrameIndex - i;
906
907 // Only allocate objects on the default stack.
908 if (MFI.getStackID(FrameIndex) != TargetStackID::Default)
909 continue;
910
911 // TODO: should this just be if (MFI.isDeadObjectIndex(FrameIndex))
912 if (!StackGrowsDown && MFI.isDeadObjectIndex(FrameIndex))
913 continue;
914
915 AdjustStackOffset(MFI, FrameIndex, StackGrowsDown, Offset, MaxAlign);
916 }
917 }
918
919 assert(MaxAlign == MFI.getMaxAlign() &&
920 "MFI.getMaxAlign should already account for all callee-saved "
921 "registers without a fixed stack slot");
922
923 // FixedCSEnd is the stack offset to the end of the fixed and callee-save
924 // stack area.
925 int64_t FixedCSEnd = Offset;
926
927 // Make sure the special register scavenging spill slot is closest to the
928 // incoming stack pointer if a frame pointer is required and is closer
929 // to the incoming rather than the final stack pointer.
931 bool EarlyScavengingSlots = TFI.allocateScavengingFrameIndexesNearIncomingSP(MF);
932 if (RS && EarlyScavengingSlots) {
934 RS->getScavengingFrameIndices(SFIs);
935 for (int SFI : SFIs)
936 AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
937 }
938
939 // FIXME: Once this is working, then enable flag will change to a target
940 // check for whether the frame is large enough to want to use virtual
941 // frame index registers. Functions which don't want/need this optimization
942 // will continue to use the existing code path.
944 Align Alignment = MFI.getLocalFrameMaxAlign();
945
946 // Adjust to alignment boundary.
947 Offset = alignTo(Offset, Alignment);
948
949 LLVM_DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
950
951 // Resolve offsets for objects in the local block.
952 for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
953 std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
954 int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
955 LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset
956 << "]\n");
957 MFI.setObjectOffset(Entry.first, FIOffset);
958 }
959 // Allocate the local block
960 Offset += MFI.getLocalFrameSize();
961
962 MaxAlign = std::max(Alignment, MaxAlign);
963 }
964
965 // Retrieve the Exception Handler registration node.
966 int EHRegNodeFrameIndex = std::numeric_limits<int>::max();
967 if (const WinEHFuncInfo *FuncInfo = MF.getWinEHFuncInfo())
968 EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;
969
970 // Make sure that the stack protector comes before the local variables on the
971 // stack.
972 SmallSet<int, 16> ProtectedObjs;
973 if (MFI.hasStackProtectorIndex()) {
974 int StackProtectorFI = MFI.getStackProtectorIndex();
975 StackObjSet LargeArrayObjs;
976 StackObjSet SmallArrayObjs;
977 StackObjSet AddrOfObjs;
978
979 // If we need a stack protector, we need to make sure that
980 // LocalStackSlotPass didn't already allocate a slot for it.
981 // If we are told to use the LocalStackAllocationBlock, the stack protector
982 // is expected to be already pre-allocated.
983 if (MFI.getStackID(StackProtectorFI) != TargetStackID::Default) {
984 // If the stack protector isn't on the default stack then it's up to the
985 // target to set the stack offset.
986 assert(MFI.getObjectOffset(StackProtectorFI) != 0 &&
987 "Offset of stack protector on non-default stack expected to be "
988 "already set.");
990 "Stack protector on non-default stack expected to not be "
991 "pre-allocated by LocalStackSlotPass.");
992 } else if (!MFI.getUseLocalStackAllocationBlock()) {
993 AdjustStackOffset(MFI, StackProtectorFI, StackGrowsDown, Offset,
994 MaxAlign);
995 } else if (!MFI.isObjectPreAllocated(MFI.getStackProtectorIndex())) {
997 "Stack protector not pre-allocated by LocalStackSlotPass.");
998 }
999
1000 // Assign large stack objects first.
1001 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1003 continue;
1004 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1005 continue;
1006 if (RS && RS->isScavengingFrameIndex((int)i))
1007 continue;
1008 if (MFI.isDeadObjectIndex(i))
1009 continue;
1010 if (StackProtectorFI == (int)i || EHRegNodeFrameIndex == (int)i)
1011 continue;
1012 // Only allocate objects on the default stack.
1013 if (MFI.getStackID(i) != TargetStackID::Default)
1014 continue;
1015
1016 switch (MFI.getObjectSSPLayout(i)) {
1018 continue;
1020 SmallArrayObjs.insert(i);
1021 continue;
1023 AddrOfObjs.insert(i);
1024 continue;
1026 LargeArrayObjs.insert(i);
1027 continue;
1028 }
1029 llvm_unreachable("Unexpected SSPLayoutKind.");
1030 }
1031
1032 // We expect **all** the protected stack objects to be pre-allocated by
1033 // LocalStackSlotPass. If it turns out that PEI still has to allocate some
1034 // of them, we may end up messing up the expected order of the objects.
1036 !(LargeArrayObjs.empty() && SmallArrayObjs.empty() &&
1037 AddrOfObjs.empty()))
1038 llvm_unreachable("Found protected stack objects not pre-allocated by "
1039 "LocalStackSlotPass.");
1040
1041 AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
1042 Offset, MaxAlign);
1043 AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
1044 Offset, MaxAlign);
1045 AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
1046 Offset, MaxAlign);
1047 }
1048
1049 SmallVector<int, 8> ObjectsToAllocate;
1050
1051 // Then prepare to assign frame offsets to stack objects that are not used to
1052 // spill callee saved registers.
1053 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1055 continue;
1056 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1057 continue;
1058 if (RS && RS->isScavengingFrameIndex((int)i))
1059 continue;
1060 if (MFI.isDeadObjectIndex(i))
1061 continue;
1062 if (MFI.getStackProtectorIndex() == (int)i || EHRegNodeFrameIndex == (int)i)
1063 continue;
1064 if (ProtectedObjs.count(i))
1065 continue;
1066 // Only allocate objects on the default stack.
1067 if (MFI.getStackID(i) != TargetStackID::Default)
1068 continue;
1069
1070 // Add the objects that we need to allocate to our working set.
1071 ObjectsToAllocate.push_back(i);
1072 }
1073
1074 // Allocate the EH registration node first if one is present.
1075 if (EHRegNodeFrameIndex != std::numeric_limits<int>::max())
1076 AdjustStackOffset(MFI, EHRegNodeFrameIndex, StackGrowsDown, Offset,
1077 MaxAlign);
1078
1079 // Give the targets a chance to order the objects the way they like it.
1080 if (MF.getTarget().getOptLevel() != CodeGenOptLevel::None &&
1082 TFI.orderFrameObjects(MF, ObjectsToAllocate);
1083
1084 // Keep track of which bytes in the fixed and callee-save range are used so we
1085 // can use the holes when allocating later stack objects. Only do this if
1086 // stack protector isn't being used and the target requests it and we're
1087 // optimizing.
1088 BitVector StackBytesFree;
1089 if (!ObjectsToAllocate.empty() &&
1090 MF.getTarget().getOptLevel() != CodeGenOptLevel::None &&
1092 computeFreeStackSlots(MFI, StackGrowsDown, MinCSFrameIndex, MaxCSFrameIndex,
1093 FixedCSEnd, StackBytesFree);
1094
1095 // Now walk the objects and actually assign base offsets to them.
1096 for (auto &Object : ObjectsToAllocate)
1097 if (!scavengeStackSlot(MFI, Object, StackGrowsDown, MaxAlign,
1098 StackBytesFree))
1099 AdjustStackOffset(MFI, Object, StackGrowsDown, Offset, MaxAlign);
1100
1101 // Make sure the special register scavenging spill slot is closest to the
1102 // stack pointer.
1103 if (RS && !EarlyScavengingSlots) {
1105 RS->getScavengingFrameIndices(SFIs);
1106 for (int SFI : SFIs)
1107 AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
1108 }
1109
1111 // If we have reserved argument space for call sites in the function
1112 // immediately on entry to the current function, count it as part of the
1113 // overall stack size.
1114 if (MFI.adjustsStack() && TFI.hasReservedCallFrame(MF))
1115 Offset += MFI.getMaxCallFrameSize();
1116
1117 // Round up the size to a multiple of the alignment. If the function has
1118 // any calls or alloca's, align to the target's StackAlignment value to
1119 // ensure that the callee's frame or the alloca data is suitably aligned;
1120 // otherwise, for leaf functions, align to the TransientStackAlignment
1121 // value.
1122 Align StackAlign;
1123 if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
1124 (RegInfo->hasStackRealignment(MF) && MFI.getObjectIndexEnd() != 0))
1125 StackAlign = TFI.getStackAlign();
1126 else
1127 StackAlign = TFI.getTransientStackAlign();
1128
1129 // If the frame pointer is eliminated, all frame offsets will be relative to
1130 // SP not FP. Align to MaxAlign so this works.
1131 StackAlign = std::max(StackAlign, MaxAlign);
1132 int64_t OffsetBeforeAlignment = Offset;
1133 Offset = alignTo(Offset, StackAlign);
1134
1135 // If we have increased the offset to fulfill the alignment constrants,
1136 // then the scavenging spill slots may become harder to reach from the
1137 // stack pointer, float them so they stay close.
1138 if (StackGrowsDown && OffsetBeforeAlignment != Offset && RS &&
1139 !EarlyScavengingSlots) {
1141 RS->getScavengingFrameIndices(SFIs);
1142 LLVM_DEBUG(if (!SFIs.empty()) llvm::dbgs()
1143 << "Adjusting emergency spill slots!\n";);
1144 int64_t Delta = Offset - OffsetBeforeAlignment;
1145 for (int SFI : SFIs) {
1147 << "Adjusting offset of emergency spill slot #" << SFI
1148 << " from " << MFI.getObjectOffset(SFI););
1149 MFI.setObjectOffset(SFI, MFI.getObjectOffset(SFI) - Delta);
1150 LLVM_DEBUG(llvm::dbgs() << " to " << MFI.getObjectOffset(SFI) << "\n";);
1151 }
1152 }
1153 }
1154
1155 // Update frame info to pretend that this is part of the stack...
1156 int64_t StackSize = Offset - LocalAreaOffset;
1157 MFI.setStackSize(StackSize);
1158 NumBytesStackSpace += StackSize;
1159}
1160
1161/// insertPrologEpilogCode - Scan the function for modified callee saved
1162/// registers, insert spill code for these callee saved registers, then add
1163/// prolog and epilog code to the function.
1164void PEI::insertPrologEpilogCode(MachineFunction &MF) {
1166
1167 // Add prologue to the function...
1168 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1169 TFI.emitPrologue(MF, *SaveBlock);
1170
1171 // Add epilogue to restore the callee-save registers in each exiting block.
1172 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1173 TFI.emitEpilogue(MF, *RestoreBlock);
1174
1175 // Zero call used registers before restoring callee-saved registers.
1176 insertZeroCallUsedRegs(MF);
1177
1178 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1179 TFI.inlineStackProbe(MF, *SaveBlock);
1180
1181 // Emit additional code that is required to support segmented stacks, if
1182 // we've been asked for it. This, when linked with a runtime with support
1183 // for segmented stacks (libgcc is one), will result in allocating stack
1184 // space in small chunks instead of one large contiguous block.
1185 if (MF.shouldSplitStack()) {
1186 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1187 TFI.adjustForSegmentedStacks(MF, *SaveBlock);
1188 }
1189
1190 // Emit additional code that is required to explicitly handle the stack in
1191 // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
1192 // approach is rather similar to that of Segmented Stacks, but it uses a
1193 // different conditional check and another BIF for allocating more stack
1194 // space.
1196 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1197 TFI.adjustForHiPEPrologue(MF, *SaveBlock);
1198}
1199
1200/// insertZeroCallUsedRegs - Zero out call used registers.
1201void PEI::insertZeroCallUsedRegs(MachineFunction &MF) {
1202 const Function &F = MF.getFunction();
1203
1204 if (!F.hasFnAttribute("zero-call-used-regs"))
1205 return;
1206
1207 using namespace ZeroCallUsedRegs;
1208
1209 ZeroCallUsedRegsKind ZeroRegsKind =
1211 F.getFnAttribute("zero-call-used-regs").getValueAsString())
1212 .Case("skip", ZeroCallUsedRegsKind::Skip)
1213 .Case("used-gpr-arg", ZeroCallUsedRegsKind::UsedGPRArg)
1214 .Case("used-gpr", ZeroCallUsedRegsKind::UsedGPR)
1215 .Case("used-arg", ZeroCallUsedRegsKind::UsedArg)
1216 .Case("used", ZeroCallUsedRegsKind::Used)
1217 .Case("all-gpr-arg", ZeroCallUsedRegsKind::AllGPRArg)
1218 .Case("all-gpr", ZeroCallUsedRegsKind::AllGPR)
1219 .Case("all-arg", ZeroCallUsedRegsKind::AllArg)
1220 .Case("all", ZeroCallUsedRegsKind::All);
1221
1222 if (ZeroRegsKind == ZeroCallUsedRegsKind::Skip)
1223 return;
1224
1225 const bool OnlyGPR = static_cast<unsigned>(ZeroRegsKind) & ONLY_GPR;
1226 const bool OnlyUsed = static_cast<unsigned>(ZeroRegsKind) & ONLY_USED;
1227 const bool OnlyArg = static_cast<unsigned>(ZeroRegsKind) & ONLY_ARG;
1228
1230 const BitVector AllocatableSet(TRI.getAllocatableSet(MF));
1231
1232 // Mark all used registers.
1233 BitVector UsedRegs(TRI.getNumRegs());
1234 if (OnlyUsed)
1235 for (const MachineBasicBlock &MBB : MF)
1236 for (const MachineInstr &MI : MBB) {
1237 // skip debug instructions
1238 if (MI.isDebugInstr())
1239 continue;
1240
1241 for (const MachineOperand &MO : MI.operands()) {
1242 if (!MO.isReg())
1243 continue;
1244
1245 MCRegister Reg = MO.getReg();
1246 if (AllocatableSet[Reg] && !MO.isImplicit() &&
1247 (MO.isDef() || MO.isUse()))
1248 UsedRegs.set(Reg);
1249 }
1250 }
1251
1252 // Get a list of registers that are used.
1253 BitVector LiveIns(TRI.getNumRegs());
1254 for (const MachineBasicBlock::RegisterMaskPair &LI : MF.front().liveins())
1255 LiveIns.set(LI.PhysReg);
1256
1257 BitVector RegsToZero(TRI.getNumRegs());
1258 for (MCRegister Reg : AllocatableSet.set_bits()) {
1259 // Skip over fixed registers.
1260 if (TRI.isFixedRegister(MF, Reg))
1261 continue;
1262
1263 // Want only general purpose registers.
1264 if (OnlyGPR && !TRI.isGeneralPurposeRegister(MF, Reg))
1265 continue;
1266
1267 // Want only used registers.
1268 if (OnlyUsed && !UsedRegs[Reg])
1269 continue;
1270
1271 // Want only registers used for arguments.
1272 if (OnlyArg) {
1273 if (OnlyUsed) {
1274 if (!LiveIns[Reg])
1275 continue;
1276 } else if (!TRI.isArgumentRegister(MF, Reg)) {
1277 continue;
1278 }
1279 }
1280
1281 RegsToZero.set(Reg);
1282 }
1283
1284 // Don't clear registers that are live when leaving the function.
1285 for (const MachineBasicBlock &MBB : MF)
1286 for (const MachineInstr &MI : MBB.terminators()) {
1287 if (!MI.isReturn())
1288 continue;
1289
1290 for (const auto &MO : MI.operands()) {
1291 if (!MO.isReg())
1292 continue;
1293
1294 MCRegister Reg = MO.getReg();
1295 if (!Reg)
1296 continue;
1297
1298 // This picks up sibling registers (e.q. %al -> %ah).
1299 for (MCRegUnit Unit : TRI.regunits(Reg))
1300 RegsToZero.reset(Unit);
1301
1302 for (MCPhysReg SReg : TRI.sub_and_superregs_inclusive(Reg))
1303 RegsToZero.reset(SReg);
1304 }
1305 }
1306
1307 // Don't need to clear registers that are used/clobbered by terminating
1308 // instructions.
1309 for (const MachineBasicBlock &MBB : MF) {
1310 if (!MBB.isReturnBlock())
1311 continue;
1312
1314 for (MachineBasicBlock::const_iterator I = MBBI, E = MBB.end(); I != E;
1315 ++I) {
1316 for (const MachineOperand &MO : I->operands()) {
1317 if (!MO.isReg())
1318 continue;
1319
1320 MCRegister Reg = MO.getReg();
1321 if (!Reg)
1322 continue;
1323
1324 for (const MCPhysReg Reg : TRI.sub_and_superregs_inclusive(Reg))
1325 RegsToZero.reset(Reg);
1326 }
1327 }
1328 }
1329
1330 // Don't clear registers that must be preserved.
1331 for (const MCPhysReg *CSRegs = TRI.getCalleeSavedRegs(&MF);
1332 MCPhysReg CSReg = *CSRegs; ++CSRegs)
1333 for (MCRegister Reg : TRI.sub_and_superregs_inclusive(CSReg))
1334 RegsToZero.reset(Reg);
1335
1336 const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
1337 for (MachineBasicBlock &MBB : MF)
1338 if (MBB.isReturnBlock())
1339 TFI.emitZeroCallUsedRegs(RegsToZero, MBB);
1340}
1341
1342/// Replace all FrameIndex operands with physical register references and actual
1343/// offsets.
1344void PEI::replaceFrameIndicesBackward(MachineFunction &MF) {
1346
1347 for (auto &MBB : MF) {
1348 int SPAdj = 0;
1349 if (!MBB.succ_empty()) {
1350 // Get the SP adjustment for the end of MBB from the start of any of its
1351 // successors. They should all be the same.
1352 assert(all_of(MBB.successors(), [&MBB](const MachineBasicBlock *Succ) {
1353 return Succ->getCallFrameSize() ==
1354 (*MBB.succ_begin())->getCallFrameSize();
1355 }));
1356 const MachineBasicBlock &FirstSucc = **MBB.succ_begin();
1357 SPAdj = TFI.alignSPAdjust(FirstSucc.getCallFrameSize());
1359 SPAdj = -SPAdj;
1360 }
1361
1362 replaceFrameIndicesBackward(&MBB, MF, SPAdj);
1363
1364 // We can't track the call frame size after call frame pseudos have been
1365 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
1367 }
1368}
1369
1370/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
1371/// register references and actual offsets.
1372void PEI::replaceFrameIndices(MachineFunction &MF) {
1374
1375 for (auto &MBB : MF) {
1376 int SPAdj = TFI.alignSPAdjust(MBB.getCallFrameSize());
1378 SPAdj = -SPAdj;
1379
1380 replaceFrameIndices(&MBB, MF, SPAdj);
1381
1382 // We can't track the call frame size after call frame pseudos have been
1383 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
1385 }
1386}
1387
1388bool PEI::replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,
1389 unsigned OpIdx, int SPAdj) {
1392 if (MI.isDebugValue()) {
1393
1394 MachineOperand &Op = MI.getOperand(OpIdx);
1395 assert(MI.isDebugOperand(&Op) &&
1396 "Frame indices can only appear as a debug operand in a DBG_VALUE*"
1397 " machine instruction");
1398 Register Reg;
1399 unsigned FrameIdx = Op.getIndex();
1400 unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
1401
1402 StackOffset Offset = TFI->getFrameIndexReference(MF, FrameIdx, Reg);
1403 Op.ChangeToRegister(Reg, false /*isDef*/);
1404
1405 const DIExpression *DIExpr = MI.getDebugExpression();
1406
1407 // If we have a direct DBG_VALUE, and its location expression isn't
1408 // currently complex, then adding an offset will morph it into a
1409 // complex location that is interpreted as being a memory address.
1410 // This changes a pointer-valued variable to dereference that pointer,
1411 // which is incorrect. Fix by adding DW_OP_stack_value.
1412
1413 if (MI.isNonListDebugValue()) {
1414 unsigned PrependFlags = DIExpression::ApplyOffset;
1415 if (!MI.isIndirectDebugValue() && !DIExpr->isComplex())
1416 PrependFlags |= DIExpression::StackValue;
1417
1418 // If we have DBG_VALUE that is indirect and has a Implicit location
1419 // expression need to insert a deref before prepending a Memory
1420 // location expression. Also after doing this we change the DBG_VALUE
1421 // to be direct.
1422 if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {
1423 SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
1424 bool WithStackValue = true;
1425 DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
1426 // Make the DBG_VALUE direct.
1427 MI.getDebugOffset().ChangeToRegister(0, false);
1428 }
1429 DIExpr = TRI.prependOffsetExpression(DIExpr, PrependFlags, Offset);
1430 } else {
1431 // The debug operand at DebugOpIndex was a frame index at offset
1432 // `Offset`; now the operand has been replaced with the frame
1433 // register, we must add Offset with `register x, plus Offset`.
1434 unsigned DebugOpIndex = MI.getDebugOperandIndex(&Op);
1436 TRI.getOffsetOpcodes(Offset, Ops);
1437 DIExpr = DIExpression::appendOpsToArg(DIExpr, Ops, DebugOpIndex);
1438 }
1439 MI.getDebugExpressionOp().setMetadata(DIExpr);
1440 return true;
1441 }
1442
1443 if (MI.isDebugPHI()) {
1444 // Allow stack ref to continue onwards.
1445 return true;
1446 }
1447
1448 // TODO: This code should be commoned with the code for
1449 // PATCHPOINT. There's no good reason for the difference in
1450 // implementation other than historical accident. The only
1451 // remaining difference is the unconditional use of the stack
1452 // pointer as the base register.
1453 if (MI.getOpcode() == TargetOpcode::STATEPOINT) {
1454 assert((!MI.isDebugValue() || OpIdx == 0) &&
1455 "Frame indices can only appear as the first operand of a "
1456 "DBG_VALUE machine instruction");
1457 Register Reg;
1458 MachineOperand &Offset = MI.getOperand(OpIdx + 1);
1460 MF, MI.getOperand(OpIdx).getIndex(), Reg, /*IgnoreSPUpdates*/ false);
1461 assert(!refOffset.getScalable() &&
1462 "Frame offsets with a scalable component are not supported");
1463 Offset.setImm(Offset.getImm() + refOffset.getFixed() + SPAdj);
1464 MI.getOperand(OpIdx).ChangeToRegister(Reg, false /*isDef*/);
1465 return true;
1466 }
1467 return false;
1468}
1469
1470void PEI::replaceFrameIndicesBackward(MachineBasicBlock *BB,
1471 MachineFunction &MF, int &SPAdj) {
1473 "getRegisterInfo() must be implemented!");
1474
1478
1479 RegScavenger *LocalRS = FrameIndexEliminationScavenging ? RS : nullptr;
1480 if (LocalRS)
1481 LocalRS->enterBasicBlockEnd(*BB);
1482
1483 for (MachineBasicBlock::iterator I = BB->end(); I != BB->begin();) {
1484 MachineInstr &MI = *std::prev(I);
1485
1486 if (TII.isFrameInstr(MI)) {
1487 SPAdj -= TII.getSPAdjust(MI);
1488 TFI.eliminateCallFramePseudoInstr(MF, *BB, &MI);
1489 continue;
1490 }
1491
1492 // Step backwards to get the liveness state at (immedately after) MI.
1493 if (LocalRS)
1494 LocalRS->backward(I);
1495
1496 bool RemovedMI = false;
1497 for (const auto &[Idx, Op] : enumerate(MI.operands())) {
1498 if (!Op.isFI())
1499 continue;
1500
1501 if (replaceFrameIndexDebugInstr(MF, MI, Idx, SPAdj))
1502 continue;
1503
1504 // Eliminate this FrameIndex operand.
1505 RemovedMI = TRI.eliminateFrameIndex(MI, SPAdj, Idx, LocalRS);
1506 if (RemovedMI)
1507 break;
1508 }
1509
1510 if (!RemovedMI)
1511 --I;
1512 }
1513}
1514
1515void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
1516 int &SPAdj) {
1518 "getRegisterInfo() must be implemented!");
1522
1523 bool InsideCallSequence = false;
1524
1525 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
1526 if (TII.isFrameInstr(*I)) {
1527 InsideCallSequence = TII.isFrameSetup(*I);
1528 SPAdj += TII.getSPAdjust(*I);
1529 I = TFI->eliminateCallFramePseudoInstr(MF, *BB, I);
1530 continue;
1531 }
1532
1533 MachineInstr &MI = *I;
1534 bool DoIncr = true;
1535 bool DidFinishLoop = true;
1536 for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1537 if (!MI.getOperand(i).isFI())
1538 continue;
1539
1540 if (replaceFrameIndexDebugInstr(MF, MI, i, SPAdj))
1541 continue;
1542
1543 // Some instructions (e.g. inline asm instructions) can have
1544 // multiple frame indices and/or cause eliminateFrameIndex
1545 // to insert more than one instruction. We need the register
1546 // scavenger to go through all of these instructions so that
1547 // it can update its register information. We keep the
1548 // iterator at the point before insertion so that we can
1549 // revisit them in full.
1550 bool AtBeginning = (I == BB->begin());
1551 if (!AtBeginning) --I;
1552
1553 // If this instruction has a FrameIndex operand, we need to
1554 // use that target machine register info object to eliminate
1555 // it.
1556 TRI.eliminateFrameIndex(MI, SPAdj, i);
1557
1558 // Reset the iterator if we were at the beginning of the BB.
1559 if (AtBeginning) {
1560 I = BB->begin();
1561 DoIncr = false;
1562 }
1563
1564 DidFinishLoop = false;
1565 break;
1566 }
1567
1568 // If we are looking at a call sequence, we need to keep track of
1569 // the SP adjustment made by each instruction in the sequence.
1570 // This includes both the frame setup/destroy pseudos (handled above),
1571 // as well as other instructions that have side effects w.r.t the SP.
1572 // Note that this must come after eliminateFrameIndex, because
1573 // if I itself referred to a frame index, we shouldn't count its own
1574 // adjustment.
1575 if (DidFinishLoop && InsideCallSequence)
1576 SPAdj += TII.getSPAdjust(MI);
1577
1578 if (DoIncr && I != BB->end())
1579 ++I;
1580 }
1581}
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file contains the simple types necessary to represent the attributes associated with functions a...
This file implements the BitVector class.
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
#define LLVM_DEBUG(X)
Definition: Debug.h:101
uint64_t Size
bool End
Definition: ELF_riscv.cpp:480
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
unsigned const TargetRegisterInfo * TRI
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:57
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
static void insertCSRRestores(MachineBasicBlock &RestoreBlock, std::vector< CalleeSavedInfo > &CSI)
Insert restore code for the callee-saved registers used in the function.
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.
static void insertCSRSaves(MachineBasicBlock &SaveBlock, ArrayRef< CalleeSavedInfo > CSI)
Insert spill code for the callee-saved registers used in the function.
static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign)
AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...
static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign)
AdjustStackOffset - Helper function used to adjust the stack frame offset.
static void updateLiveness(MachineFunction &MF)
Helper function to update the liveness information for the callee-saved registers.
static void assignCalleeSavedSpillSlots(MachineFunction &F, const BitVector &SavedRegs, unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex)
Prologue Epilogue Insertion &Frame Finalization
static void stashEntryDbgValues(MachineBasicBlock &MBB, SavedDbgValuesMap &EntryDbgValues)
Stash DBG_VALUEs that describe parameters and which are placed at the start of the block.
#define DEBUG_TYPE
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...
This file declares the machine register scavenger class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:166
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:256
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:392
bool test(unsigned Idx) const
Definition: BitVector.h:461
BitVector & reset()
Definition: BitVector.h:392
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:300
void resize(unsigned N, bool t=false)
resize - Grow or shrink the bitvector.
Definition: BitVector.h:341
void clear()
clear - Removes all bits from the bitvector.
Definition: BitVector.h:335
BitVector & set()
Definition: BitVector.h:351
int find_next(unsigned Prev) const
find_next - Returns the index of the next set bit following the "Prev" bit.
Definition: BitVector.h:308
bool none() const
none - Returns true if none of the bits are set.
Definition: BitVector.h:188
size_type size() const
size - Returns the number of bits in this bitvector.
Definition: BitVector.h:159
bool empty() const
empty - Tests whether there are no bits in this bitvector.
Definition: BitVector.h:156
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
DWARF expression.
bool isImplicit() const
Return whether this is an implicit location description.
static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B)
Check if fragments overlap between a pair of FragmentInfos.
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...
bool isComplex() const
Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...
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.
This class represents an Operation in the Expression.
A debug info location.
Definition: DebugLoc.h:33
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:151
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.cpp:769
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1837
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:281
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:743
void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register SrcReg, bool isKill, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI, Register VReg) const override
Store the specified register of the given register class to the specified stack frame index.
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register DestReg, int FrameIndex, const TargetRegisterClass *RC, const TargetRegisterInfo *TRI, Register VReg) const override
Load the specified register of the given register class from the specified stack frame index.
virtual bool usesPhysRegsForValues() const
True if the target uses physical regs (as nearly all targets do).
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
void push_back(MachineInstr *MI)
void setCallFrameSize(unsigned N)
Set the call frame size on entry to this basic block.
bool isLiveIn(MCPhysReg Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
iterator_range< iterator > terminators()
unsigned getCallFrameSize() const
Return the call frame size on entry to this basic block.
iterator_range< succ_iterator > successors()
Analysis pass which computes a MachineDominatorTree.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
SSPLayoutKind getObjectSSPLayout(int ObjectIdx) const
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
void computeMaxCallFrameSize(MachineFunction &MF, std::vector< MachineBasicBlock::iterator > *FrameSDOps=nullptr)
Computes the maximum size of a callframe.
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
void setRestorePoint(MachineBasicBlock *NewRestore)
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
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.
int64_t getLocalFrameObjectCount() const
Return the number of objects allocated into the local object block.
bool hasCalls() const
Return true if the current function has any function calls.
Align getMaxAlign() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
Align getLocalFrameMaxAlign() const
Return the required alignment of the local object blob.
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
@ SSPLK_SmallArray
Array or nested array < SSP-buffer-size.
@ SSPLK_LargeArray
Array or nested array >= SSP-buffer-size.
@ SSPLK_AddrOf
The address of this allocation is exposed and triggered protection.
@ SSPLK_None
Did not trigger a stack protector.
std::pair< int, int64_t > getLocalFrameObjectMap(int i) const
Get the local offset mapping for a for an object.
uint64_t getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call.
bool getUseLocalStackAllocationBlock() const
Get whether the local allocation blob should be allocated together or let PEI allocate the locals in ...
MachineBasicBlock * getRestorePoint() const
int getStackProtectorIndex() const
Return the index for the stack protector object.
void setCalleeSavedInfoValid(bool v)
Align getObjectAlign(int ObjectIdx) const
Return the alignment of the specified stack object.
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
bool isMaxCallFrameSizeComputed() const
int64_t getLocalFrameSize() const
Get the size of the local object blob.
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
void setCalleeSavedInfo(std::vector< CalleeSavedInfo > CSI)
Used by prolog/epilog inserter to set the function's callee saved information.
bool isVariableSizedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a variable sized object.
void setSavePoint(MachineBasicBlock *NewSave)
uint64_t getUnsafeStackSize() const
int getObjectIndexEnd() const
Return one past the maximum frame object index.
bool hasStackProtectorIndex() const
int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
uint8_t getStackID(int ObjectIdx) const
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
void setStackSize(uint64_t Size)
Set the size of the stack.
int getObjectIndexBegin() const
Return the minimum frame object index.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
MachineBasicBlock * getSavePoint() const
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
bool hasProperty(Property P) const
const WinEHFuncInfo * getWinEHFuncInfo() const
getWinEHFuncInfo - Return information about how the current function uses Windows exception handling.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
const MachineFunctionProperties & getProperties() const
Get the function properties.
const MachineBasicBlock & front() const
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
Diagnostic information for optimization analysis remarks.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void enterBasicBlockEnd(MachineBasicBlock &MBB)
Start tracking liveness from the end of basic block MBB.
void backward()
Update internal register state and move MBB iterator backwards.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:93
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:162
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:367
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:502
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:370
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:135
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
Definition: SmallSet.h:166
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:179
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:33
static StackOffset getScalable(int64_t Scalable)
Definition: TypeSize.h:43
static StackOffset getFixed(int64_t Fixed)
Definition: TypeSize.h:42
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:455
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:44
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:69
Information about stack frame layout on the target.
virtual void spillFPBP(MachineFunction &MF) const
If frame pointer or base pointer is clobbered by an instruction, we should spill/restore it around th...
virtual void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
virtual const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const
getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...
virtual bool hasReservedCallFrame(const MachineFunction &MF) const
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
virtual bool enableStackSlotScavenging(const MachineFunction &MF) const
Returns true if the stack slot holes in the fixed and callee-save stack area should be used when allo...
virtual bool allocateScavengingFrameIndexesNearIncomingSP(const MachineFunction &MF) const
Control the placement of special register scavenging spill slots when allocating a stack frame.
Align getTransientStackAlign() const
getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
virtual uint64_t getStackThreshold() const
getStackThreshold - Return the maximum stack size
virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
virtual void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Replace a StackProbe stub (if any) with the actual probe code inline.
virtual void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &objectsToAllocate) const
Order the symbols in the local stack frame.
virtual void adjustForHiPEPrologue(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in the assembly prologue to ex...
virtual 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...
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
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.
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
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...
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
virtual void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS=nullptr) const
processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...
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 ...
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to have the function use segmented stacks.
int alignSPAdjust(int SPAdj) const
alignSPAdjust - This method aligns the stack adjustment to the correct alignment.
virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const
canSimplifyCallFramePseudos - When possible, it's best to simplify the call frame pseudo ops before d...
virtual void emitZeroCallUsedRegs(BitVector RegsToZero, MachineBasicBlock &MBB) const
emitZeroCallUsedRegs - Zeros out call used registers.
virtual void emitRemarks(const MachineFunction &MF, MachineOptimizationRemarkEmitter *ORE) const
This method is called at the end of prolog/epilog code insertion, so targets can emit remarks based o...
virtual bool targetHandlesStackFrameRounding() const
targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...
virtual void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const =0
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
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...
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...
TargetInstrInfo - Interface to description of machine instruction set.
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
TargetOptions Options
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetFrameLowering * getFrameLowering() const
virtual const TargetInstrInfo * getInstrInfo() const
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
#define UINT64_MAX
Definition: DataTypes.h:77
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Entry
Definition: COFF.h:826
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ HiPE
Used by the High-Performance Erlang Compiler (HiPE).
Definition: CallingConv.h:53
@ FrameIndex
Definition: ISDOpcodes.h:80
Reg
All possible values of the reg field in the ModR/M byte.
DiagnosticInfoOptimizationBase::Argument NV
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1722
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
Definition: STLExtras.h:2413
testing::Matcher< const detail::ErrorHolder & > Failed()
Definition: Error.h:198
void scavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger &RS)
Replaces all frame index virtual registers with physical registers.
MachineFunctionPass * createPrologEpilogInserterPass()
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
char & PrologEpilogCodeInserterID
PrologEpilogCodeInserter - This pass inserts prolog and epilog code, and eliminates abstract frame re...
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:1729
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:419
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
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:1736
unsigned getKillRegState(bool B)
void initializePEIPass(PassRegistry &)
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
@ DS_Warning
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Pair of physical register and lane mask.