LLVM 19.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 // Calculate the MaxCallFrameSize and AdjustsStack variables for the
232 // function's frame information. Also eliminates call frame pseudo
233 // instructions.
234 calculateCallFrameInfo(MF);
235
236 // Determine placement of CSR spill/restore code and prolog/epilog code:
237 // place all spills in the entry block, all restores in return blocks.
238 calculateSaveRestoreBlocks(MF);
239
240 // Stash away DBG_VALUEs that should not be moved by insertion of prolog code.
241 SavedDbgValuesMap EntryDbgValues;
242 for (MachineBasicBlock *SaveBlock : SaveBlocks)
243 stashEntryDbgValues(*SaveBlock, EntryDbgValues);
244
245 // Handle CSR spilling and restoring, for targets that need it.
247 spillCalleeSavedRegs(MF);
248
249 // Allow the target machine to make final modifications to the function
250 // before the frame layout is finalized.
252
253 // Calculate actual frame offsets for all abstract stack objects...
254 calculateFrameObjectOffsets(MF);
255
256 // Add prolog and epilog code to the function. This function is required
257 // to align the stack frame as necessary for any stack variables or
258 // called functions. Because of this, calculateCalleeSavedRegisters()
259 // must be called before this function in order to set the AdjustsStack
260 // and MaxCallFrameSize variables.
261 if (!F.hasFnAttribute(Attribute::Naked))
262 insertPrologEpilogCode(MF);
263
264 // Reinsert stashed debug values at the start of the entry blocks.
265 for (auto &I : EntryDbgValues)
266 I.first->insert(I.first->begin(), I.second.begin(), I.second.end());
267
268 // Allow the target machine to make final modifications to the function
269 // before the frame layout is finalized.
271
272 // Replace all MO_FrameIndex operands with physical register references
273 // and actual offsets.
274 if (TFI->needsFrameIndexResolution(MF)) {
275 // Allow the target to determine this after knowing the frame size.
276 FrameIndexEliminationScavenging =
277 (RS && !FrameIndexVirtualScavenging) ||
278 TRI->requiresFrameIndexReplacementScavenging(MF);
279
280 if (TRI->eliminateFrameIndicesBackwards())
281 replaceFrameIndicesBackward(MF);
282 else
283 replaceFrameIndices(MF);
284 }
285
286 // If register scavenging is needed, as we've enabled doing it as a
287 // post-pass, scavenge the virtual registers that frame index elimination
288 // inserted.
289 if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)
291
292 // Warn on stack size when we exceeds the given limit.
293 MachineFrameInfo &MFI = MF.getFrameInfo();
294 uint64_t StackSize = MFI.getStackSize();
295
296 uint64_t Threshold = TFI->getStackThreshold();
297 if (MF.getFunction().hasFnAttribute("warn-stack-size")) {
298 bool Failed = MF.getFunction()
299 .getFnAttribute("warn-stack-size")
301 .getAsInteger(10, Threshold);
302 // Verifier should have caught this.
303 assert(!Failed && "Invalid warn-stack-size fn attr value");
304 (void)Failed;
305 }
306 uint64_t UnsafeStackSize = MFI.getUnsafeStackSize();
307 if (MF.getFunction().hasFnAttribute(Attribute::SafeStack))
308 StackSize += UnsafeStackSize;
309
310 if (StackSize > Threshold) {
311 DiagnosticInfoStackSize DiagStackSize(F, StackSize, Threshold, DS_Warning);
312 F.getContext().diagnose(DiagStackSize);
313 int64_t SpillSize = 0;
314 for (int Idx = MFI.getObjectIndexBegin(), End = MFI.getObjectIndexEnd();
315 Idx != End; ++Idx) {
317 SpillSize += MFI.getObjectSize(Idx);
318 }
319
320 [[maybe_unused]] float SpillPct =
321 static_cast<float>(SpillSize) / static_cast<float>(StackSize);
323 dbgs() << formatv("{0}/{1} ({3:P}) spills, {2}/{1} ({4:P}) variables",
324 SpillSize, StackSize, StackSize - SpillSize, SpillPct,
325 1.0f - SpillPct));
326 if (UnsafeStackSize != 0) {
327 LLVM_DEBUG(dbgs() << formatv(", {0}/{2} ({1:P}) unsafe stack",
328 UnsafeStackSize,
329 static_cast<float>(UnsafeStackSize) /
330 static_cast<float>(StackSize),
331 StackSize));
332 }
333 LLVM_DEBUG(dbgs() << "\n");
334 }
335
336 ORE->emit([&]() {
339 &MF.front())
340 << ore::NV("NumStackBytes", StackSize)
341 << " stack bytes in function '"
342 << ore::NV("Function", MF.getFunction().getName()) << "'";
343 });
344
345 delete RS;
346 SaveBlocks.clear();
347 RestoreBlocks.clear();
348 MFI.setSavePoint(nullptr);
349 MFI.setRestorePoint(nullptr);
350 return true;
351}
352
353/// Calculate the MaxCallFrameSize and AdjustsStack
354/// variables for the function's frame information and eliminate call frame
355/// pseudo instructions.
356void PEI::calculateCallFrameInfo(MachineFunction &MF) {
359 MachineFrameInfo &MFI = MF.getFrameInfo();
360
361 unsigned MaxCallFrameSize = 0;
362 bool AdjustsStack = MFI.adjustsStack();
363
364 // Get the function call frame set-up and tear-down instruction opcode
365 unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();
366 unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();
367
368 // Early exit for targets which have no call frame setup/destroy pseudo
369 // instructions.
370 if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)
371 return;
372
373 std::vector<MachineBasicBlock::iterator> FrameSDOps;
374 for (MachineBasicBlock &BB : MF)
375 for (MachineBasicBlock::iterator I = BB.begin(); I != BB.end(); ++I)
376 if (TII.isFrameInstr(*I)) {
377 unsigned Size = TII.getFrameSize(*I);
378 if (Size > MaxCallFrameSize) MaxCallFrameSize = Size;
379 AdjustsStack = true;
380 FrameSDOps.push_back(I);
381 } else if (I->isInlineAsm()) {
382 // Some inline asm's need a stack frame, as indicated by operand 1.
383 unsigned ExtraInfo = I->getOperand(InlineAsm::MIOp_ExtraInfo).getImm();
384 if (ExtraInfo & InlineAsm::Extra_IsAlignStack)
385 AdjustsStack = true;
386 }
387
389 (MFI.getMaxCallFrameSize() >= MaxCallFrameSize &&
390 !(AdjustsStack && !MFI.adjustsStack())));
391 MFI.setAdjustsStack(AdjustsStack);
392 MFI.setMaxCallFrameSize(MaxCallFrameSize);
393
394 if (TFI->canSimplifyCallFramePseudos(MF)) {
395 // If call frames are not being included as part of the stack frame, and
396 // the target doesn't indicate otherwise, remove the call frame pseudos
397 // here. The sub/add sp instruction pairs are still inserted, but we don't
398 // need to track the SP adjustment for frame index elimination.
399 for (MachineBasicBlock::iterator I : FrameSDOps)
400 TFI->eliminateCallFramePseudoInstr(MF, *I->getParent(), I);
401
402 // We can't track the call frame size after call frame pseudos have been
403 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
404 for (MachineBasicBlock &MBB : MF)
406 }
407}
408
409/// Compute the sets of entry and return blocks for saving and restoring
410/// callee-saved registers, and placing prolog and epilog code.
411void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
412 const MachineFrameInfo &MFI = MF.getFrameInfo();
413
414 // Even when we do not change any CSR, we still want to insert the
415 // prologue and epilogue of the function.
416 // So set the save points for those.
417
418 // Use the points found by shrink-wrapping, if any.
419 if (MFI.getSavePoint()) {
420 SaveBlocks.push_back(MFI.getSavePoint());
421 assert(MFI.getRestorePoint() && "Both restore and save must be set");
422 MachineBasicBlock *RestoreBlock = MFI.getRestorePoint();
423 // If RestoreBlock does not have any successor and is not a return block
424 // then the end point is unreachable and we do not need to insert any
425 // epilogue.
426 if (!RestoreBlock->succ_empty() || RestoreBlock->isReturnBlock())
427 RestoreBlocks.push_back(RestoreBlock);
428 return;
429 }
430
431 // Save refs to entry and return blocks.
432 SaveBlocks.push_back(&MF.front());
433 for (MachineBasicBlock &MBB : MF) {
434 if (MBB.isEHFuncletEntry())
435 SaveBlocks.push_back(&MBB);
436 if (MBB.isReturnBlock())
437 RestoreBlocks.push_back(&MBB);
438 }
439}
440
442 const BitVector &SavedRegs,
443 unsigned &MinCSFrameIndex,
444 unsigned &MaxCSFrameIndex) {
445 if (SavedRegs.empty())
446 return;
447
448 const TargetRegisterInfo *RegInfo = F.getSubtarget().getRegisterInfo();
449 const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();
450 BitVector CSMask(SavedRegs.size());
451
452 for (unsigned i = 0; CSRegs[i]; ++i)
453 CSMask.set(CSRegs[i]);
454
455 std::vector<CalleeSavedInfo> CSI;
456 for (unsigned i = 0; CSRegs[i]; ++i) {
457 unsigned Reg = CSRegs[i];
458 if (SavedRegs.test(Reg)) {
459 bool SavedSuper = false;
460 for (const MCPhysReg &SuperReg : RegInfo->superregs(Reg)) {
461 // Some backends set all aliases for some registers as saved, such as
462 // Mips's $fp, so they appear in SavedRegs but not CSRegs.
463 if (SavedRegs.test(SuperReg) && CSMask.test(SuperReg)) {
464 SavedSuper = true;
465 break;
466 }
467 }
468
469 if (!SavedSuper)
470 CSI.push_back(CalleeSavedInfo(Reg));
471 }
472 }
473
474 const TargetFrameLowering *TFI = F.getSubtarget().getFrameLowering();
475 MachineFrameInfo &MFI = F.getFrameInfo();
476 if (!TFI->assignCalleeSavedSpillSlots(F, RegInfo, CSI, MinCSFrameIndex,
477 MaxCSFrameIndex)) {
478 // If target doesn't implement this, use generic code.
479
480 if (CSI.empty())
481 return; // Early exit if no callee saved registers are modified!
482
483 unsigned NumFixedSpillSlots;
484 const TargetFrameLowering::SpillSlot *FixedSpillSlots =
485 TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots);
486
487 // Now that we know which registers need to be saved and restored, allocate
488 // stack slots for them.
489 for (auto &CS : CSI) {
490 // If the target has spilled this register to another register, we don't
491 // need to allocate a stack slot.
492 if (CS.isSpilledToReg())
493 continue;
494
495 unsigned Reg = CS.getReg();
496 const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg);
497
498 int FrameIdx;
499 if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {
500 CS.setFrameIdx(FrameIdx);
501 continue;
502 }
503
504 // Check to see if this physreg must be spilled to a particular stack slot
505 // on this target.
506 const TargetFrameLowering::SpillSlot *FixedSlot = FixedSpillSlots;
507 while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&
508 FixedSlot->Reg != Reg)
509 ++FixedSlot;
510
511 unsigned Size = RegInfo->getSpillSize(*RC);
512 if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {
513 // Nope, just spill it anywhere convenient.
514 Align Alignment = RegInfo->getSpillAlign(*RC);
515 // We may not be able to satisfy the desired alignment specification of
516 // the TargetRegisterClass if the stack alignment is smaller. Use the
517 // min.
518 Alignment = std::min(Alignment, TFI->getStackAlign());
519 FrameIdx = MFI.CreateStackObject(Size, Alignment, true);
520 if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx;
521 if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx;
522 } else {
523 // Spill it to the stack where we must.
524 FrameIdx = MFI.CreateFixedSpillStackObject(Size, FixedSlot->Offset);
525 }
526
527 CS.setFrameIdx(FrameIdx);
528 }
529 }
530
531 MFI.setCalleeSavedInfo(CSI);
532}
533
534/// Helper function to update the liveness information for the callee-saved
535/// registers.
537 MachineFrameInfo &MFI = MF.getFrameInfo();
538 // Visited will contain all the basic blocks that are in the region
539 // where the callee saved registers are alive:
540 // - Anything that is not Save or Restore -> LiveThrough.
541 // - Save -> LiveIn.
542 // - Restore -> LiveOut.
543 // The live-out is not attached to the block, so no need to keep
544 // Restore in this set.
547 MachineBasicBlock *Entry = &MF.front();
548 MachineBasicBlock *Save = MFI.getSavePoint();
549
550 if (!Save)
551 Save = Entry;
552
553 if (Entry != Save) {
554 WorkList.push_back(Entry);
555 Visited.insert(Entry);
556 }
557 Visited.insert(Save);
558
559 MachineBasicBlock *Restore = MFI.getRestorePoint();
560 if (Restore)
561 // By construction Restore cannot be visited, otherwise it
562 // means there exists a path to Restore that does not go
563 // through Save.
564 WorkList.push_back(Restore);
565
566 while (!WorkList.empty()) {
567 const MachineBasicBlock *CurBB = WorkList.pop_back_val();
568 // By construction, the region that is after the save point is
569 // dominated by the Save and post-dominated by the Restore.
570 if (CurBB == Save && Save != Restore)
571 continue;
572 // Enqueue all the successors not already visited.
573 // Those are by construction either before Save or after Restore.
574 for (MachineBasicBlock *SuccBB : CurBB->successors())
575 if (Visited.insert(SuccBB).second)
576 WorkList.push_back(SuccBB);
577 }
578
579 const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
580
582 for (const CalleeSavedInfo &I : CSI) {
583 for (MachineBasicBlock *MBB : Visited) {
584 MCPhysReg Reg = I.getReg();
585 // Add the callee-saved register as live-in.
586 // It's killed at the spill.
587 if (!MRI.isReserved(Reg) && !MBB->isLiveIn(Reg))
588 MBB->addLiveIn(Reg);
589 }
590 // If callee-saved register is spilled to another register rather than
591 // spilling to stack, the destination register has to be marked as live for
592 // each MBB between the prologue and epilogue so that it is not clobbered
593 // before it is reloaded in the epilogue. The Visited set contains all
594 // blocks outside of the region delimited by prologue/epilogue.
595 if (I.isSpilledToReg()) {
596 for (MachineBasicBlock &MBB : MF) {
597 if (Visited.count(&MBB))
598 continue;
599 MCPhysReg DstReg = I.getDstReg();
600 if (!MBB.isLiveIn(DstReg))
601 MBB.addLiveIn(DstReg);
602 }
603 }
604 }
605}
606
607/// Insert spill code for the callee-saved registers used in the function.
608static void insertCSRSaves(MachineBasicBlock &SaveBlock,
610 MachineFunction &MF = *SaveBlock.getParent();
614
615 MachineBasicBlock::iterator I = SaveBlock.begin();
616 if (!TFI->spillCalleeSavedRegisters(SaveBlock, I, CSI, TRI)) {
617 for (const CalleeSavedInfo &CS : CSI) {
618 // Insert the spill to the stack frame.
619 unsigned Reg = CS.getReg();
620
621 if (CS.isSpilledToReg()) {
622 BuildMI(SaveBlock, I, DebugLoc(),
623 TII.get(TargetOpcode::COPY), CS.getDstReg())
624 .addReg(Reg, getKillRegState(true));
625 } else {
626 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
627 TII.storeRegToStackSlot(SaveBlock, I, Reg, true, CS.getFrameIdx(), RC,
628 TRI, Register());
629 }
630 }
631 }
632}
633
634/// Insert restore code for the callee-saved registers used in the function.
635static void insertCSRRestores(MachineBasicBlock &RestoreBlock,
636 std::vector<CalleeSavedInfo> &CSI) {
637 MachineFunction &MF = *RestoreBlock.getParent();
641
642 // Restore all registers immediately before the return and any
643 // terminators that precede it.
645
646 if (!TFI->restoreCalleeSavedRegisters(RestoreBlock, I, CSI, TRI)) {
647 for (const CalleeSavedInfo &CI : reverse(CSI)) {
648 unsigned Reg = CI.getReg();
649 if (CI.isSpilledToReg()) {
650 BuildMI(RestoreBlock, I, DebugLoc(), TII.get(TargetOpcode::COPY), Reg)
651 .addReg(CI.getDstReg(), getKillRegState(true));
652 } else {
653 const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg);
654 TII.loadRegFromStackSlot(RestoreBlock, I, Reg, CI.getFrameIdx(), RC,
655 TRI, Register());
656 assert(I != RestoreBlock.begin() &&
657 "loadRegFromStackSlot didn't insert any code!");
658 // Insert in reverse order. loadRegFromStackSlot can insert
659 // multiple instructions.
660 }
661 }
662 }
663}
664
665void PEI::spillCalleeSavedRegs(MachineFunction &MF) {
666 // We can't list this requirement in getRequiredProperties because some
667 // targets (WebAssembly) use virtual registers past this point, and the pass
668 // pipeline is set up without giving the passes a chance to look at the
669 // TargetMachine.
670 // FIXME: Find a way to express this in getRequiredProperties.
672 MachineFunctionProperties::Property::NoVRegs));
673
674 const Function &F = MF.getFunction();
676 MachineFrameInfo &MFI = MF.getFrameInfo();
677 MinCSFrameIndex = std::numeric_limits<unsigned>::max();
678 MaxCSFrameIndex = 0;
679
680 // Determine which of the registers in the callee save list should be saved.
681 BitVector SavedRegs;
682 TFI->determineCalleeSaves(MF, SavedRegs, RS);
683
684 // Assign stack slots for any callee-saved registers that must be spilled.
685 assignCalleeSavedSpillSlots(MF, SavedRegs, MinCSFrameIndex, MaxCSFrameIndex);
686
687 // Add the code to save and restore the callee saved registers.
688 if (!F.hasFnAttribute(Attribute::Naked)) {
689 MFI.setCalleeSavedInfoValid(true);
690
691 std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
692 if (!CSI.empty()) {
693 if (!MFI.hasCalls())
694 NumLeafFuncWithSpills++;
695
696 for (MachineBasicBlock *SaveBlock : SaveBlocks)
697 insertCSRSaves(*SaveBlock, CSI);
698
699 // Update the live-in information of all the blocks up to the save point.
700 updateLiveness(MF);
701
702 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
703 insertCSRRestores(*RestoreBlock, CSI);
704 }
705 }
706}
707
708/// AdjustStackOffset - Helper function used to adjust the stack frame offset.
709static inline void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx,
710 bool StackGrowsDown, int64_t &Offset,
711 Align &MaxAlign) {
712 // If the stack grows down, add the object size to find the lowest address.
713 if (StackGrowsDown)
714 Offset += MFI.getObjectSize(FrameIdx);
715
716 Align Alignment = MFI.getObjectAlign(FrameIdx);
717
718 // If the alignment of this object is greater than that of the stack, then
719 // increase the stack alignment to match.
720 MaxAlign = std::max(MaxAlign, Alignment);
721
722 // Adjust to alignment boundary.
723 Offset = alignTo(Offset, Alignment);
724
725 if (StackGrowsDown) {
726 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset
727 << "]\n");
728 MFI.setObjectOffset(FrameIdx, -Offset); // Set the computed offset
729 } else {
730 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset
731 << "]\n");
732 MFI.setObjectOffset(FrameIdx, Offset);
733 Offset += MFI.getObjectSize(FrameIdx);
734 }
735}
736
737/// Compute which bytes of fixed and callee-save stack area are unused and keep
738/// track of them in StackBytesFree.
739static inline void
740computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown,
741 unsigned MinCSFrameIndex, unsigned MaxCSFrameIndex,
742 int64_t FixedCSEnd, BitVector &StackBytesFree) {
743 // Avoid undefined int64_t -> int conversion below in extreme case.
744 if (FixedCSEnd > std::numeric_limits<int>::max())
745 return;
746
747 StackBytesFree.resize(FixedCSEnd, true);
748
749 SmallVector<int, 16> AllocatedFrameSlots;
750 // Add fixed objects.
751 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i)
752 // StackSlot scavenging is only implemented for the default stack.
754 AllocatedFrameSlots.push_back(i);
755 // Add callee-save objects if there are any.
756 if (MinCSFrameIndex <= MaxCSFrameIndex) {
757 for (int i = MinCSFrameIndex; i <= (int)MaxCSFrameIndex; ++i)
759 AllocatedFrameSlots.push_back(i);
760 }
761
762 for (int i : AllocatedFrameSlots) {
763 // These are converted from int64_t, but they should always fit in int
764 // because of the FixedCSEnd check above.
765 int ObjOffset = MFI.getObjectOffset(i);
766 int ObjSize = MFI.getObjectSize(i);
767 int ObjStart, ObjEnd;
768 if (StackGrowsDown) {
769 // ObjOffset is negative when StackGrowsDown is true.
770 ObjStart = -ObjOffset - ObjSize;
771 ObjEnd = -ObjOffset;
772 } else {
773 ObjStart = ObjOffset;
774 ObjEnd = ObjOffset + ObjSize;
775 }
776 // Ignore fixed holes that are in the previous stack frame.
777 if (ObjEnd > 0)
778 StackBytesFree.reset(ObjStart, ObjEnd);
779 }
780}
781
782/// Assign frame object to an unused portion of the stack in the fixed stack
783/// object range. Return true if the allocation was successful.
784static inline bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx,
785 bool StackGrowsDown, Align MaxAlign,
786 BitVector &StackBytesFree) {
787 if (MFI.isVariableSizedObjectIndex(FrameIdx))
788 return false;
789
790 if (StackBytesFree.none()) {
791 // clear it to speed up later scavengeStackSlot calls to
792 // StackBytesFree.none()
793 StackBytesFree.clear();
794 return false;
795 }
796
797 Align ObjAlign = MFI.getObjectAlign(FrameIdx);
798 if (ObjAlign > MaxAlign)
799 return false;
800
801 int64_t ObjSize = MFI.getObjectSize(FrameIdx);
802 int FreeStart;
803 for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;
804 FreeStart = StackBytesFree.find_next(FreeStart)) {
805
806 // Check that free space has suitable alignment.
807 unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;
808 if (alignTo(ObjStart, ObjAlign) != ObjStart)
809 continue;
810
811 if (FreeStart + ObjSize > StackBytesFree.size())
812 return false;
813
814 bool AllBytesFree = true;
815 for (unsigned Byte = 0; Byte < ObjSize; ++Byte)
816 if (!StackBytesFree.test(FreeStart + Byte)) {
817 AllBytesFree = false;
818 break;
819 }
820 if (AllBytesFree)
821 break;
822 }
823
824 if (FreeStart == -1)
825 return false;
826
827 if (StackGrowsDown) {
828 int ObjStart = -(FreeStart + ObjSize);
829 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
830 << ObjStart << "]\n");
831 MFI.setObjectOffset(FrameIdx, ObjStart);
832 } else {
833 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["
834 << FreeStart << "]\n");
835 MFI.setObjectOffset(FrameIdx, FreeStart);
836 }
837
838 StackBytesFree.reset(FreeStart, FreeStart + ObjSize);
839 return true;
840}
841
842/// AssignProtectedObjSet - Helper function to assign large stack objects (i.e.,
843/// those required to be close to the Stack Protector) to stack offsets.
844static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs,
845 SmallSet<int, 16> &ProtectedObjs,
846 MachineFrameInfo &MFI, bool StackGrowsDown,
847 int64_t &Offset, Align &MaxAlign) {
848
849 for (int i : UnassignedObjs) {
850 AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign);
851 ProtectedObjs.insert(i);
852 }
853}
854
855/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the
856/// abstract stack objects.
857void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
859
860 bool StackGrowsDown =
862
863 // Loop over all of the stack objects, assigning sequential addresses...
864 MachineFrameInfo &MFI = MF.getFrameInfo();
865
866 // Start at the beginning of the local area.
867 // The Offset is the distance from the stack top in the direction
868 // of stack growth -- so it's always nonnegative.
869 int LocalAreaOffset = TFI.getOffsetOfLocalArea();
870 if (StackGrowsDown)
871 LocalAreaOffset = -LocalAreaOffset;
872 assert(LocalAreaOffset >= 0
873 && "Local area offset should be in direction of stack growth");
874 int64_t Offset = LocalAreaOffset;
875
876#ifdef EXPENSIVE_CHECKS
877 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i)
878 if (!MFI.isDeadObjectIndex(i) &&
880 assert(MFI.getObjectAlign(i) <= MFI.getMaxAlign() &&
881 "MaxAlignment is invalid");
882#endif
883
884 // If there are fixed sized objects that are preallocated in the local area,
885 // non-fixed objects can't be allocated right at the start of local area.
886 // Adjust 'Offset' to point to the end of last fixed sized preallocated
887 // object.
888 for (int i = MFI.getObjectIndexBegin(); i != 0; ++i) {
889 // Only allocate objects on the default stack.
891 continue;
892
893 int64_t FixedOff;
894 if (StackGrowsDown) {
895 // The maximum distance from the stack pointer is at lower address of
896 // the object -- which is given by offset. For down growing stack
897 // the offset is negative, so we negate the offset to get the distance.
898 FixedOff = -MFI.getObjectOffset(i);
899 } else {
900 // The maximum distance from the start pointer is at the upper
901 // address of the object.
902 FixedOff = MFI.getObjectOffset(i) + MFI.getObjectSize(i);
903 }
904 if (FixedOff > Offset) Offset = FixedOff;
905 }
906
907 Align MaxAlign = MFI.getMaxAlign();
908 // First assign frame offsets to stack objects that are used to spill
909 // callee saved registers.
910 if (MaxCSFrameIndex >= MinCSFrameIndex) {
911 for (unsigned i = 0; i <= MaxCSFrameIndex - MinCSFrameIndex; ++i) {
912 unsigned FrameIndex =
913 StackGrowsDown ? MinCSFrameIndex + i : MaxCSFrameIndex - i;
914
915 // Only allocate objects on the default stack.
916 if (MFI.getStackID(FrameIndex) != TargetStackID::Default)
917 continue;
918
919 // TODO: should this just be if (MFI.isDeadObjectIndex(FrameIndex))
920 if (!StackGrowsDown && MFI.isDeadObjectIndex(FrameIndex))
921 continue;
922
923 AdjustStackOffset(MFI, FrameIndex, StackGrowsDown, Offset, MaxAlign);
924 }
925 }
926
927 assert(MaxAlign == MFI.getMaxAlign() &&
928 "MFI.getMaxAlign should already account for all callee-saved "
929 "registers without a fixed stack slot");
930
931 // FixedCSEnd is the stack offset to the end of the fixed and callee-save
932 // stack area.
933 int64_t FixedCSEnd = Offset;
934
935 // Make sure the special register scavenging spill slot is closest to the
936 // incoming stack pointer if a frame pointer is required and is closer
937 // to the incoming rather than the final stack pointer.
939 bool EarlyScavengingSlots = TFI.allocateScavengingFrameIndexesNearIncomingSP(MF);
940 if (RS && EarlyScavengingSlots) {
942 RS->getScavengingFrameIndices(SFIs);
943 for (int SFI : SFIs)
944 AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
945 }
946
947 // FIXME: Once this is working, then enable flag will change to a target
948 // check for whether the frame is large enough to want to use virtual
949 // frame index registers. Functions which don't want/need this optimization
950 // will continue to use the existing code path.
952 Align Alignment = MFI.getLocalFrameMaxAlign();
953
954 // Adjust to alignment boundary.
955 Offset = alignTo(Offset, Alignment);
956
957 LLVM_DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n");
958
959 // Resolve offsets for objects in the local block.
960 for (unsigned i = 0, e = MFI.getLocalFrameObjectCount(); i != e; ++i) {
961 std::pair<int, int64_t> Entry = MFI.getLocalFrameObjectMap(i);
962 int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;
963 LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset
964 << "]\n");
965 MFI.setObjectOffset(Entry.first, FIOffset);
966 }
967 // Allocate the local block
968 Offset += MFI.getLocalFrameSize();
969
970 MaxAlign = std::max(Alignment, MaxAlign);
971 }
972
973 // Retrieve the Exception Handler registration node.
974 int EHRegNodeFrameIndex = std::numeric_limits<int>::max();
975 if (const WinEHFuncInfo *FuncInfo = MF.getWinEHFuncInfo())
976 EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;
977
978 // Make sure that the stack protector comes before the local variables on the
979 // stack.
980 SmallSet<int, 16> ProtectedObjs;
981 if (MFI.hasStackProtectorIndex()) {
982 int StackProtectorFI = MFI.getStackProtectorIndex();
983 StackObjSet LargeArrayObjs;
984 StackObjSet SmallArrayObjs;
985 StackObjSet AddrOfObjs;
986
987 // If we need a stack protector, we need to make sure that
988 // LocalStackSlotPass didn't already allocate a slot for it.
989 // If we are told to use the LocalStackAllocationBlock, the stack protector
990 // is expected to be already pre-allocated.
991 if (MFI.getStackID(StackProtectorFI) != TargetStackID::Default) {
992 // If the stack protector isn't on the default stack then it's up to the
993 // target to set the stack offset.
994 assert(MFI.getObjectOffset(StackProtectorFI) != 0 &&
995 "Offset of stack protector on non-default stack expected to be "
996 "already set.");
998 "Stack protector on non-default stack expected to not be "
999 "pre-allocated by LocalStackSlotPass.");
1000 } else if (!MFI.getUseLocalStackAllocationBlock()) {
1001 AdjustStackOffset(MFI, StackProtectorFI, StackGrowsDown, Offset,
1002 MaxAlign);
1003 } else if (!MFI.isObjectPreAllocated(MFI.getStackProtectorIndex())) {
1005 "Stack protector not pre-allocated by LocalStackSlotPass.");
1006 }
1007
1008 // Assign large stack objects first.
1009 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1011 continue;
1012 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1013 continue;
1014 if (RS && RS->isScavengingFrameIndex((int)i))
1015 continue;
1016 if (MFI.isDeadObjectIndex(i))
1017 continue;
1018 if (StackProtectorFI == (int)i || EHRegNodeFrameIndex == (int)i)
1019 continue;
1020 // Only allocate objects on the default stack.
1021 if (MFI.getStackID(i) != TargetStackID::Default)
1022 continue;
1023
1024 switch (MFI.getObjectSSPLayout(i)) {
1026 continue;
1028 SmallArrayObjs.insert(i);
1029 continue;
1031 AddrOfObjs.insert(i);
1032 continue;
1034 LargeArrayObjs.insert(i);
1035 continue;
1036 }
1037 llvm_unreachable("Unexpected SSPLayoutKind.");
1038 }
1039
1040 // We expect **all** the protected stack objects to be pre-allocated by
1041 // LocalStackSlotPass. If it turns out that PEI still has to allocate some
1042 // of them, we may end up messing up the expected order of the objects.
1044 !(LargeArrayObjs.empty() && SmallArrayObjs.empty() &&
1045 AddrOfObjs.empty()))
1046 llvm_unreachable("Found protected stack objects not pre-allocated by "
1047 "LocalStackSlotPass.");
1048
1049 AssignProtectedObjSet(LargeArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
1050 Offset, MaxAlign);
1051 AssignProtectedObjSet(SmallArrayObjs, ProtectedObjs, MFI, StackGrowsDown,
1052 Offset, MaxAlign);
1053 AssignProtectedObjSet(AddrOfObjs, ProtectedObjs, MFI, StackGrowsDown,
1054 Offset, MaxAlign);
1055 }
1056
1057 SmallVector<int, 8> ObjectsToAllocate;
1058
1059 // Then prepare to assign frame offsets to stack objects that are not used to
1060 // spill callee saved registers.
1061 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {
1063 continue;
1064 if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex)
1065 continue;
1066 if (RS && RS->isScavengingFrameIndex((int)i))
1067 continue;
1068 if (MFI.isDeadObjectIndex(i))
1069 continue;
1070 if (MFI.getStackProtectorIndex() == (int)i || EHRegNodeFrameIndex == (int)i)
1071 continue;
1072 if (ProtectedObjs.count(i))
1073 continue;
1074 // Only allocate objects on the default stack.
1075 if (MFI.getStackID(i) != TargetStackID::Default)
1076 continue;
1077
1078 // Add the objects that we need to allocate to our working set.
1079 ObjectsToAllocate.push_back(i);
1080 }
1081
1082 // Allocate the EH registration node first if one is present.
1083 if (EHRegNodeFrameIndex != std::numeric_limits<int>::max())
1084 AdjustStackOffset(MFI, EHRegNodeFrameIndex, StackGrowsDown, Offset,
1085 MaxAlign);
1086
1087 // Give the targets a chance to order the objects the way they like it.
1088 if (MF.getTarget().getOptLevel() != CodeGenOptLevel::None &&
1090 TFI.orderFrameObjects(MF, ObjectsToAllocate);
1091
1092 // Keep track of which bytes in the fixed and callee-save range are used so we
1093 // can use the holes when allocating later stack objects. Only do this if
1094 // stack protector isn't being used and the target requests it and we're
1095 // optimizing.
1096 BitVector StackBytesFree;
1097 if (!ObjectsToAllocate.empty() &&
1098 MF.getTarget().getOptLevel() != CodeGenOptLevel::None &&
1100 computeFreeStackSlots(MFI, StackGrowsDown, MinCSFrameIndex, MaxCSFrameIndex,
1101 FixedCSEnd, StackBytesFree);
1102
1103 // Now walk the objects and actually assign base offsets to them.
1104 for (auto &Object : ObjectsToAllocate)
1105 if (!scavengeStackSlot(MFI, Object, StackGrowsDown, MaxAlign,
1106 StackBytesFree))
1107 AdjustStackOffset(MFI, Object, StackGrowsDown, Offset, MaxAlign);
1108
1109 // Make sure the special register scavenging spill slot is closest to the
1110 // stack pointer.
1111 if (RS && !EarlyScavengingSlots) {
1113 RS->getScavengingFrameIndices(SFIs);
1114 for (int SFI : SFIs)
1115 AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign);
1116 }
1117
1119 // If we have reserved argument space for call sites in the function
1120 // immediately on entry to the current function, count it as part of the
1121 // overall stack size.
1122 if (MFI.adjustsStack() && TFI.hasReservedCallFrame(MF))
1123 Offset += MFI.getMaxCallFrameSize();
1124
1125 // Round up the size to a multiple of the alignment. If the function has
1126 // any calls or alloca's, align to the target's StackAlignment value to
1127 // ensure that the callee's frame or the alloca data is suitably aligned;
1128 // otherwise, for leaf functions, align to the TransientStackAlignment
1129 // value.
1130 Align StackAlign;
1131 if (MFI.adjustsStack() || MFI.hasVarSizedObjects() ||
1132 (RegInfo->hasStackRealignment(MF) && MFI.getObjectIndexEnd() != 0))
1133 StackAlign = TFI.getStackAlign();
1134 else
1135 StackAlign = TFI.getTransientStackAlign();
1136
1137 // If the frame pointer is eliminated, all frame offsets will be relative to
1138 // SP not FP. Align to MaxAlign so this works.
1139 StackAlign = std::max(StackAlign, MaxAlign);
1140 int64_t OffsetBeforeAlignment = Offset;
1141 Offset = alignTo(Offset, StackAlign);
1142
1143 // If we have increased the offset to fulfill the alignment constrants,
1144 // then the scavenging spill slots may become harder to reach from the
1145 // stack pointer, float them so they stay close.
1146 if (StackGrowsDown && OffsetBeforeAlignment != Offset && RS &&
1147 !EarlyScavengingSlots) {
1149 RS->getScavengingFrameIndices(SFIs);
1150 LLVM_DEBUG(if (!SFIs.empty()) llvm::dbgs()
1151 << "Adjusting emergency spill slots!\n";);
1152 int64_t Delta = Offset - OffsetBeforeAlignment;
1153 for (int SFI : SFIs) {
1155 << "Adjusting offset of emergency spill slot #" << SFI
1156 << " from " << MFI.getObjectOffset(SFI););
1157 MFI.setObjectOffset(SFI, MFI.getObjectOffset(SFI) - Delta);
1158 LLVM_DEBUG(llvm::dbgs() << " to " << MFI.getObjectOffset(SFI) << "\n";);
1159 }
1160 }
1161 }
1162
1163 // Update frame info to pretend that this is part of the stack...
1164 int64_t StackSize = Offset - LocalAreaOffset;
1165 MFI.setStackSize(StackSize);
1166 NumBytesStackSpace += StackSize;
1167}
1168
1169/// insertPrologEpilogCode - Scan the function for modified callee saved
1170/// registers, insert spill code for these callee saved registers, then add
1171/// prolog and epilog code to the function.
1172void PEI::insertPrologEpilogCode(MachineFunction &MF) {
1174
1175 // Add prologue to the function...
1176 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1177 TFI.emitPrologue(MF, *SaveBlock);
1178
1179 // Add epilogue to restore the callee-save registers in each exiting block.
1180 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)
1181 TFI.emitEpilogue(MF, *RestoreBlock);
1182
1183 // Zero call used registers before restoring callee-saved registers.
1184 insertZeroCallUsedRegs(MF);
1185
1186 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1187 TFI.inlineStackProbe(MF, *SaveBlock);
1188
1189 // Emit additional code that is required to support segmented stacks, if
1190 // we've been asked for it. This, when linked with a runtime with support
1191 // for segmented stacks (libgcc is one), will result in allocating stack
1192 // space in small chunks instead of one large contiguous block.
1193 if (MF.shouldSplitStack()) {
1194 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1195 TFI.adjustForSegmentedStacks(MF, *SaveBlock);
1196 }
1197
1198 // Emit additional code that is required to explicitly handle the stack in
1199 // HiPE native code (if needed) when loaded in the Erlang/OTP runtime. The
1200 // approach is rather similar to that of Segmented Stacks, but it uses a
1201 // different conditional check and another BIF for allocating more stack
1202 // space.
1204 for (MachineBasicBlock *SaveBlock : SaveBlocks)
1205 TFI.adjustForHiPEPrologue(MF, *SaveBlock);
1206}
1207
1208/// insertZeroCallUsedRegs - Zero out call used registers.
1209void PEI::insertZeroCallUsedRegs(MachineFunction &MF) {
1210 const Function &F = MF.getFunction();
1211
1212 if (!F.hasFnAttribute("zero-call-used-regs"))
1213 return;
1214
1215 using namespace ZeroCallUsedRegs;
1216
1217 ZeroCallUsedRegsKind ZeroRegsKind =
1219 F.getFnAttribute("zero-call-used-regs").getValueAsString())
1220 .Case("skip", ZeroCallUsedRegsKind::Skip)
1221 .Case("used-gpr-arg", ZeroCallUsedRegsKind::UsedGPRArg)
1222 .Case("used-gpr", ZeroCallUsedRegsKind::UsedGPR)
1223 .Case("used-arg", ZeroCallUsedRegsKind::UsedArg)
1224 .Case("used", ZeroCallUsedRegsKind::Used)
1225 .Case("all-gpr-arg", ZeroCallUsedRegsKind::AllGPRArg)
1226 .Case("all-gpr", ZeroCallUsedRegsKind::AllGPR)
1227 .Case("all-arg", ZeroCallUsedRegsKind::AllArg)
1228 .Case("all", ZeroCallUsedRegsKind::All);
1229
1230 if (ZeroRegsKind == ZeroCallUsedRegsKind::Skip)
1231 return;
1232
1233 const bool OnlyGPR = static_cast<unsigned>(ZeroRegsKind) & ONLY_GPR;
1234 const bool OnlyUsed = static_cast<unsigned>(ZeroRegsKind) & ONLY_USED;
1235 const bool OnlyArg = static_cast<unsigned>(ZeroRegsKind) & ONLY_ARG;
1236
1238 const BitVector AllocatableSet(TRI.getAllocatableSet(MF));
1239
1240 // Mark all used registers.
1241 BitVector UsedRegs(TRI.getNumRegs());
1242 if (OnlyUsed)
1243 for (const MachineBasicBlock &MBB : MF)
1244 for (const MachineInstr &MI : MBB) {
1245 // skip debug instructions
1246 if (MI.isDebugInstr())
1247 continue;
1248
1249 for (const MachineOperand &MO : MI.operands()) {
1250 if (!MO.isReg())
1251 continue;
1252
1253 MCRegister Reg = MO.getReg();
1254 if (AllocatableSet[Reg] && !MO.isImplicit() &&
1255 (MO.isDef() || MO.isUse()))
1256 UsedRegs.set(Reg);
1257 }
1258 }
1259
1260 // Get a list of registers that are used.
1261 BitVector LiveIns(TRI.getNumRegs());
1262 for (const MachineBasicBlock::RegisterMaskPair &LI : MF.front().liveins())
1263 LiveIns.set(LI.PhysReg);
1264
1265 BitVector RegsToZero(TRI.getNumRegs());
1266 for (MCRegister Reg : AllocatableSet.set_bits()) {
1267 // Skip over fixed registers.
1268 if (TRI.isFixedRegister(MF, Reg))
1269 continue;
1270
1271 // Want only general purpose registers.
1272 if (OnlyGPR && !TRI.isGeneralPurposeRegister(MF, Reg))
1273 continue;
1274
1275 // Want only used registers.
1276 if (OnlyUsed && !UsedRegs[Reg])
1277 continue;
1278
1279 // Want only registers used for arguments.
1280 if (OnlyArg) {
1281 if (OnlyUsed) {
1282 if (!LiveIns[Reg])
1283 continue;
1284 } else if (!TRI.isArgumentRegister(MF, Reg)) {
1285 continue;
1286 }
1287 }
1288
1289 RegsToZero.set(Reg);
1290 }
1291
1292 // Don't clear registers that are live when leaving the function.
1293 for (const MachineBasicBlock &MBB : MF)
1294 for (const MachineInstr &MI : MBB.terminators()) {
1295 if (!MI.isReturn())
1296 continue;
1297
1298 for (const auto &MO : MI.operands()) {
1299 if (!MO.isReg())
1300 continue;
1301
1302 MCRegister Reg = MO.getReg();
1303 if (!Reg)
1304 continue;
1305
1306 // This picks up sibling registers (e.q. %al -> %ah).
1307 for (MCRegUnit Unit : TRI.regunits(Reg))
1308 RegsToZero.reset(Unit);
1309
1310 for (MCPhysReg SReg : TRI.sub_and_superregs_inclusive(Reg))
1311 RegsToZero.reset(SReg);
1312 }
1313 }
1314
1315 // Don't need to clear registers that are used/clobbered by terminating
1316 // instructions.
1317 for (const MachineBasicBlock &MBB : MF) {
1318 if (!MBB.isReturnBlock())
1319 continue;
1320
1323 ++I) {
1324 for (const MachineOperand &MO : I->operands()) {
1325 if (!MO.isReg())
1326 continue;
1327
1328 MCRegister Reg = MO.getReg();
1329 if (!Reg)
1330 continue;
1331
1332 for (const MCPhysReg Reg : TRI.sub_and_superregs_inclusive(Reg))
1333 RegsToZero.reset(Reg);
1334 }
1335 }
1336 }
1337
1338 // Don't clear registers that must be preserved.
1339 for (const MCPhysReg *CSRegs = TRI.getCalleeSavedRegs(&MF);
1340 MCPhysReg CSReg = *CSRegs; ++CSRegs)
1341 for (MCRegister Reg : TRI.sub_and_superregs_inclusive(CSReg))
1342 RegsToZero.reset(Reg);
1343
1344 const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();
1345 for (MachineBasicBlock &MBB : MF)
1346 if (MBB.isReturnBlock())
1347 TFI.emitZeroCallUsedRegs(RegsToZero, MBB);
1348}
1349
1350/// Replace all FrameIndex operands with physical register references and actual
1351/// offsets.
1352void PEI::replaceFrameIndicesBackward(MachineFunction &MF) {
1354
1355 for (auto &MBB : MF) {
1356 int SPAdj = 0;
1357 if (!MBB.succ_empty()) {
1358 // Get the SP adjustment for the end of MBB from the start of any of its
1359 // successors. They should all be the same.
1360 assert(all_of(MBB.successors(), [&MBB](const MachineBasicBlock *Succ) {
1361 return Succ->getCallFrameSize() ==
1362 (*MBB.succ_begin())->getCallFrameSize();
1363 }));
1364 const MachineBasicBlock &FirstSucc = **MBB.succ_begin();
1365 SPAdj = TFI.alignSPAdjust(FirstSucc.getCallFrameSize());
1367 SPAdj = -SPAdj;
1368 }
1369
1370 replaceFrameIndicesBackward(&MBB, MF, SPAdj);
1371
1372 // We can't track the call frame size after call frame pseudos have been
1373 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
1375 }
1376}
1377
1378/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical
1379/// register references and actual offsets.
1380void PEI::replaceFrameIndices(MachineFunction &MF) {
1382
1383 for (auto &MBB : MF) {
1384 int SPAdj = TFI.alignSPAdjust(MBB.getCallFrameSize());
1386 SPAdj = -SPAdj;
1387
1388 replaceFrameIndices(&MBB, MF, SPAdj);
1389
1390 // We can't track the call frame size after call frame pseudos have been
1391 // eliminated. Set it to zero everywhere to keep MachineVerifier happy.
1393 }
1394}
1395
1396bool PEI::replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,
1397 unsigned OpIdx, int SPAdj) {
1400 if (MI.isDebugValue()) {
1401
1402 MachineOperand &Op = MI.getOperand(OpIdx);
1403 assert(MI.isDebugOperand(&Op) &&
1404 "Frame indices can only appear as a debug operand in a DBG_VALUE*"
1405 " machine instruction");
1406 Register Reg;
1407 unsigned FrameIdx = Op.getIndex();
1408 unsigned Size = MF.getFrameInfo().getObjectSize(FrameIdx);
1409
1410 StackOffset Offset = TFI->getFrameIndexReference(MF, FrameIdx, Reg);
1411 Op.ChangeToRegister(Reg, false /*isDef*/);
1412
1413 const DIExpression *DIExpr = MI.getDebugExpression();
1414
1415 // If we have a direct DBG_VALUE, and its location expression isn't
1416 // currently complex, then adding an offset will morph it into a
1417 // complex location that is interpreted as being a memory address.
1418 // This changes a pointer-valued variable to dereference that pointer,
1419 // which is incorrect. Fix by adding DW_OP_stack_value.
1420
1421 if (MI.isNonListDebugValue()) {
1422 unsigned PrependFlags = DIExpression::ApplyOffset;
1423 if (!MI.isIndirectDebugValue() && !DIExpr->isComplex())
1424 PrependFlags |= DIExpression::StackValue;
1425
1426 // If we have DBG_VALUE that is indirect and has a Implicit location
1427 // expression need to insert a deref before prepending a Memory
1428 // location expression. Also after doing this we change the DBG_VALUE
1429 // to be direct.
1430 if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {
1431 SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};
1432 bool WithStackValue = true;
1433 DIExpr = DIExpression::prependOpcodes(DIExpr, Ops, WithStackValue);
1434 // Make the DBG_VALUE direct.
1435 MI.getDebugOffset().ChangeToRegister(0, false);
1436 }
1437 DIExpr = TRI.prependOffsetExpression(DIExpr, PrependFlags, Offset);
1438 } else {
1439 // The debug operand at DebugOpIndex was a frame index at offset
1440 // `Offset`; now the operand has been replaced with the frame
1441 // register, we must add Offset with `register x, plus Offset`.
1442 unsigned DebugOpIndex = MI.getDebugOperandIndex(&Op);
1444 TRI.getOffsetOpcodes(Offset, Ops);
1445 DIExpr = DIExpression::appendOpsToArg(DIExpr, Ops, DebugOpIndex);
1446 }
1447 MI.getDebugExpressionOp().setMetadata(DIExpr);
1448 return true;
1449 }
1450
1451 if (MI.isDebugPHI()) {
1452 // Allow stack ref to continue onwards.
1453 return true;
1454 }
1455
1456 // TODO: This code should be commoned with the code for
1457 // PATCHPOINT. There's no good reason for the difference in
1458 // implementation other than historical accident. The only
1459 // remaining difference is the unconditional use of the stack
1460 // pointer as the base register.
1461 if (MI.getOpcode() == TargetOpcode::STATEPOINT) {
1462 assert((!MI.isDebugValue() || OpIdx == 0) &&
1463 "Frame indicies can only appear as the first operand of a "
1464 "DBG_VALUE machine instruction");
1465 Register Reg;
1466 MachineOperand &Offset = MI.getOperand(OpIdx + 1);
1468 MF, MI.getOperand(OpIdx).getIndex(), Reg, /*IgnoreSPUpdates*/ false);
1469 assert(!refOffset.getScalable() &&
1470 "Frame offsets with a scalable component are not supported");
1471 Offset.setImm(Offset.getImm() + refOffset.getFixed() + SPAdj);
1472 MI.getOperand(OpIdx).ChangeToRegister(Reg, false /*isDef*/);
1473 return true;
1474 }
1475 return false;
1476}
1477
1478void PEI::replaceFrameIndicesBackward(MachineBasicBlock *BB,
1479 MachineFunction &MF, int &SPAdj) {
1481 "getRegisterInfo() must be implemented!");
1482
1486
1487 RegScavenger *LocalRS = FrameIndexEliminationScavenging ? RS : nullptr;
1488 if (LocalRS)
1489 LocalRS->enterBasicBlockEnd(*BB);
1490
1491 for (MachineBasicBlock::iterator I = BB->end(); I != BB->begin();) {
1492 MachineInstr &MI = *std::prev(I);
1493
1494 if (TII.isFrameInstr(MI)) {
1495 SPAdj -= TII.getSPAdjust(MI);
1496 TFI.eliminateCallFramePseudoInstr(MF, *BB, &MI);
1497 continue;
1498 }
1499
1500 // Step backwards to get the liveness state at (immedately after) MI.
1501 if (LocalRS)
1502 LocalRS->backward(I);
1503
1504 bool RemovedMI = false;
1505 for (const auto &[Idx, Op] : enumerate(MI.operands())) {
1506 if (!Op.isFI())
1507 continue;
1508
1509 if (replaceFrameIndexDebugInstr(MF, MI, Idx, SPAdj))
1510 continue;
1511
1512 // Eliminate this FrameIndex operand.
1513 RemovedMI = TRI.eliminateFrameIndex(MI, SPAdj, Idx, LocalRS);
1514 if (RemovedMI)
1515 break;
1516 }
1517
1518 if (!RemovedMI)
1519 --I;
1520 }
1521}
1522
1523void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
1524 int &SPAdj) {
1526 "getRegisterInfo() must be implemented!");
1530
1531 bool InsideCallSequence = false;
1532
1533 for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) {
1534 if (TII.isFrameInstr(*I)) {
1535 InsideCallSequence = TII.isFrameSetup(*I);
1536 SPAdj += TII.getSPAdjust(*I);
1537 I = TFI->eliminateCallFramePseudoInstr(MF, *BB, I);
1538 continue;
1539 }
1540
1541 MachineInstr &MI = *I;
1542 bool DoIncr = true;
1543 bool DidFinishLoop = true;
1544 for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
1545 if (!MI.getOperand(i).isFI())
1546 continue;
1547
1548 if (replaceFrameIndexDebugInstr(MF, MI, i, SPAdj))
1549 continue;
1550
1551 // Some instructions (e.g. inline asm instructions) can have
1552 // multiple frame indices and/or cause eliminateFrameIndex
1553 // to insert more than one instruction. We need the register
1554 // scavenger to go through all of these instructions so that
1555 // it can update its register information. We keep the
1556 // iterator at the point before insertion so that we can
1557 // revisit them in full.
1558 bool AtBeginning = (I == BB->begin());
1559 if (!AtBeginning) --I;
1560
1561 // If this instruction has a FrameIndex operand, we need to
1562 // use that target machine register info object to eliminate
1563 // it.
1564 TRI.eliminateFrameIndex(MI, SPAdj, i);
1565
1566 // Reset the iterator if we were at the beginning of the BB.
1567 if (AtBeginning) {
1568 I = BB->begin();
1569 DoIncr = false;
1570 }
1571
1572 DidFinishLoop = false;
1573 break;
1574 }
1575
1576 // If we are looking at a call sequence, we need to keep track of
1577 // the SP adjustment made by each instruction in the sequence.
1578 // This includes both the frame setup/destroy pseudos (handled above),
1579 // as well as other instructions that have side effects w.r.t the SP.
1580 // Note that this must come after eliminateFrameIndex, because
1581 // if I itself referred to a frame index, we shouldn't count its own
1582 // adjustment.
1583 if (DidFinishLoop && InsideCallSequence)
1584 SPAdj += TII.getSPAdjust(MI);
1585
1586 if (DoIncr && I != BB->end())
1587 ++I;
1588 }
1589}
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.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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:59
#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:167
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:269
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:318
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:695
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1828
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:262
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:669
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()
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
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.
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.
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
unsigned getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
bool hasStackProtectorIndex() const
void setMaxCallFrameSize(unsigned S)
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:68
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:342
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
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:466
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 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 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.
TargetOptions Options
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
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 llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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:456
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
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:1731
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 are tuples (A,...
Definition: STLExtras.h:2386
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()
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:1738
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:428
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:1745
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.