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