LLVM 18.0.0git
ARMMachineFunctionInfo.h
Go to the documentation of this file.
1//===-- ARMMachineFunctionInfo.h - ARM machine function info ----*- 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 file declares ARM-specific per-machine-function information.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_TARGET_ARM_ARMMACHINEFUNCTIONINFO_H
14#define LLVM_LIB_TARGET_ARM_ARMMACHINEFUNCTIONINFO_H
15
16#include "llvm/ADT/DenseMap.h"
21#include <utility>
22
23namespace llvm {
24
25class ARMSubtarget;
26
27/// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
28/// contains private ARM-specific information for each MachineFunction.
30 virtual void anchor();
31
32 /// isThumb - True if this function is compiled under Thumb mode.
33 /// Used to initialized Align, so must precede it.
34 bool isThumb = false;
35
36 /// hasThumb2 - True if the target architecture supports Thumb2. Do not use
37 /// to determine if function is compiled under Thumb mode, for that use
38 /// 'isThumb'.
39 bool hasThumb2 = false;
40
41 /// ArgsRegSaveSize - Size of the register save area for vararg functions or
42 /// those making guaranteed tail calls that need more stack argument space
43 /// than is provided by this functions incoming parameters.
44 ///
45 unsigned ArgRegsSaveSize = 0;
46
47 /// ReturnRegsCount - Number of registers used up in the return.
48 unsigned ReturnRegsCount = 0;
49
50 /// HasStackFrame - True if this function has a stack frame. Set by
51 /// determineCalleeSaves().
52 bool HasStackFrame = false;
53
54 /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by
55 /// emitPrologue.
56 bool RestoreSPFromFP = false;
57
58 /// LRSpilled - True if the LR register has been for spilled for
59 /// any reason, so it's legal to emit an ARM::tBfar (i.e. "bl").
60 bool LRSpilled = false;
61
62 /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
63 /// spill stack offset.
64 unsigned FramePtrSpillOffset = 0;
65
66 /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
67 /// register spills areas. For Mac OS X:
68 ///
69 /// GPR callee-saved (1) : r4, r5, r6, r7, lr
70 /// --------------------------------------------
71 /// GPR callee-saved (2) : r8, r10, r11
72 /// --------------------------------------------
73 /// DPR callee-saved : d8 - d15
74 ///
75 /// Also see AlignedDPRCSRegs below. Not all D-regs need to go in area 3.
76 /// Some may be spilled after the stack has been realigned.
77 unsigned GPRCS1Offset = 0;
78 unsigned GPRCS2Offset = 0;
79 unsigned DPRCSOffset = 0;
80
81 /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
82 /// areas.
83 unsigned FPCXTSaveSize = 0;
84 unsigned FRSaveSize = 0;
85 unsigned GPRCS1Size = 0;
86 unsigned GPRCS2Size = 0;
87 unsigned DPRCSAlignGapSize = 0;
88 unsigned DPRCSSize = 0;
89
90 /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in
91 /// the aligned portion of the stack frame. This is always a contiguous
92 /// sequence of D-registers starting from d8.
93 ///
94 /// We do not keep track of the frame indices used for these registers - they
95 /// behave like any other frame index in the aligned stack frame. These
96 /// registers also aren't included in DPRCSSize above.
97 unsigned NumAlignedDPRCS2Regs = 0;
98
99 unsigned PICLabelUId = 0;
100
101 /// VarArgsFrameIndex - FrameIndex for start of varargs area.
102 int VarArgsFrameIndex = 0;
103
104 /// HasITBlocks - True if IT blocks have been inserted.
105 bool HasITBlocks = false;
106
107 // Security Extensions
108 bool IsCmseNSEntry;
109 bool IsCmseNSCall;
110
111 /// CPEClones - Track constant pool entries clones created by Constant Island
112 /// pass.
114
115 /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
116 /// being passed on the stack
117 unsigned ArgumentStackSize = 0;
118
119 /// ArgumentStackToRestore - amount of bytes on stack consumed that we must
120 /// restore on return.
121 unsigned ArgumentStackToRestore = 0;
122
123 /// CoalescedWeights - mapping of basic blocks to the rolling counter of
124 /// coalesced weights.
126
127 /// True if this function has a subset of CSRs that is handled explicitly via
128 /// copies.
129 bool IsSplitCSR = false;
130
131 /// Globals that have had their storage promoted into the constant pool.
133
134 /// The amount the literal pool has been increasedby due to promoted globals.
135 int PromotedGlobalsIncrease = 0;
136
137 /// True if r0 will be preserved by a call to this function (e.g. C++
138 /// con/destructors).
139 bool PreservesR0 = false;
140
141 /// True if the function should sign its return address.
142 bool SignReturnAddress = false;
143
144 /// True if the fucntion should sign its return address, even if LR is not
145 /// saved.
146 bool SignReturnAddressAll = false;
147
148 /// True if BTI instructions should be placed at potential indirect jump
149 /// destinations.
150 bool BranchTargetEnforcement = false;
151
152public:
153 ARMFunctionInfo() = default;
154
155 explicit ARMFunctionInfo(const Function &F, const ARMSubtarget *STI);
156
160 const override;
161
162 bool isThumbFunction() const { return isThumb; }
163 bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
164 bool isThumb2Function() const { return isThumb && hasThumb2; }
165
166 bool isCmseNSEntryFunction() const { return IsCmseNSEntry; }
167 bool isCmseNSCallFunction() const { return IsCmseNSCall; }
168
169 unsigned getArgRegsSaveSize() const { return ArgRegsSaveSize; }
170 void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
171
172 unsigned getReturnRegsCount() const { return ReturnRegsCount; }
173 void setReturnRegsCount(unsigned s) { ReturnRegsCount = s; }
174
175 bool hasStackFrame() const { return HasStackFrame; }
176 void setHasStackFrame(bool s) { HasStackFrame = s; }
177
178 bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
179 void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
180
181 bool isLRSpilled() const { return LRSpilled; }
182 void setLRIsSpilled(bool s) { LRSpilled = s; }
183
184 unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
185 void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
186
187 unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
188 void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
189
190 unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
191 unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
192 unsigned getDPRCalleeSavedAreaOffset() const { return DPRCSOffset; }
193
194 void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
195 void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
196 void setDPRCalleeSavedAreaOffset(unsigned o) { DPRCSOffset = o; }
197
198 unsigned getFPCXTSaveAreaSize() const { return FPCXTSaveSize; }
199 unsigned getFrameRecordSavedAreaSize() const { return FRSaveSize; }
200 unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
201 unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
202 unsigned getDPRCalleeSavedGapSize() const { return DPRCSAlignGapSize; }
203 unsigned getDPRCalleeSavedAreaSize() const { return DPRCSSize; }
204
205 void setFPCXTSaveAreaSize(unsigned s) { FPCXTSaveSize = s; }
206 void setFrameRecordSavedAreaSize(unsigned s) { FRSaveSize = s; }
207 void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
208 void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
209 void setDPRCalleeSavedGapSize(unsigned s) { DPRCSAlignGapSize = s; }
210 void setDPRCalleeSavedAreaSize(unsigned s) { DPRCSSize = s; }
211
212 unsigned getArgumentStackSize() const { return ArgumentStackSize; }
213 void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
214
215 unsigned getArgumentStackToRestore() const { return ArgumentStackToRestore; }
216 void setArgumentStackToRestore(unsigned v) { ArgumentStackToRestore = v; }
217
218 void initPICLabelUId(unsigned UId) {
219 PICLabelUId = UId;
220 }
221
222 unsigned getNumPICLabels() const {
223 return PICLabelUId;
224 }
225
226 unsigned createPICLabelUId() {
227 return PICLabelUId++;
228 }
229
230 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
231 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
232
233 bool hasITBlocks() const { return HasITBlocks; }
234 void setHasITBlocks(bool h) { HasITBlocks = h; }
235
236 bool isSplitCSR() const { return IsSplitCSR; }
237 void setIsSplitCSR(bool s) { IsSplitCSR = s; }
238
239 void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
240 if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
241 llvm_unreachable("Duplicate entries!");
242 }
243
244 unsigned getOriginalCPIdx(unsigned CloneIdx) const {
246 if (I != CPEClones.end())
247 return I->second;
248 else
249 return -1U;
250 }
251
254 auto It = CoalescedWeights.find(MBB);
255 if (It == CoalescedWeights.end()) {
256 It = CoalescedWeights.insert(std::make_pair(MBB, 0)).first;
257 }
258 return It;
259 }
260
261 /// Indicate to the backend that \c GV has had its storage changed to inside
262 /// a constant pool. This means it no longer needs to be emitted as a
263 /// global variable.
265 PromotedGlobals.insert(GV);
266 }
268 return PromotedGlobals;
269 }
271 return PromotedGlobalsIncrease;
272 }
274 PromotedGlobalsIncrease = Sz;
275 }
276
279
280 void setPreservesR0() { PreservesR0 = true; }
281 bool getPreservesR0() const { return PreservesR0; }
282
284 return shouldSignReturnAddress(LRSpilled);
285 }
286
287 bool shouldSignReturnAddress(bool SpillsLR) const {
288 if (!SignReturnAddress)
289 return false;
290 if (SignReturnAddressAll)
291 return true;
292 return SpillsLR;
293 }
294
295 bool branchTargetEnforcement() const { return BranchTargetEnforcement; }
296};
297
298} // end namespace llvm
299
300#endif // LLVM_LIB_TARGET_ARM_ARMMACHINEFUNCTIONINFO_H
MachineBasicBlock & MBB
This file defines the DenseMap class.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Basic Register Allocator
This file defines the SmallPtrSet class.
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
void setDPRCalleeSavedAreaSize(unsigned s)
void initPICLabelUId(unsigned UId)
unsigned getFPCXTSaveAreaSize() const
unsigned getGPRCalleeSavedArea2Offset() const
unsigned getGPRCalleeSavedArea1Size() const
SmallPtrSet< const GlobalVariable *, 2 > & getGlobalsPromotedToConstantPool()
void setArgumentStackToRestore(unsigned v)
unsigned getDPRCalleeSavedGapSize() const
unsigned getGPRCalleeSavedArea1Offset() const
void setPromotedConstpoolIncrease(int Sz)
void setGPRCalleeSavedArea2Size(unsigned s)
unsigned getDPRCalleeSavedAreaOffset() const
bool shouldSignReturnAddress(bool SpillsLR) const
void setDPRCalleeSavedAreaOffset(unsigned o)
DenseMap< unsigned, unsigned > EHPrologueRemappedRegs
void setFramePtrSpillOffset(unsigned o)
void setArgRegsSaveSize(unsigned s)
unsigned getGPRCalleeSavedArea2Size() const
unsigned getNumAlignedDPRCS2Regs() const
void setGPRCalleeSavedArea1Size(unsigned s)
unsigned getArgumentStackToRestore() const
void setFPCXTSaveAreaSize(unsigned s)
unsigned getDPRCalleeSavedAreaSize() const
unsigned getFramePtrSpillOffset() const
void setReturnRegsCount(unsigned s)
void setVarArgsFrameIndex(int Index)
DenseMap< unsigned, unsigned > EHPrologueOffsetInRegs
unsigned getOriginalCPIdx(unsigned CloneIdx) const
void setFrameRecordSavedAreaSize(unsigned s)
unsigned getNumPICLabels() const
unsigned getArgRegsSaveSize() const
void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx)
void markGlobalAsPromotedToConstantPool(const GlobalVariable *GV)
Indicate to the backend that GV has had its storage changed to inside a constant pool.
void setGPRCalleeSavedArea2Offset(unsigned o)
unsigned getFrameRecordSavedAreaSize() const
DenseMap< constMachineBasicBlock *, unsigned >::iterator getCoalescedWeight(MachineBasicBlock *MBB)
void setGPRCalleeSavedArea1Offset(unsigned o)
void setDPRCalleeSavedGapSize(unsigned s)
void setArgumentStackSize(unsigned size)
MachineFunctionInfo * clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, const DenseMap< MachineBasicBlock *, MachineBasicBlock * > &Src2DstMBB) const override
Make a functionally equivalent copy of this MachineFunctionInfo in MF.
void setNumAlignedDPRCS2Regs(unsigned n)
unsigned getArgumentStackSize() const
unsigned getReturnRegsCount() const
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
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:366
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:451
#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
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1685
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...