LLVM 17.0.0git
X86FrameLowering.h
Go to the documentation of this file.
1//===-- X86TargetFrameLowering.h - Define frame lowering for X86 -*- 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// This class implements X86-specific bits of TargetFrameLowering class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
14#define LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
15
19
20namespace llvm {
21
22class MachineInstrBuilder;
23class MCCFIInstruction;
24class X86InstrInfo;
25class X86Subtarget;
26class X86RegisterInfo;
27
29public:
30 X86FrameLowering(const X86Subtarget &STI, MaybeAlign StackAlignOverride);
31
32 // Cached subtarget predicates.
33
37
38 unsigned SlotSize;
39
40 /// Is64Bit implies that x86_64 instructions are available.
41 bool Is64Bit;
42
43 bool IsLP64;
44
45 /// True if the 64-bit frame or stack pointer should be used. True for most
46 /// 64-bit targets with the exception of x32. If this is false, 32-bit
47 /// instruction operands should be used to manipulate StackPtr and FramePtr.
49
50 unsigned StackPtr;
51
52 /// Emit target stack probe code. This is required for all
53 /// large stack allocations on Windows. The caller is required to materialize
54 /// the number of bytes to probe in RAX/EAX.
55 /// \p InstrNum optionally contains a debug-info instruction number for the
56 /// new stack pointer.
59 bool InProlog,
60 std::optional<MachineFunction::DebugInstrOperandPair>
61 InstrNum = std::nullopt) const;
62
63 bool stackProbeFunctionModifiesSP() const override;
64
65 /// Replace a StackProbe inline-stub with the actual probe code inline.
67 MachineBasicBlock &PrologMBB) const override;
68
71
74 const DebugLoc &DL, bool IsPrologue) const;
75
76 /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
77 /// the function.
78 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
79 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
80
82 MachineBasicBlock &PrologueMBB) const override;
83
85 MachineBasicBlock &PrologueMBB) const override;
86
88 RegScavenger *RS = nullptr) const override;
89
90 bool
93 std::vector<CalleeSavedInfo> &CSI) const override;
94
98 const TargetRegisterInfo *TRI) const override;
99
100 bool
104 const TargetRegisterInfo *TRI) const override;
105
106 bool hasFP(const MachineFunction &MF) const override;
107 bool hasReservedCallFrame(const MachineFunction &MF) const override;
108 bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
109 bool needsFrameIndexResolution(const MachineFunction &MF) const override;
110
112 Register &FrameReg) const override;
113
114 int getWin64EHFrameIndexRef(const MachineFunction &MF, int FI,
115 Register &SPReg) const;
117 Register &SPReg, int Adjustment) const;
120 Register &FrameReg,
121 bool IgnoreSPUpdates) const override;
122
125 MachineBasicBlock::iterator MI) const override;
126
127 unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
128
130 RegScavenger *RS) const override;
131
132 void
134 RegScavenger *RS) const override;
135
136 /// Check the instruction before/after the passed instruction. If
137 /// it is an ADD/SUB/LEA instruction it is deleted argument and the
138 /// stack adjustment is returned as a positive value for ADD/LEA and
139 /// a negative for SUB.
141 bool doMergeWithPrevious) const;
142
143 /// Emit a series of instructions to increment / decrement the stack
144 /// pointer by a constant value.
146 const DebugLoc &DL, int64_t NumBytes, bool InEpilogue) const;
147
148 /// Check that LEA can be used on SP in an epilogue sequence for \p MF.
149 bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const;
150
151 /// Check whether or not the given \p MBB can be used as a prologue
152 /// for the target.
153 /// The prologue will be inserted first in this basic block.
154 /// This method is used by the shrink-wrapping pass to decide if
155 /// \p MBB will be correctly handled by the target.
156 /// As soon as the target enable shrink-wrapping without overriding
157 /// this method, we assume that each basic block is a valid
158 /// prologue.
159 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
160
161 /// Check whether or not the given \p MBB can be used as a epilogue
162 /// for the target.
163 /// The epilogue will be inserted before the first terminator of that block.
164 /// This method is used by the shrink-wrapping pass to decide if
165 /// \p MBB will be correctly handled by the target.
166 bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
167
168 /// Returns true if the target will correctly handle shrink wrapping.
169 bool enableShrinkWrapping(const MachineFunction &MF) const override;
170
171 /// Order the symbols in the local stack.
172 /// We want to place the local stack objects in some sort of sensible order.
173 /// The heuristic we use is to try and pack them according to static number
174 /// of uses and size in order to minimize code size.
175 void orderFrameObjects(const MachineFunction &MF,
176 SmallVectorImpl<int> &ObjectsToAllocate) const override;
177
178 /// Wraps up getting a CFI index and building a MachineInstr for it.
180 const DebugLoc &DL, const MCCFIInstruction &CFIInst,
182
183 /// Sets up EBP and optionally ESI based on the incoming EBP value. Only
184 /// needed for 32-bit. Used in funclet prologues and at catchret destinations.
188 const DebugLoc &DL, bool RestoreSP = false) const;
189
191
192 int getInitialCFAOffset(const MachineFunction &MF) const override;
193
194 Register getInitialCFARegister(const MachineFunction &MF) const override;
195
196 /// Return true if the function has a redzone (accessible bytes past the
197 /// frame of the top of stack function) as part of it's ABI.
198 bool has128ByteRedZone(const MachineFunction& MF) const;
199
200private:
201 bool isWin64Prologue(const MachineFunction &MF) const;
202
203 bool needsDwarfCFI(const MachineFunction &MF) const;
204
205 uint64_t calculateMaxStackAlign(const MachineFunction &MF) const;
206
207 /// Emit target stack probe as a call to a helper function
208 void emitStackProbeCall(
210 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, bool InProlog,
211 std::optional<MachineFunction::DebugInstrOperandPair> InstrNum) const;
212
213 /// Emit target stack probe as an inline sequence.
214 void emitStackProbeInline(MachineFunction &MF, MachineBasicBlock &MBB,
216 const DebugLoc &DL, bool InProlog) const;
217 void emitStackProbeInlineWindowsCoreCLR64(MachineFunction &MF,
220 const DebugLoc &DL,
221 bool InProlog) const;
222 void emitStackProbeInlineGeneric(MachineFunction &MF, MachineBasicBlock &MBB,
224 const DebugLoc &DL, bool InProlog) const;
225
226 void emitStackProbeInlineGenericBlock(MachineFunction &MF,
229 const DebugLoc &DL, uint64_t Offset,
230 uint64_t Align) const;
231
232 void emitStackProbeInlineGenericLoop(MachineFunction &MF,
235 const DebugLoc &DL, uint64_t Offset,
236 uint64_t Align) const;
237
238 /// Emit target zero call-used regs.
239 void emitZeroCallUsedRegs(BitVector RegsToZero,
240 MachineBasicBlock &MBB) const override;
241
242 void adjustFrameForMsvcCxxEh(MachineFunction &MF) const;
243
244 /// Aligns the stack pointer by ANDing it with -MaxAlign.
245 void BuildStackAlignAND(MachineBasicBlock &MBB,
247 unsigned Reg, uint64_t MaxAlign) const;
248
249 /// Make small positive stack adjustments using POPs.
250 bool adjustStackWithPops(MachineBasicBlock &MBB,
252 int Offset) const;
253
254 /// Adjusts the stack pointer using LEA, SUB, or ADD.
255 MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
257 const DebugLoc &DL, int64_t Offset,
258 bool InEpilogue) const;
259
260 unsigned getPSPSlotOffsetFromSP(const MachineFunction &MF) const;
261
262 unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
263
264 /// Materialize the catchret target MBB in RAX.
265 void emitCatchRetReturnValue(MachineBasicBlock &MBB,
267 MachineInstr *CatchRet) const;
268};
269
270} // End llvm namespace
271
272#endif
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
IRTranslator LLVM IR MI
unsigned Reg
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
A debug info location.
Definition: DebugLoc.h:33
Representation of each machine instruction.
Definition: MachineInstr.h:68
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.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
bool has128ByteRedZone(const MachineFunction &MF) const
Return true if the function has a redzone (accessible bytes past the frame of the top of stack functi...
bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override
canSimplifyCallFramePseudos - If there is a reserved call frame, the call frame pseudos can be simpli...
bool needsFrameIndexResolution(const MachineFunction &MF) const override
const X86RegisterInfo * TRI
bool hasFP(const MachineFunction &MF) const override
hasFP - Return true if the specified function should have a dedicated frame pointer register.
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
MachineBasicBlock::iterator restoreWin32EHStackPointers(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, bool RestoreSP=false) const
Sets up EBP and optionally ESI based on the incoming EBP value.
int getInitialCFAOffset(const MachineFunction &MF) const override
Return initial CFA offset value i.e.
bool canUseAsPrologue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a prologue for the target.
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
void emitStackProbe(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, bool InProlog, std::optional< MachineFunction::DebugInstrOperandPair > InstrNum=std::nullopt) const
Emit target stack probe code.
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, bool IsPrologue) const
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
StackOffset getFrameIndexReferenceSP(const MachineFunction &MF, int FI, Register &SPReg, int Adjustment) const
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const override
bool enableShrinkWrapping(const MachineFunction &MF) const override
Returns true if the target will correctly handle shrink wrapping.
StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const override
getFrameIndexReference - This method should return the base register and offset used to reference a f...
void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologMBB) const override
Replace a StackProbe inline-stub with the actual probe code inline.
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
const X86InstrInfo & TII
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, const DebugLoc &DL, int64_t NumBytes, bool InEpilogue) const
Emit a series of instructions to increment / decrement the stack pointer by a constant value.
bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a epilogue for the target.
bool Is64Bit
Is64Bit implies that x86_64 instructions are available.
Register getInitialCFARegister(const MachineFunction &MF) const override
Return initial CFA register value i.e.
bool Uses64BitFramePtr
True if the 64-bit frame or stack pointer should be used.
unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override
void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const override
Adjust the prologue to have the function use segmented stacks.
void emitCalleeSavedFrameMovesFullCFA(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const override
Emits Dwarf Info specifying offsets of callee saved registers and frame pointer.
int getWin64EHFrameIndexRef(const MachineFunction &MF, int FI, Register &SPReg) const
bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const
Check that LEA can be used on SP in an epilogue sequence for MF.
bool stackProbeFunctionModifiesSP() const override
Does the stack probe function call return with a modified stack pointer?
void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &ObjectsToAllocate) const override
Order the symbols in the local stack.
void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, const MCCFIInstruction &CFIInst, MachineInstr::MIFlag Flag=MachineInstr::NoFlags) const
Wraps up getting a CFI index and building a MachineInstr for it.
int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, bool doMergeWithPrevious) const
Check the instruction before/after the passed instruction.
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...
StackOffset getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, Register &FrameReg, bool IgnoreSPUpdates) const override
Same as getFrameIndexReference, except that the stack pointer (as opposed to the frame pointer) will ...
void restoreWinEHStackPointersInParent(MachineFunction &MF) const
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
void adjustForHiPEPrologue(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const override
Erlang programs may need a special prologue to handle the stack size they might need at runtime.
const X86Subtarget & STI
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117