LLVM 20.0.0git
TargetFrameLowering.h
Go to the documentation of this file.
1//===-- llvm/CodeGen/TargetFrameLowering.h ----------------------*- C++ -*-===//
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// Interface to describe the layout of a stack frame on the target machine.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CODEGEN_TARGETFRAMELOWERING_H
14#define LLVM_CODEGEN_TARGETFRAMELOWERING_H
15
16#include "llvm/ADT/BitVector.h"
20#include <vector>
21
22namespace llvm {
23 class BitVector;
24 class CalleeSavedInfo;
25 class MachineFunction;
26 class RegScavenger;
27
28namespace TargetStackID {
29enum Value {
34 NoAlloc = 255
35};
36}
37
38/// Information about stack frame layout on the target. It holds the direction
39/// of stack growth, the known stack alignment on entry to each function, and
40/// the offset to the locals area.
41///
42/// The offset to the local area is the offset from the stack pointer on
43/// function entry to the first location where function data (local variables,
44/// spill locations) can be stored.
46public:
48 StackGrowsUp, // Adding to the stack increases the stack address
49 StackGrowsDown // Adding to the stack decreases the stack address
50 };
51
52 // Maps a callee saved register to a stack slot with a fixed offset.
53 struct SpillSlot {
54 unsigned Reg;
55 int64_t Offset; // Offset relative to stack pointer on function entry.
56 };
57
59 // The frame base may be either a register (the default), the CFA with an
60 // offset, or a WebAssembly-specific location description.
63 unsigned Kind; // Wasm local, global, or value stack
64 unsigned Index;
65 };
66 union {
67 // Used with FrameBaseKind::Register.
68 unsigned Reg;
69 // Used with FrameBaseKind::CFA.
70 int64_t Offset;
73 };
74
75private:
76 StackDirection StackDir;
77 Align StackAlignment;
78 Align TransientStackAlignment;
79 int LocalAreaOffset;
80 bool StackRealignable;
81public:
83 Align TransAl = Align(1), bool StackReal = true)
84 : StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
85 LocalAreaOffset(LAO), StackRealignable(StackReal) {}
86
88
89 // These methods return information that describes the abstract stack layout
90 // of the target machine.
91
92 /// getStackGrowthDirection - Return the direction the stack grows
93 ///
94 StackDirection getStackGrowthDirection() const { return StackDir; }
95
96 /// getStackAlignment - This method returns the number of bytes to which the
97 /// stack pointer must be aligned on entry to a function. Typically, this
98 /// is the largest alignment for any data object in the target.
99 ///
100 unsigned getStackAlignment() const { return StackAlignment.value(); }
101 /// getStackAlignment - This method returns the number of bytes to which the
102 /// stack pointer must be aligned on entry to a function. Typically, this
103 /// is the largest alignment for any data object in the target.
104 ///
105 Align getStackAlign() const { return StackAlignment; }
106
107 /// getStackThreshold - Return the maximum stack size
108 ///
109 virtual uint64_t getStackThreshold() const { return UINT_MAX; }
110
111 /// alignSPAdjust - This method aligns the stack adjustment to the correct
112 /// alignment.
113 ///
114 int alignSPAdjust(int SPAdj) const {
115 if (SPAdj < 0) {
116 SPAdj = -alignTo(-SPAdj, StackAlignment);
117 } else {
118 SPAdj = alignTo(SPAdj, StackAlignment);
119 }
120 return SPAdj;
121 }
122
123 /// getTransientStackAlignment - This method returns the number of bytes to
124 /// which the stack pointer must be aligned at all times, even between
125 /// calls.
126 ///
127 Align getTransientStackAlign() const { return TransientStackAlignment; }
128
129 /// isStackRealignable - This method returns whether the stack can be
130 /// realigned.
131 bool isStackRealignable() const {
132 return StackRealignable;
133 }
134
135 /// This method returns whether or not it is safe for an object with the
136 /// given stack id to be bundled into the local area.
137 virtual bool isStackIdSafeForLocalArea(unsigned StackId) const {
138 return true;
139 }
140
141 /// getOffsetOfLocalArea - This method returns the offset of the local area
142 /// from the stack pointer on entrance to a function.
143 ///
144 int getOffsetOfLocalArea() const { return LocalAreaOffset; }
145
146 /// Control the placement of special register scavenging spill slots when
147 /// allocating a stack frame.
148 ///
149 /// If this returns true, the frame indexes used by the RegScavenger will be
150 /// allocated closest to the incoming stack pointer.
152 const MachineFunction &MF) const;
153
154 /// assignCalleeSavedSpillSlots - Allows target to override spill slot
155 /// assignment logic. If implemented, assignCalleeSavedSpillSlots() should
156 /// assign frame slots to all CSI entries and return true. If this method
157 /// returns false, spill slots will be assigned using generic implementation.
158 /// assignCalleeSavedSpillSlots() may add, delete or rearrange elements of
159 /// CSI.
161 const TargetRegisterInfo *TRI,
162 std::vector<CalleeSavedInfo> &CSI,
163 unsigned &MinCSFrameIndex,
164 unsigned &MaxCSFrameIndex) const {
165 return assignCalleeSavedSpillSlots(MF, TRI, CSI);
166 }
167
168 virtual bool
170 const TargetRegisterInfo *TRI,
171 std::vector<CalleeSavedInfo> &CSI) const {
172 return false;
173 }
174
175 /// getCalleeSavedSpillSlots - This method returns a pointer to an array of
176 /// pairs, that contains an entry for each callee saved register that must be
177 /// spilled to a particular stack location if it is spilled.
178 ///
179 /// Each entry in this array contains a <register,offset> pair, indicating the
180 /// fixed offset from the incoming stack pointer that each register should be
181 /// spilled at. If a register is not listed here, the code generator is
182 /// allowed to spill it anywhere it chooses.
183 ///
184 virtual const SpillSlot *
185 getCalleeSavedSpillSlots(unsigned &NumEntries) const {
186 NumEntries = 0;
187 return nullptr;
188 }
189
190 /// targetHandlesStackFrameRounding - Returns true if the target is
191 /// responsible for rounding up the stack frame (probably at emitPrologue
192 /// time).
193 virtual bool targetHandlesStackFrameRounding() const {
194 return false;
195 }
196
197 /// Returns true if the target will correctly handle shrink wrapping.
198 virtual bool enableShrinkWrapping(const MachineFunction &MF) const {
199 return false;
200 }
201
202 /// Returns true if the stack slot holes in the fixed and callee-save stack
203 /// area should be used when allocating other stack locations to reduce stack
204 /// size.
205 virtual bool enableStackSlotScavenging(const MachineFunction &MF) const {
206 return false;
207 }
208
209 /// Returns true if the target can safely skip saving callee-saved registers
210 /// for noreturn nounwind functions.
211 virtual bool enableCalleeSaveSkip(const MachineFunction &MF) const;
212
213 /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
214 /// the function.
216 MachineBasicBlock &MBB) const = 0;
218 MachineBasicBlock &MBB) const = 0;
219
220 /// emitZeroCallUsedRegs - Zeros out call used registers.
221 virtual void emitZeroCallUsedRegs(BitVector RegsToZero,
222 MachineBasicBlock &MBB) const {}
223
224 /// With basic block sections, emit callee saved frame moves for basic blocks
225 /// that are in a different section.
226 virtual void
229
230 /// Returns true if we may need to fix the unwind information for the
231 /// function.
232 virtual bool enableCFIFixup(MachineFunction &MF) const;
233
234 /// Emit CFI instructions that recreate the state of the unwind information
235 /// upon fucntion entry.
237
238 /// Replace a StackProbe stub (if any) with the actual probe code inline
240 MachineBasicBlock &PrologueMBB) const {}
241
242 /// Does the stack probe function call return with a modified stack pointer?
243 virtual bool stackProbeFunctionModifiesSP() const { return false; }
244
245 /// Adjust the prologue to have the function use segmented stacks. This works
246 /// by adding a check even before the "normal" function prologue.
248 MachineBasicBlock &PrologueMBB) const {}
249
250 /// Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in
251 /// the assembly prologue to explicitly handle the stack.
253 MachineBasicBlock &PrologueMBB) const {}
254
255 /// spillCalleeSavedRegisters - Issues instruction(s) to spill all callee
256 /// saved registers and returns true if it isn't possible / profitable to do
257 /// so by issuing a series of store instructions via
258 /// storeRegToStackSlot(). Returns false otherwise.
262 const TargetRegisterInfo *TRI) const {
263 return false;
264 }
265
266 /// restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee
267 /// saved registers and returns true if it isn't possible / profitable to do
268 /// so by issuing a series of load instructions via loadRegToStackSlot().
269 /// If it returns true, and any of the registers in CSI is not restored,
270 /// it sets the corresponding Restored flag in CSI to false.
271 /// Returns false otherwise.
272 virtual bool
276 const TargetRegisterInfo *TRI) const {
277 return false;
278 }
279
280 /// Return true if the target wants to keep the frame pointer regardless of
281 /// the function attribute "frame-pointer".
282 virtual bool keepFramePointer(const MachineFunction &MF) const {
283 return false;
284 }
285
286 /// hasFP - Return true if the specified function should have a dedicated
287 /// frame pointer register. For most targets this is true only if the function
288 /// has variable sized allocas or if frame pointer elimination is disabled.
289 virtual bool hasFP(const MachineFunction &MF) const = 0;
290
291 /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
292 /// not required, we reserve argument space for call sites in the function
293 /// immediately on entry to the current function. This eliminates the need for
294 /// add/sub sp brackets around call sites. Returns true if the call frame is
295 /// included as part of the stack frame.
296 virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
297 return !hasFP(MF);
298 }
299
300 /// canSimplifyCallFramePseudos - When possible, it's best to simplify the
301 /// call frame pseudo ops before doing frame index elimination. This is
302 /// possible only when frame index references between the pseudos won't
303 /// need adjusting for the call frame adjustments. Normally, that's true
304 /// if the function has a reserved call frame or a frame pointer. Some
305 /// targets (Thumb2, for example) may have more complicated criteria,
306 /// however, and can override this behavior.
307 virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const {
308 return hasReservedCallFrame(MF) || hasFP(MF);
309 }
310
311 // needsFrameIndexResolution - Do we need to perform FI resolution for
312 // this function. Normally, this is required only when the function
313 // has any stack objects. However, targets may want to override this.
314 virtual bool needsFrameIndexResolution(const MachineFunction &MF) const;
315
316 /// getFrameIndexReference - This method should return the base register
317 /// and offset used to reference a frame index location. The offset is
318 /// returned directly, and the base register is returned via FrameReg.
319 virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
320 Register &FrameReg) const;
321
322 /// Same as \c getFrameIndexReference, except that the stack pointer (as
323 /// opposed to the frame pointer) will be the preferred value for \p
324 /// FrameReg. This is generally used for emitting statepoint or EH tables that
325 /// use offsets from RSP. If \p IgnoreSPUpdates is true, the returned
326 /// offset is only guaranteed to be valid with respect to the value of SP at
327 /// the end of the prologue.
328 virtual StackOffset
330 Register &FrameReg,
331 bool IgnoreSPUpdates) const {
332 // Always safe to dispatch to getFrameIndexReference.
333 return getFrameIndexReference(MF, FI, FrameReg);
334 }
335
336 /// getNonLocalFrameIndexReference - This method returns the offset used to
337 /// reference a frame index location. The offset can be from either FP/BP/SP
338 /// based on which base register is returned by llvm.localaddress.
340 int FI) const {
341 // By default, dispatch to getFrameIndexReference. Interested targets can
342 // override this.
343 Register FrameReg;
344 return getFrameIndexReference(MF, FI, FrameReg);
345 }
346
347 /// getFrameIndexReferenceFromSP - This method returns the offset from the
348 /// stack pointer to the slot of the specified index. This function serves to
349 /// provide a comparable offset from a single reference point (the value of
350 /// the stack-pointer at function entry) that can be used for analysis.
352 int FI) const;
353
354 /// Returns the callee-saved registers as computed by determineCalleeSaves
355 /// in the BitVector \p SavedRegs.
356 virtual void getCalleeSaves(const MachineFunction &MF,
357 BitVector &SavedRegs) const;
358
359 /// This method determines which of the registers reported by
360 /// TargetRegisterInfo::getCalleeSavedRegs() should actually get saved.
361 /// The default implementation checks populates the \p SavedRegs bitset with
362 /// all registers which are modified in the function, targets may override
363 /// this function to save additional registers.
364 /// This method also sets up the register scavenger ensuring there is a free
365 /// register or a frameindex available.
366 /// This method should not be called by any passes outside of PEI, because
367 /// it may change state passed in by \p MF and \p RS. The preferred
368 /// interface outside PEI is getCalleeSaves.
369 virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
370 RegScavenger *RS = nullptr) const;
371
372 /// processFunctionBeforeFrameFinalized - This method is called immediately
373 /// before the specified function's frame layout (MF.getFrameInfo()) is
374 /// finalized. Once the frame is finalized, MO_FrameIndex operands are
375 /// replaced with direct constants. This method is optional.
376 ///
378 RegScavenger *RS = nullptr) const {
379 }
380
381 /// processFunctionBeforeFrameIndicesReplaced - This method is called
382 /// immediately before MO_FrameIndex operands are eliminated, but after the
383 /// frame is finalized. This method is optional.
384 virtual void
386 RegScavenger *RS = nullptr) const {}
387
388 virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const {
389 report_fatal_error("WinEH not implemented for this target");
390 }
391
392 /// This method is called during prolog/epilog code insertion to eliminate
393 /// call frame setup and destroy pseudo instructions (but only if the Target
394 /// is using them). It is responsible for eliminating these instructions,
395 /// replacing them with concrete instructions. This method need only be
396 /// implemented if using call frame setup/destroy pseudo instructions.
397 /// Returns an iterator pointing to the instruction after the replaced one.
402 llvm_unreachable("Call Frame Pseudo Instructions do not exist on this "
403 "target!");
404 }
405
406
407 /// Order the symbols in the local stack frame.
408 /// The list of objects that we want to order is in \p objectsToAllocate as
409 /// indices into the MachineFrameInfo. The array can be reordered in any way
410 /// upon return. The contents of the array, however, may not be modified (i.e.
411 /// only their order may be changed).
412 /// By default, just maintain the original order.
413 virtual void
415 SmallVectorImpl<int> &objectsToAllocate) const {
416 }
417
418 /// Check whether or not the given \p MBB can be used as a prologue
419 /// for the target.
420 /// The prologue will be inserted first in this basic block.
421 /// This method is used by the shrink-wrapping pass to decide if
422 /// \p MBB will be correctly handled by the target.
423 /// As soon as the target enable shrink-wrapping without overriding
424 /// this method, we assume that each basic block is a valid
425 /// prologue.
426 virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const {
427 return true;
428 }
429
430 /// Check whether or not the given \p MBB can be used as a epilogue
431 /// for the target.
432 /// The epilogue will be inserted before the first terminator of that block.
433 /// This method is used by the shrink-wrapping pass to decide if
434 /// \p MBB will be correctly handled by the target.
435 /// As soon as the target enable shrink-wrapping without overriding
436 /// this method, we assume that each basic block is a valid
437 /// epilogue.
438 virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const {
439 return true;
440 }
441
442 /// Returns the StackID that scalable vectors should be associated with.
445 }
446
448 switch (ID) {
449 default:
450 return false;
453 return true;
454 }
455 }
456
457 /// Check if given function is safe for not having callee saved registers.
458 /// This is used when interprocedural register allocation is enabled.
459 static bool isSafeForNoCSROpt(const Function &F);
460
461 /// Check if the no-CSR optimisation is profitable for the given function.
462 virtual bool isProfitableForNoCSROpt(const Function &F) const {
463 return true;
464 }
465
466 /// Return initial CFA offset value i.e. the one valid at the beginning of the
467 /// function (before any stack operations).
468 virtual int getInitialCFAOffset(const MachineFunction &MF) const;
469
470 /// Return initial CFA register value i.e. the one valid at the beginning of
471 /// the function (before any stack operations).
472 virtual Register getInitialCFARegister(const MachineFunction &MF) const;
473
474 /// Return the frame base information to be encoded in the DWARF subprogram
475 /// debug info.
476 virtual DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const;
477
478 /// If frame pointer or base pointer is clobbered by an instruction, we should
479 /// spill/restore it around that instruction.
480 virtual void spillFPBP(MachineFunction &MF) const {}
481
482 /// This method is called at the end of prolog/epilog code insertion, so
483 /// targets can emit remarks based on the final frame layout.
484 virtual void emitRemarks(const MachineFunction &MF,
486};
487
488} // End llvm namespace
489
490#endif
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file implements the BitVector class.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
uint64_t Align
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
unsigned const TargetRegisterInfo * TRI
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:587
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:33
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...
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
virtual void emitCalleeSavedFrameMovesFullCFA(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const
With basic block sections, emit callee saved frame moves for basic blocks that are in a different sec...
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 bool enableCalleeSaveSkip(const MachineFunction &MF) const
Returns true if the target can safely skip saving callee-saved registers for noreturn nounwind functi...
virtual bool enableShrinkWrapping(const MachineFunction &MF) const
Returns true if the target will correctly handle shrink wrapping.
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 bool isStackIdSafeForLocalArea(unsigned StackId) const
This method returns whether or not it is safe for an object with the given stack id to be bundled int...
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...
virtual Register getInitialCFARegister(const MachineFunction &MF) const
Return initial CFA register value i.e.
virtual bool stackProbeFunctionModifiesSP() const
Does the stack probe function call return with a modified stack pointer?
virtual bool hasFP(const MachineFunction &MF) const =0
hasFP - Return true if the specified function should have a dedicated frame pointer register.
bool isStackRealignable() const
isStackRealignable - This method returns whether the stack can be realigned.
virtual TargetStackID::Value getStackIDForScalableVectors() const
Returns the StackID that scalable vectors should be associated with.
virtual void getCalleeSaves(const MachineFunction &MF, BitVector &SavedRegs) const
Returns the callee-saved registers as computed by determineCalleeSaves in the BitVector SavedRegs.
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
virtual DwarfFrameBase getDwarfFrameBase(const MachineFunction &MF) const
Return the frame base information to be encoded in the DWARF subprogram debug info.
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.
TargetFrameLowering(StackDirection D, Align StackAl, int LAO, Align TransAl=Align(1), bool StackReal=true)
virtual bool needsFrameIndexResolution(const MachineFunction &MF) const
virtual bool isSupportedStackID(TargetStackID::Value ID) 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 StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF, int FI) const
getNonLocalFrameIndexReference - This method returns the offset used to reference a frame index locat...
virtual bool keepFramePointer(const MachineFunction &MF) const
Return true if the target wants to keep the frame pointer regardless of the function attribute "frame...
virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const
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 ...
virtual bool isProfitableForNoCSROpt(const Function &F) const
Check if the no-CSR optimisation is profitable for the given function.
StackDirection getStackGrowthDirection() const
getStackGrowthDirection - Return the direction the stack grows
virtual bool canUseAsEpilogue(const MachineBasicBlock &MBB) const
Check whether or not the given MBB can be used as a epilogue for the target.
virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const
Adjust the prologue to have the function use segmented stacks.
virtual bool canUseAsPrologue(const MachineBasicBlock &MBB) const
Check whether or not the given MBB can be used as a prologue for the target.
int alignSPAdjust(int SPAdj) const
alignSPAdjust - This method aligns the stack adjustment to the correct alignment.
static bool isSafeForNoCSROpt(const Function &F)
Check if given function is safe for not having callee saved registers.
virtual void resetCFIToInitialState(MachineBasicBlock &MBB) const
Emit CFI instructions that recreate the state of the unwind information upon fucntion entry.
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 enableCFIFixup(MachineFunction &MF) const
Returns true if we may need to fix the unwind information for the function.
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 StackOffset getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI) const
getFrameIndexReferenceFromSP - This method returns the offset from the stack pointer to the slot of t...
virtual bool targetHandlesStackFrameRounding() const
targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...
virtual int getInitialCFAOffset(const MachineFunction &MF) const
Return initial CFA offset value i.e.
virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const
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...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
union llvm::TargetFrameLowering::DwarfFrameBase::@246 Location
enum llvm::TargetFrameLowering::DwarfFrameBase::FrameBaseKind Kind