ARMMachineFunctionInfo.h revision 288943 
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
24namespace llvm {
25
26/// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
27/// contains private ARM-specific information for each MachineFunction.
28class 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  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.
111  DenseMap<unsigned, unsigned> CPEClones;
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.
124  DenseMap<const MachineBasicBlock*, unsigned> CoalescedWeights;
125
126public:
127  ARMFunctionInfo() :
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 {
216    DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
217    if (I != CPEClones.end())
218      return I->second;
219    else
220      return -1U;
221  }
222
223  DenseMap<const MachineBasicBlock*, unsigned>::iterator getCoalescedWeight(
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
235