ARMMachineFunctionInfo.h revision 203954 
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  /// LRSpilledForFarJump - True if the LR register has been for spilled to
47  /// enable far jump.
48  bool LRSpilledForFarJump;
49
50  /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
51  /// spill stack offset.
52  unsigned FramePtrSpillOffset;
53
54  /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
55  /// register spills areas. For Mac OS X:
56  ///
57  /// GPR callee-saved (1) : r4, r5, r6, r7, lr
58  /// --------------------------------------------
59  /// GPR callee-saved (2) : r8, r10, r11
60  /// --------------------------------------------
61  /// DPR callee-saved : d8 - d15
62  unsigned GPRCS1Offset;
63  unsigned GPRCS2Offset;
64  unsigned DPRCSOffset;
65
66  /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
67  /// areas.
68  unsigned GPRCS1Size;
69  unsigned GPRCS2Size;
70  unsigned DPRCSSize;
71
72  /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices
73  /// which belong to these spill areas.
74  BitVector GPRCS1Frames;
75  BitVector GPRCS2Frames;
76  BitVector DPRCSFrames;
77
78  /// SpilledCSRegs - A BitVector mask of all spilled callee-saved registers.
79  ///
80  BitVector SpilledCSRegs;
81
82  /// JumpTableUId - Unique id for jumptables.
83  ///
84  unsigned JumpTableUId;
85
86  unsigned ConstPoolEntryUId;
87
88public:
89  ARMFunctionInfo() :
90    isThumb(false),
91    hasThumb2(false),
92    VarArgsRegSaveSize(0), HasStackFrame(false),
93    LRSpilledForFarJump(false),
94    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
95    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
96    GPRCS1Frames(0), GPRCS2Frames(0), DPRCSFrames(0),
97    JumpTableUId(0), ConstPoolEntryUId(0) {}
98
99  explicit ARMFunctionInfo(MachineFunction &MF) :
100    isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()),
101    hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()),
102    VarArgsRegSaveSize(0), HasStackFrame(false),
103    LRSpilledForFarJump(false),
104    FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
105    GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
106    GPRCS1Frames(32), GPRCS2Frames(32), DPRCSFrames(32),
107    SpilledCSRegs(MF.getTarget().getRegisterInfo()->getNumRegs()),
108    JumpTableUId(0), ConstPoolEntryUId(0) {}
109
110  bool isThumbFunction() const { return isThumb; }
111  bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
112  bool isThumb2Function() const { return isThumb && hasThumb2; }
113
114  unsigned getVarArgsRegSaveSize() const { return VarArgsRegSaveSize; }
115  void setVarArgsRegSaveSize(unsigned s) { VarArgsRegSaveSize = s; }
116
117  bool hasStackFrame() const { return HasStackFrame; }
118  void setHasStackFrame(bool s) { HasStackFrame = s; }
119
120  bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
121  void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
122
123  unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
124  void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
125
126  unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
127  unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
128  unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
129
130  void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
131  void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
132  void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
133
134  unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
135  unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
136  unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
137
138  void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
139  void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
140  void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
141
142  bool isGPRCalleeSavedArea1Frame(int fi) const {
143    if (fi < 0 || fi >= (int)GPRCS1Frames.size())
144      return false;
145    return GPRCS1Frames[fi];
146  }
147  bool isGPRCalleeSavedArea2Frame(int fi) const {
148    if (fi < 0 || fi >= (int)GPRCS2Frames.size())
149      return false;
150    return GPRCS2Frames[fi];
151  }
152  bool isDPRCalleeSavedAreaFrame(int fi) const {
153    if (fi < 0 || fi >= (int)DPRCSFrames.size())
154      return false;
155    return DPRCSFrames[fi];
156  }
157
158  void addGPRCalleeSavedArea1Frame(int fi) {
159    if (fi >= 0) {
160      int Size = GPRCS1Frames.size();
161      if (fi >= Size) {
162        Size *= 2;
163        if (fi >= Size)
164          Size = fi+1;
165        GPRCS1Frames.resize(Size);
166      }
167      GPRCS1Frames[fi] = true;
168    }
169  }
170  void addGPRCalleeSavedArea2Frame(int fi) {
171    if (fi >= 0) {
172      int Size = GPRCS2Frames.size();
173      if (fi >= Size) {
174        Size *= 2;
175        if (fi >= Size)
176          Size = fi+1;
177        GPRCS2Frames.resize(Size);
178      }
179      GPRCS2Frames[fi] = true;
180    }
181  }
182  void addDPRCalleeSavedAreaFrame(int fi) {
183    if (fi >= 0) {
184      int Size = DPRCSFrames.size();
185      if (fi >= Size) {
186        Size *= 2;
187        if (fi >= Size)
188          Size = fi+1;
189        DPRCSFrames.resize(Size);
190      }
191      DPRCSFrames[fi] = true;
192    }
193  }
194
195  void setCSRegisterIsSpilled(unsigned Reg) {
196    SpilledCSRegs.set(Reg);
197  }
198
199  bool isCSRegisterSpilled(unsigned Reg) const {
200    return SpilledCSRegs[Reg];
201  }
202
203  const BitVector &getSpilledCSRegisters() const {
204    return SpilledCSRegs;
205  }
206
207  unsigned createJumpTableUId() {
208    return JumpTableUId++;
209  }
210
211  unsigned getNumJumpTables() const {
212    return JumpTableUId;
213  }
214
215  void initConstPoolEntryUId(unsigned UId) {
216    ConstPoolEntryUId = UId;
217  }
218
219  unsigned getNumConstPoolEntries() const {
220    return ConstPoolEntryUId;
221  }
222
223  unsigned createConstPoolEntryUId() {
224    return ConstPoolEntryUId++;
225  }
226};
227} // End llvm namespace
228
229#endif // ARMMACHINEFUNCTIONINFO_H
230