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 ARMMACHINEFUNCTIONINFO_H
15#define ARMMACHINEFUNCTIONINFO_H
16
17#include "ARMSubtarget.h"
18#include "llvm/ADT/BitVector.h"
19#include "llvm/CodeGen/MachineFunction.h"
20#include "llvm/Target/TargetMachine.h"
21#include "llvm/Target/TargetRegisterInfo.h"
22
23namespace llvm {
24
25/// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
26/// contains private ARM-specific information for each MachineFunction.
27class 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;
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;
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;
45
46  /// VarArgsRegSaveSize - Size of the register save area for vararg functions.
47  ///
48  unsigned ArgRegsSaveSize;
49
50  /// HasStackFrame - True if this function has a stack frame. Set by
51  /// processFunctionBeforeCalleeSavedScan().
52  bool HasStackFrame;
53
54  /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by
55  /// emitPrologue.
56  bool RestoreSPFromFP;
57
58  /// LRSpilledForFarJump - True if the LR register has been for spilled to
59  /// enable far jump.
60  bool LRSpilledForFarJump;
61
62  /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
63  /// spill stack offset.
64  unsigned FramePtrSpillOffset;
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;
78  unsigned GPRCS2Offset;
79  unsigned DPRCSOffset;
80
81  /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
82  /// areas.
83  unsigned GPRCS1Size;
84  unsigned GPRCS2Size;
85  unsigned DPRCSSize;
86
87  /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in
88  /// the aligned portion of the stack frame.  This is always a contiguous
89  /// sequence of D-registers starting from d8.
90  ///
91  /// We do not keep track of the frame indices used for these registers - they
92  /// behave like any other frame index in the aligned stack frame.  These
93  /// registers also aren't included in DPRCSSize above.
94  unsigned NumAlignedDPRCS2Regs;
95
96  /// JumpTableUId - Unique id for jumptables.
97  ///
98  unsigned JumpTableUId;
99
100  unsigned PICLabelUId;
101
102  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
103  int VarArgsFrameIndex;
104
105  /// HasITBlocks - True if IT blocks have been inserted.
106  bool HasITBlocks;
107
108  /// CPEClones - Track constant pool entries clones created by Constant Island
109  /// pass.
110  DenseMap<unsigned, unsigned> CPEClones;
111
112  /// GlobalBaseReg - keeps track of the virtual register initialized for
113  /// use as the global base register. This is used for PIC in some PIC
114  /// relocation models.
115  unsigned GlobalBaseReg;
116
117  /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
118  /// being passed on the stack
119  unsigned ArgumentStackSize;
120
121public:
122  ARMFunctionInfo() :
123    isThumb(false),
124    hasThumb2(false),
125    ArgRegsSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false),
126    LRSpilledForFarJump(false),
127    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
128    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
129    NumAlignedDPRCS2Regs(0),
130    JumpTableUId(0), PICLabelUId(0),
131    VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
132
133  explicit ARMFunctionInfo(MachineFunction &MF);
134
135  bool isThumbFunction() const { return isThumb; }
136  bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
137  bool isThumb2Function() const { return isThumb && hasThumb2; }
138
139  unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; }
140  void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; }
141
142  unsigned getArgRegsSaveSize(unsigned Align = 0) const {
143    if (!Align)
144      return ArgRegsSaveSize;
145    return (ArgRegsSaveSize + Align - 1) & ~(Align - 1);
146  }
147  void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
148
149  bool hasStackFrame() const { return HasStackFrame; }
150  void setHasStackFrame(bool s) { HasStackFrame = s; }
151
152  bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
153  void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
154
155  bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
156  void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
157
158  unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
159  void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
160
161  unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
162  void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
163
164  unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
165  unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
166  unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
167
168  void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
169  void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
170  void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
171
172  unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
173  unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
174  unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
175
176  void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
177  void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
178  void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
179
180  unsigned getArgumentStackSize() const { return ArgumentStackSize; }
181  void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
182
183  unsigned createJumpTableUId() {
184    return JumpTableUId++;
185  }
186
187  unsigned getNumJumpTables() const {
188    return JumpTableUId;
189  }
190
191  void initPICLabelUId(unsigned UId) {
192    PICLabelUId = UId;
193  }
194
195  unsigned getNumPICLabels() const {
196    return PICLabelUId;
197  }
198
199  unsigned createPICLabelUId() {
200    return PICLabelUId++;
201  }
202
203  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
204  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
205
206  bool hasITBlocks() const { return HasITBlocks; }
207  void setHasITBlocks(bool h) { HasITBlocks = h; }
208
209  unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
210  void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
211
212  void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
213    if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
214      llvm_unreachable("Duplicate entries!");
215  }
216
217  unsigned getOriginalCPIdx(unsigned CloneIdx) const {
218    DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
219    if (I != CPEClones.end())
220      return I->second;
221    else
222      return -1U;
223  }
224};
225} // End llvm namespace
226
227#endif // ARMMACHINEFUNCTIONINFO_H
228