1 //===-- ARMMachineFuctionInfo.h - ARM machine function info -----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares ARM-specific per-machine-function information.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_ARM_ARMMACHINEFUNCTIONINFO_H
15 #define LLVM_LIB_TARGET_ARM_ARMMACHINEFUNCTIONINFO_H
16 
17 #include "ARMSubtarget.h"
18 #include "llvm/ADT/BitVector.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/CodeGen/MachineFunction.h"
21 #include "llvm/Target/TargetMachine.h"
22 #include "llvm/Target/TargetRegisterInfo.h"
23 
24 namespace llvm {
25 
26 /// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
27 /// contains private ARM-specific information for each MachineFunction.
28 class ARMFunctionInfo : public MachineFunctionInfo {
29   virtual void anchor();
30 
31   /// isThumb - True if this function is compiled under Thumb mode.
32   /// Used to initialized Align, so must precede it.
33   bool isThumb;
34 
35   /// hasThumb2 - True if the target architecture supports Thumb2. Do not use
36   /// to determine if function is compiled under Thumb mode, for that use
37   /// 'isThumb'.
38   bool hasThumb2;
39 
40   /// StByValParamsPadding - For parameter that is split between
41   /// GPRs and memory; while recovering GPRs part, when
42   /// StackAlignment > 4, and GPRs-part-size mod StackAlignment != 0,
43   /// we need to insert gap before parameter start address. It allows to
44   /// "attach" GPR-part to the part that was passed via stack.
45   unsigned StByValParamsPadding;
46 
47   /// VarArgsRegSaveSize - Size of the register save area for vararg functions.
48   ///
49   unsigned ArgRegsSaveSize;
50 
51   /// ReturnRegsCount - Number of registers used up in the return.
52   unsigned ReturnRegsCount;
53 
54   /// HasStackFrame - True if this function has a stack frame. Set by
55   /// processFunctionBeforeCalleeSavedScan().
56   bool HasStackFrame;
57 
58   /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by
59   /// emitPrologue.
60   bool RestoreSPFromFP;
61 
62   /// LRSpilledForFarJump - True if the LR register has been for spilled to
63   /// enable far jump.
64   bool LRSpilledForFarJump;
65 
66   /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
67   /// spill stack offset.
68   unsigned FramePtrSpillOffset;
69 
70   /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
71   /// register spills areas. For Mac OS X:
72   ///
73   /// GPR callee-saved (1) : r4, r5, r6, r7, lr
74   /// --------------------------------------------
75   /// GPR callee-saved (2) : r8, r10, r11
76   /// --------------------------------------------
77   /// DPR callee-saved : d8 - d15
78   ///
79   /// Also see AlignedDPRCSRegs below. Not all D-regs need to go in area 3.
80   /// Some may be spilled after the stack has been realigned.
81   unsigned GPRCS1Offset;
82   unsigned GPRCS2Offset;
83   unsigned DPRCSOffset;
84 
85   /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
86   /// areas.
87   unsigned GPRCS1Size;
88   unsigned GPRCS2Size;
89   unsigned DPRCSAlignGapSize;
90   unsigned DPRCSSize;
91 
92   /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in
93   /// the aligned portion of the stack frame.  This is always a contiguous
94   /// sequence of D-registers starting from d8.
95   ///
96   /// We do not keep track of the frame indices used for these registers - they
97   /// behave like any other frame index in the aligned stack frame.  These
98   /// registers also aren't included in DPRCSSize above.
99   unsigned NumAlignedDPRCS2Regs;
100 
101   /// JumpTableUId - Unique id for jumptables.
102   ///
103   unsigned JumpTableUId;
104 
105   unsigned PICLabelUId;
106 
107   /// VarArgsFrameIndex - FrameIndex for start of varargs area.
108   int VarArgsFrameIndex;
109 
110   /// HasITBlocks - True if IT blocks have been inserted.
111   bool HasITBlocks;
112 
113   /// CPEClones - Track constant pool entries clones created by Constant Island
114   /// pass.
115   DenseMap<unsigned, unsigned> CPEClones;
116 
117   /// GlobalBaseReg - keeps track of the virtual register initialized for
118   /// use as the global base register. This is used for PIC in some PIC
119   /// relocation models.
120   unsigned GlobalBaseReg;
121 
122   /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
123   /// being passed on the stack
124   unsigned ArgumentStackSize;
125 
126   /// CoalescedWeights - mapping of basic blocks to the rolling counter of
127   /// coalesced weights.
128   DenseMap<const MachineBasicBlock*, unsigned> CoalescedWeights;
129 
130 public:
ARMFunctionInfo()131   ARMFunctionInfo() :
132     isThumb(false),
133     hasThumb2(false),
134     ArgRegsSaveSize(0), ReturnRegsCount(0), HasStackFrame(false),
135     RestoreSPFromFP(false),
136     LRSpilledForFarJump(false),
137     FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
138     GPRCS1Size(0), GPRCS2Size(0), DPRCSAlignGapSize(0), DPRCSSize(0),
139     NumAlignedDPRCS2Regs(0),
140     JumpTableUId(0), PICLabelUId(0),
141     VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
142 
143   explicit ARMFunctionInfo(MachineFunction &MF);
144 
isThumbFunction()145   bool isThumbFunction() const { return isThumb; }
isThumb1OnlyFunction()146   bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
isThumb2Function()147   bool isThumb2Function() const { return isThumb && hasThumb2; }
148 
getStoredByValParamsPadding()149   unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; }
setStoredByValParamsPadding(unsigned p)150   void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; }
151 
getArgRegsSaveSize()152   unsigned getArgRegsSaveSize() const { return ArgRegsSaveSize; }
setArgRegsSaveSize(unsigned s)153   void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
154 
getReturnRegsCount()155   unsigned getReturnRegsCount() const { return ReturnRegsCount; }
setReturnRegsCount(unsigned s)156   void setReturnRegsCount(unsigned s) { ReturnRegsCount = s; }
157 
hasStackFrame()158   bool hasStackFrame() const { return HasStackFrame; }
setHasStackFrame(bool s)159   void setHasStackFrame(bool s) { HasStackFrame = s; }
160 
shouldRestoreSPFromFP()161   bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
setShouldRestoreSPFromFP(bool s)162   void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
163 
isLRSpilledForFarJump()164   bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
setLRIsSpilledForFarJump(bool s)165   void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
166 
getFramePtrSpillOffset()167   unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
setFramePtrSpillOffset(unsigned o)168   void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
169 
getNumAlignedDPRCS2Regs()170   unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
setNumAlignedDPRCS2Regs(unsigned n)171   void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
172 
getGPRCalleeSavedArea1Offset()173   unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
getGPRCalleeSavedArea2Offset()174   unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
getDPRCalleeSavedAreaOffset()175   unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
176 
setGPRCalleeSavedArea1Offset(unsigned o)177   void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
setGPRCalleeSavedArea2Offset(unsigned o)178   void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
setDPRCalleeSavedAreaOffset(unsigned o)179   void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
180 
getGPRCalleeSavedArea1Size()181   unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
getGPRCalleeSavedArea2Size()182   unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
getDPRCalleeSavedGapSize()183   unsigned getDPRCalleeSavedGapSize() const   { return DPRCSAlignGapSize; }
getDPRCalleeSavedAreaSize()184   unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
185 
setGPRCalleeSavedArea1Size(unsigned s)186   void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
setGPRCalleeSavedArea2Size(unsigned s)187   void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
setDPRCalleeSavedGapSize(unsigned s)188   void setDPRCalleeSavedGapSize(unsigned s)   { DPRCSAlignGapSize = s; }
setDPRCalleeSavedAreaSize(unsigned s)189   void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
190 
getArgumentStackSize()191   unsigned getArgumentStackSize() const { return ArgumentStackSize; }
setArgumentStackSize(unsigned size)192   void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
193 
createJumpTableUId()194   unsigned createJumpTableUId() {
195     return JumpTableUId++;
196   }
197 
getNumJumpTables()198   unsigned getNumJumpTables() const {
199     return JumpTableUId;
200   }
201 
initPICLabelUId(unsigned UId)202   void initPICLabelUId(unsigned UId) {
203     PICLabelUId = UId;
204   }
205 
getNumPICLabels()206   unsigned getNumPICLabels() const {
207     return PICLabelUId;
208   }
209 
createPICLabelUId()210   unsigned createPICLabelUId() {
211     return PICLabelUId++;
212   }
213 
getVarArgsFrameIndex()214   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
setVarArgsFrameIndex(int Index)215   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
216 
hasITBlocks()217   bool hasITBlocks() const { return HasITBlocks; }
setHasITBlocks(bool h)218   void setHasITBlocks(bool h) { HasITBlocks = h; }
219 
getGlobalBaseReg()220   unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
setGlobalBaseReg(unsigned Reg)221   void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
222 
recordCPEClone(unsigned CPIdx,unsigned CPCloneIdx)223   void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
224     if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
225       llvm_unreachable("Duplicate entries!");
226   }
227 
getOriginalCPIdx(unsigned CloneIdx)228   unsigned getOriginalCPIdx(unsigned CloneIdx) const {
229     DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
230     if (I != CPEClones.end())
231       return I->second;
232     else
233       return -1U;
234   }
235 
getCoalescedWeight(MachineBasicBlock * MBB)236   DenseMap<const MachineBasicBlock*, unsigned>::iterator getCoalescedWeight(
237                                                   MachineBasicBlock* MBB) {
238     auto It = CoalescedWeights.find(MBB);
239     if (It == CoalescedWeights.end()) {
240       It = CoalescedWeights.insert(std::make_pair(MBB, 0)).first;
241     }
242     return It;
243   }
244 };
245 } // End llvm namespace
246 
247 #endif
248