LLVM 20.0.0git
AArch64FrameLowering.h
Go to the documentation of this file.
1//==-- AArch64FrameLowering.h - TargetFrameLowering for AArch64 --*- 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//
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
14#define LLVM_LIB_TARGET_AARCH64_AARCH64FRAMELOWERING_H
15
19
20namespace llvm {
21
23public:
26 true /*StackRealignable*/) {}
27
28 void resetCFIToInitialState(MachineBasicBlock &MBB) const override;
29
32 MachineBasicBlock::iterator I) const override;
33
34 /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
35 /// the function.
36 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
37 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
38
39 bool enableCFIFixup(MachineFunction &MF) const override;
40
41 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
42
44 Register &FrameReg) const override;
46 int FI) const override;
48 Register &FrameReg, bool PreferFP,
49 bool ForSimm) const;
51 int64_t ObjectOffset, bool isFixed,
52 bool isSVE, Register &FrameReg,
53 bool PreferFP, bool ForSimm) const;
57 const TargetRegisterInfo *TRI) const override;
58
59 bool
63 const TargetRegisterInfo *TRI) const override;
64
65 /// Can this function use the red zone for local allocations.
66 bool canUseRedZone(const MachineFunction &MF) const;
67
68 bool hasReservedCallFrame(const MachineFunction &MF) const override;
69
72 std::vector<CalleeSavedInfo> &CSI,
73 unsigned &MinCSFrameIndex,
74 unsigned &MaxCSFrameIndex) const override;
75
77 RegScavenger *RS) const override;
78
79 /// Returns true if the target will correctly handle shrink wrapping.
80 bool enableShrinkWrapping(const MachineFunction &MF) const override {
81 return true;
82 }
83
84 bool enableStackSlotScavenging(const MachineFunction &MF) const override;
86
88 RegScavenger *RS) const override;
89
90 void
92 RegScavenger *RS) const override;
93
94 unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
95
96 unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
97
100 Register &FrameReg,
101 bool IgnoreSPUpdates) const override;
103 int FI) const override;
104 int getSEHFrameIndexOffset(const MachineFunction &MF, int FI) const;
105
107 switch (ID) {
108 default:
109 return false;
113 return true;
114 }
115 }
116
117 bool isStackIdSafeForLocalArea(unsigned StackId) const override {
118 // We don't support putting SVE objects into the pre-allocated local
119 // frame block at the moment.
120 return StackId != TargetStackID::ScalableVector;
121 }
122
123 void
125 SmallVectorImpl<int> &ObjectsToAllocate) const override;
126
127protected:
128 bool hasFPImpl(const MachineFunction &MF) const override;
129
130private:
131 /// Returns true if a homogeneous prolog or epilog code can be emitted
132 /// for the size optimization. If so, HOM_Prolog/HOM_Epilog pseudo
133 /// instructions are emitted in place. When Exit block is given, this check is
134 /// for epilog.
135 bool homogeneousPrologEpilog(MachineFunction &MF,
136 MachineBasicBlock *Exit = nullptr) const;
137
138 /// Returns true if CSRs should be paired.
139 bool producePairRegisters(MachineFunction &MF) const;
140
141 bool shouldCombineCSRLocalStackBump(MachineFunction &MF,
142 uint64_t StackBumpBytes) const;
143
144 int64_t estimateSVEStackObjectOffsets(MachineFrameInfo &MF) const;
145 int64_t assignSVEStackObjectOffsets(MachineFrameInfo &MF,
146 int &MinCSFrameIndex,
147 int &MaxCSFrameIndex) const;
148 bool shouldCombineCSRLocalStackBumpInEpilogue(MachineBasicBlock &MBB,
149 unsigned StackBumpBytes) const;
150 void emitCalleeSavedGPRLocations(MachineBasicBlock &MBB,
152 void emitCalleeSavedSVELocations(MachineBasicBlock &MBB,
154 void emitCalleeSavedGPRRestores(MachineBasicBlock &MBB,
156 void emitCalleeSavedSVERestores(MachineBasicBlock &MBB,
158 void allocateStackSpace(MachineBasicBlock &MBB,
160 int64_t RealignmentPadding, StackOffset AllocSize,
161 bool NeedsWinCFI, bool *HasWinCFI, bool EmitCFI,
162 StackOffset InitialOffset, bool FollowupAllocs) const;
163 /// Make a determination whether a Hazard slot is used and create it if
164 /// needed.
165 void determineStackHazardSlot(MachineFunction &MF,
166 BitVector &SavedRegs) const;
167
168 /// Emit target zero call-used regs.
169 void emitZeroCallUsedRegs(BitVector RegsToZero,
170 MachineBasicBlock &MBB) const override;
171
172 /// Replace a StackProbe stub (if any) with the actual probe code inline
173 void inlineStackProbe(MachineFunction &MF,
174 MachineBasicBlock &PrologueMBB) const override;
175
176 void inlineStackProbeFixed(MachineBasicBlock::iterator MBBI,
177 Register ScratchReg, int64_t FrameSize,
178 StackOffset CFAOffset) const;
179
181 inlineStackProbeLoopExactMultiple(MachineBasicBlock::iterator MBBI,
182 int64_t NegProbeSize,
183 Register TargetReg) const;
184
185 void emitRemarks(const MachineFunction &MF,
186 MachineOptimizationRemarkEmitter *ORE) const override;
187};
188
189} // End llvm namespace
190
191#endif
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator MBBI
basic Basic Alias true
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
unsigned const TargetRegisterInfo * TRI
void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
bool canUseAsPrologue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a prologue for the target.
bool enableStackSlotScavenging(const MachineFunction &MF) const override
Returns true if the stack slot holes in the fixed and callee-save stack area should be used when allo...
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...
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...
StackOffset getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI) const override
getFrameIndexReferenceFromSP - This method returns the offset from the stack pointer to the slot of t...
StackOffset getNonLocalFrameIndexReference(const MachineFunction &MF, int FI) const override
getNonLocalFrameIndexReference - This method returns the offset used to reference a frame index locat...
TargetStackID::Value getStackIDForScalableVectors() const override
Returns the StackID that scalable vectors should be associated with.
bool hasFPImpl(const MachineFunction &MF) const override
hasFPImpl - Return true if the specified function should have a dedicated frame pointer register.
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
bool enableCFIFixup(MachineFunction &MF) const override
Returns true if we may need to fix the unwind information for the function.
void resetCFIToInitialState(MachineBasicBlock &MBB) const override
Emit CFI instructions that recreate the state of the unwind information upon fucntion entry.
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
bool enableShrinkWrapping(const MachineFunction &MF) const override
Returns true if the target will correctly handle shrink wrapping.
bool canUseRedZone(const MachineFunction &MF) const
Can this function use the red zone for local allocations.
bool isSupportedStackID(TargetStackID::Value ID) const override
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
int getSEHFrameIndexOffset(const MachineFunction &MF, int FI) const
unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const
Funclets only need to account for space for the callee saved registers, as the locals are accounted f...
void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &ObjectsToAllocate) const override
Order the symbols in the local stack frame.
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const override
getFrameIndexReference - Provide a base+offset reference to an FI slot for debug info.
StackOffset resolveFrameOffsetReference(const MachineFunction &MF, int64_t ObjectOffset, bool isFixed, bool isSVE, Register &FrameReg, bool PreferFP, bool ForSimm) const
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI, unsigned &MinCSFrameIndex, unsigned &MaxCSFrameIndex) const override
assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.
StackOffset getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, Register &FrameReg, bool IgnoreSPUpdates) const override
For Win64 AArch64 EH, the offset to the Unwind object is from the SP before the update.
bool isStackIdSafeForLocalArea(unsigned StackId) const override
This method returns whether or not it is safe for an object with the given stack id to be bundled int...
StackOffset resolveFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg, bool PreferFP, bool ForSimm) const
unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override
The parent frame offset (aka dispFrame) is only used on X86_64 to retrieve the parent's frame pointer...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:310
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:573
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:33
Information about stack frame layout on the target.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39