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