LLVM  3.7.0
ARMMachineFunctionInfo.h
Go to the documentation of this file.
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"
23 
24 namespace llvm {
25 
26 /// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
27 /// contains private ARM-specific information for each MachineFunction.
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  unsigned PICLabelUId;
102 
103  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
104  int VarArgsFrameIndex;
105 
106  /// HasITBlocks - True if IT blocks have been inserted.
107  bool HasITBlocks;
108 
109  /// CPEClones - Track constant pool entries clones created by Constant Island
110  /// pass.
112 
113  /// GlobalBaseReg - keeps track of the virtual register initialized for
114  /// use as the global base register. This is used for PIC in some PIC
115  /// relocation models.
116  unsigned GlobalBaseReg;
117 
118  /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
119  /// being passed on the stack
120  unsigned ArgumentStackSize;
121 
122  /// CoalescedWeights - mapping of basic blocks to the rolling counter of
123  /// coalesced weights.
125 
126 public:
128  isThumb(false),
129  hasThumb2(false),
130  ArgRegsSaveSize(0), ReturnRegsCount(0), HasStackFrame(false),
131  RestoreSPFromFP(false),
132  LRSpilledForFarJump(false),
133  FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
134  GPRCS1Size(0), GPRCS2Size(0), DPRCSAlignGapSize(0), DPRCSSize(0),
135  NumAlignedDPRCS2Regs(0), PICLabelUId(0),
136  VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
137 
138  explicit ARMFunctionInfo(MachineFunction &MF);
139 
140  bool isThumbFunction() const { return isThumb; }
141  bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
142  bool isThumb2Function() const { return isThumb && hasThumb2; }
143 
144  unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; }
145  void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; }
146 
147  unsigned getArgRegsSaveSize() const { return ArgRegsSaveSize; }
148  void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
149 
150  unsigned getReturnRegsCount() const { return ReturnRegsCount; }
151  void setReturnRegsCount(unsigned s) { ReturnRegsCount = s; }
152 
153  bool hasStackFrame() const { return HasStackFrame; }
154  void setHasStackFrame(bool s) { HasStackFrame = s; }
155 
156  bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
157  void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
158 
159  bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
160  void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
161 
162  unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
163  void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
164 
165  unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
166  void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
167 
168  unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
169  unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
170  unsigned getDPRCalleeSavedAreaOffset() const { return DPRCSOffset; }
171 
172  void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
173  void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
174  void setDPRCalleeSavedAreaOffset(unsigned o) { DPRCSOffset = o; }
175 
176  unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
177  unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
178  unsigned getDPRCalleeSavedGapSize() const { return DPRCSAlignGapSize; }
179  unsigned getDPRCalleeSavedAreaSize() const { return DPRCSSize; }
180 
181  void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
182  void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
183  void setDPRCalleeSavedGapSize(unsigned s) { DPRCSAlignGapSize = s; }
184  void setDPRCalleeSavedAreaSize(unsigned s) { DPRCSSize = s; }
185 
186  unsigned getArgumentStackSize() const { return ArgumentStackSize; }
187  void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
188 
189  void initPICLabelUId(unsigned UId) {
190  PICLabelUId = UId;
191  }
192 
193  unsigned getNumPICLabels() const {
194  return PICLabelUId;
195  }
196 
197  unsigned createPICLabelUId() {
198  return PICLabelUId++;
199  }
200 
201  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
202  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
203 
204  bool hasITBlocks() const { return HasITBlocks; }
205  void setHasITBlocks(bool h) { HasITBlocks = h; }
206 
207  unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
208  void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
209 
210  void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
211  if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
212  llvm_unreachable("Duplicate entries!");
213  }
214 
215  unsigned getOriginalCPIdx(unsigned CloneIdx) const {
217  if (I != CPEClones.end())
218  return I->second;
219  else
220  return -1U;
221  }
222 
224  MachineBasicBlock* MBB) {
225  auto It = CoalescedWeights.find(MBB);
226  if (It == CoalescedWeights.end()) {
227  It = CoalescedWeights.insert(std::make_pair(MBB, 0)).first;
228  }
229  return It;
230  }
231 };
232 } // End llvm namespace
233 
234 #endif
void setGPRCalleeSavedArea2Offset(unsigned o)
unsigned getDPRCalleeSavedAreaSize() const
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:169
unsigned getNumAlignedDPRCS2Regs() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
unsigned getArgRegsSaveSize() const
Reg
All possible values of the reg field in the ModR/M byte.
void setDPRCalleeSavedAreaOffset(unsigned o)
#define false
Definition: ConvertUTF.c:65
void setFramePtrSpillOffset(unsigned o)
unsigned getArgumentStackSize() const
void setDPRCalleeSavedGapSize(unsigned s)
unsigned getReturnRegsCount() const
unsigned getStoredByValParamsPadding() const
void setReturnRegsCount(unsigned s)
unsigned getGPRCalleeSavedArea2Offset() const
unsigned getNumPICLabels() const
unsigned getGlobalBaseReg() const
unsigned getDPRCalleeSavedAreaOffset() const
unsigned getFramePtrSpillOffset() const
void setGPRCalleeSavedArea2Size(unsigned s)
void initPICLabelUId(unsigned UId)
void setGPRCalleeSavedArea1Size(unsigned s)
void setNumAlignedDPRCS2Regs(unsigned n)
unsigned getGPRCalleeSavedArea1Offset() const
void setArgumentStackSize(unsigned size)
void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx)
void setVarArgsFrameIndex(int Index)
void setGPRCalleeSavedArea1Offset(unsigned o)
void setStoredByValParamsPadding(unsigned p)
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
void setArgRegsSaveSize(unsigned s)
#define I(x, y, z)
Definition: MD5.cpp:54
iterator end()
Definition: DenseMap.h:68
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
unsigned getDPRCalleeSavedGapSize() const
void size_t size
void setDPRCalleeSavedAreaSize(unsigned s)
unsigned getGPRCalleeSavedArea1Size() const
unsigned getGPRCalleeSavedArea2Size() const
unsigned getOriginalCPIdx(unsigned CloneIdx) const
void setGlobalBaseReg(unsigned Reg)
DenseMap< const MachineBasicBlock *, unsigned >::iterator getCoalescedWeight(MachineBasicBlock *MBB)