ARMMachineFunctionInfo.h revision 212904 
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/CodeGen/MachineFunction.h"
19#include "llvm/Target/TargetRegisterInfo.h"
20#include "llvm/Target/TargetMachine.h"
21#include "llvm/ADT/BitVector.h"
22
23namespace llvm {
24
25/// ARMFunctionInfo - This class is derived from MachineFunction private
26/// ARM target-specific information for each MachineFunction.
27class ARMFunctionInfo : public MachineFunctionInfo {
28
29  /// isThumb - True if this function is compiled under Thumb mode.
30  /// Used to initialized Align, so must precede it.
31  bool isThumb;
32
33  /// hasThumb2 - True if the target architecture supports Thumb2. Do not use
34  /// to determine if function is compiled under Thumb mode, for that use
35  /// 'isThumb'.
36  bool hasThumb2;
37
38  /// VarArgsRegSaveSize - Size of the register save area for vararg functions.
39  ///
40  unsigned VarArgsRegSaveSize;
41
42  /// HasStackFrame - True if this function has a stack frame. Set by
43  /// processFunctionBeforeCalleeSavedScan().
44  bool HasStackFrame;
45
46  /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by
47  /// emitPrologue.
48  bool RestoreSPFromFP;
49
50  /// LRSpilledForFarJump - True if the LR register has been for spilled to
51  /// enable far jump.
52  bool LRSpilledForFarJump;
53
54  /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
55  /// spill stack offset.
56  unsigned FramePtrSpillOffset;
57
58  /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
59  /// register spills areas. For Mac OS X:
60  ///
61  /// GPR callee-saved (1) : r4, r5, r6, r7, lr
62  /// --------------------------------------------
63  /// GPR callee-saved (2) : r8, r10, r11
64  /// --------------------------------------------
65  /// DPR callee-saved : d8 - d15
66  unsigned GPRCS1Offset;
67  unsigned GPRCS2Offset;
68  unsigned DPRCSOffset;
69
70  /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
71  /// areas.
72  unsigned GPRCS1Size;
73  unsigned GPRCS2Size;
74  unsigned DPRCSSize;
75
76  /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices
77  /// which belong to these spill areas.
78  BitVector GPRCS1Frames;
79  BitVector GPRCS2Frames;
80  BitVector DPRCSFrames;
81
82  /// SpilledCSRegs - A BitVector mask of all spilled callee-saved registers.
83  ///
84  BitVector SpilledCSRegs;
85
86  /// JumpTableUId - Unique id for jumptables.
87  ///
88  unsigned JumpTableUId;
89
90  unsigned ConstPoolEntryUId;
91
92  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
93  int VarArgsFrameIndex;
94
95  /// HasITBlocks - True if IT blocks have been inserted.
96  bool HasITBlocks;
97
98public:
99  ARMFunctionInfo() :
100    isThumb(false),
101    hasThumb2(false),
102    VarArgsRegSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false),
103    LRSpilledForFarJump(false),
104    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
105    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
106    GPRCS1Frames(0), GPRCS2Frames(0), DPRCSFrames(0),
107    JumpTableUId(0), ConstPoolEntryUId(0), VarArgsFrameIndex(0),
108    HasITBlocks(false) {}
109
110  explicit ARMFunctionInfo(MachineFunction &MF) :
111    isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()),
112    hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()),
113    VarArgsRegSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false),
114    LRSpilledForFarJump(false),
115    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
116    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
117    GPRCS1Frames(32), GPRCS2Frames(32), DPRCSFrames(32),
118    SpilledCSRegs(MF.getTarget().getRegisterInfo()->getNumRegs()),
119    JumpTableUId(0), ConstPoolEntryUId(0), VarArgsFrameIndex(0),
120    HasITBlocks(false) {}
121
122  bool isThumbFunction() const { return isThumb; }
123  bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
124  bool isThumb2Function() const { return isThumb && hasThumb2; }
125
126  unsigned getVarArgsRegSaveSize() const { return VarArgsRegSaveSize; }
127  void setVarArgsRegSaveSize(unsigned s) { VarArgsRegSaveSize = s; }
128
129  bool hasStackFrame() const { return HasStackFrame; }
130  void setHasStackFrame(bool s) { HasStackFrame = s; }
131
132  bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
133  void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
134
135  bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
136  void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
137
138  unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
139  void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
140
141  unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
142  unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
143  unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
144
145  void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
146  void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
147  void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
148
149  unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
150  unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
151  unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
152
153  void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
154  void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
155  void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
156
157  bool isGPRCalleeSavedArea1Frame(int fi) const {
158    if (fi < 0 || fi >= (int)GPRCS1Frames.size())
159      return false;
160    return GPRCS1Frames[fi];
161  }
162  bool isGPRCalleeSavedArea2Frame(int fi) const {
163    if (fi < 0 || fi >= (int)GPRCS2Frames.size())
164      return false;
165    return GPRCS2Frames[fi];
166  }
167  bool isDPRCalleeSavedAreaFrame(int fi) const {
168    if (fi < 0 || fi >= (int)DPRCSFrames.size())
169      return false;
170    return DPRCSFrames[fi];
171  }
172
173  void addGPRCalleeSavedArea1Frame(int fi) {
174    if (fi >= 0) {
175      int Size = GPRCS1Frames.size();
176      if (fi >= Size) {
177        Size *= 2;
178        if (fi >= Size)
179          Size = fi+1;
180        GPRCS1Frames.resize(Size);
181      }
182      GPRCS1Frames[fi] = true;
183    }
184  }
185  void addGPRCalleeSavedArea2Frame(int fi) {
186    if (fi >= 0) {
187      int Size = GPRCS2Frames.size();
188      if (fi >= Size) {
189        Size *= 2;
190        if (fi >= Size)
191          Size = fi+1;
192        GPRCS2Frames.resize(Size);
193      }
194      GPRCS2Frames[fi] = true;
195    }
196  }
197  void addDPRCalleeSavedAreaFrame(int fi) {
198    if (fi >= 0) {
199      int Size = DPRCSFrames.size();
200      if (fi >= Size) {
201        Size *= 2;
202        if (fi >= Size)
203          Size = fi+1;
204        DPRCSFrames.resize(Size);
205      }
206      DPRCSFrames[fi] = true;
207    }
208  }
209
210  void setCSRegisterIsSpilled(unsigned Reg) {
211    SpilledCSRegs.set(Reg);
212  }
213
214  bool isCSRegisterSpilled(unsigned Reg) const {
215    return SpilledCSRegs[Reg];
216  }
217
218  const BitVector &getSpilledCSRegisters() const {
219    return SpilledCSRegs;
220  }
221
222  unsigned createJumpTableUId() {
223    return JumpTableUId++;
224  }
225
226  unsigned getNumJumpTables() const {
227    return JumpTableUId;
228  }
229
230  void initConstPoolEntryUId(unsigned UId) {
231    ConstPoolEntryUId = UId;
232  }
233
234  unsigned getNumConstPoolEntries() const {
235    return ConstPoolEntryUId;
236  }
237
238  unsigned createConstPoolEntryUId() {
239    return ConstPoolEntryUId++;
240  }
241
242  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
243  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
244
245  bool hasITBlocks() const { return HasITBlocks; }
246  void setHasITBlocks(bool h) { HasITBlocks = h; }
247};
248} // End llvm namespace
249
250#endif // ARMMACHINEFUNCTIONINFO_H
251