LLVM  3.7.0
PPCMachineFunctionInfo.h
Go to the documentation of this file.
1 //===-- PPCMachineFunctionInfo.h - Private data used for PowerPC --*- 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 the PowerPC specific subclass of MachineFunctionInfo.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H
15 #define LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H
16 
18 
19 namespace llvm {
20 
21 /// PPCFunctionInfo - This class is derived from MachineFunction private
22 /// PowerPC target-specific information for each MachineFunction.
24  virtual void anchor();
25 
26  /// FramePointerSaveIndex - Frame index of where the old frame pointer is
27  /// stored. Also used as an anchor for instructions that need to be altered
28  /// when using frame pointers (dyna_add, dyna_sub.)
29  int FramePointerSaveIndex;
30 
31  /// ReturnAddrSaveIndex - Frame index of where the return address is stored.
32  ///
33  int ReturnAddrSaveIndex;
34 
35  /// Frame index where the old base pointer is stored.
36  int BasePointerSaveIndex;
37 
38  /// Frame index where the old PIC base pointer is stored.
39  int PICBasePointerSaveIndex;
40 
41  /// MustSaveLR - Indicates whether LR is defined (or clobbered) in the current
42  /// function. This is only valid after the initial scan of the function by
43  /// PEI.
44  bool MustSaveLR;
45 
46  /// Does this function have any stack spills.
47  bool HasSpills;
48 
49  /// Does this function spill using instructions with only r+r (not r+i)
50  /// forms.
51  bool HasNonRISpills;
52 
53  /// SpillsCR - Indicates whether CR is spilled in the current function.
54  bool SpillsCR;
55 
56  /// Indicates whether VRSAVE is spilled in the current function.
57  bool SpillsVRSAVE;
58 
59  /// LRStoreRequired - The bool indicates whether there is some explicit use of
60  /// the LR/LR8 stack slot that is not obvious from scanning the code. This
61  /// requires that the code generator produce a store of LR to the stack on
62  /// entry, even though LR may otherwise apparently not be used.
63  bool LRStoreRequired;
64 
65  /// This function makes use of the PPC64 ELF TOC base pointer (register r2).
66  bool UsesTOCBasePtr;
67 
68  /// MinReservedArea - This is the frame size that is at least reserved in a
69  /// potential caller (parameter+linkage area).
70  unsigned MinReservedArea;
71 
72  /// TailCallSPDelta - Stack pointer delta used when tail calling. Maximum
73  /// amount the stack pointer is adjusted to make the frame bigger for tail
74  /// calls. Used for creating an area before the register spill area.
75  int TailCallSPDelta;
76 
77  /// HasFastCall - Does this function contain a fast call. Used to determine
78  /// how the caller's stack pointer should be calculated (epilog/dynamicalloc).
79  bool HasFastCall;
80 
81  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
82  int VarArgsFrameIndex;
83  /// VarArgsStackOffset - StackOffset for start of stack
84  /// arguments.
85  int VarArgsStackOffset;
86  /// VarArgsNumGPR - Index of the first unused integer
87  /// register for parameter passing.
88  unsigned VarArgsNumGPR;
89  /// VarArgsNumFPR - Index of the first unused double
90  /// register for parameter passing.
91  unsigned VarArgsNumFPR;
92 
93  /// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4.
94  int CRSpillFrameIndex;
95 
96  /// If any of CR[2-4] need to be saved in the prologue and restored in the
97  /// epilogue then they are added to this array. This is used for the
98  /// 64-bit SVR4 ABI.
99  SmallVector<unsigned, 3> MustSaveCRs;
100 
101  /// Hold onto our MachineFunction context.
102  MachineFunction &MF;
103 
104  /// Whether this uses the PIC Base register or not.
105  bool UsesPICBase;
106 
107 public:
109  : FramePointerSaveIndex(0),
110  ReturnAddrSaveIndex(0),
111  BasePointerSaveIndex(0),
112  PICBasePointerSaveIndex(0),
113  HasSpills(false),
114  HasNonRISpills(false),
115  SpillsCR(false),
116  SpillsVRSAVE(false),
117  LRStoreRequired(false),
118  UsesTOCBasePtr(false),
119  MinReservedArea(0),
120  TailCallSPDelta(0),
121  HasFastCall(false),
122  VarArgsFrameIndex(0),
123  VarArgsStackOffset(0),
124  VarArgsNumGPR(0),
125  VarArgsNumFPR(0),
126  CRSpillFrameIndex(0),
127  MF(MF),
128  UsesPICBase(0) {}
129 
130  int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
131  void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
132 
133  int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
134  void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
135 
136  int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
137  void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
138 
139  int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
140  void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
141 
142  unsigned getMinReservedArea() const { return MinReservedArea; }
143  void setMinReservedArea(unsigned size) { MinReservedArea = size; }
144 
145  int getTailCallSPDelta() const { return TailCallSPDelta; }
146  void setTailCallSPDelta(int size) { TailCallSPDelta = size; }
147 
148  /// MustSaveLR - This is set when the prolog/epilog inserter does its initial
149  /// scan of the function. It is true if the LR/LR8 register is ever explicitly
150  /// defined/clobbered in the machine function (e.g. by calls and movpctolr,
151  /// which is used in PIC generation), or if the LR stack slot is explicitly
152  /// referenced by builtin_return_address.
153  void setMustSaveLR(bool U) { MustSaveLR = U; }
154  bool mustSaveLR() const { return MustSaveLR; }
155 
156  void setHasSpills() { HasSpills = true; }
157  bool hasSpills() const { return HasSpills; }
158 
159  void setHasNonRISpills() { HasNonRISpills = true; }
160  bool hasNonRISpills() const { return HasNonRISpills; }
161 
162  void setSpillsCR() { SpillsCR = true; }
163  bool isCRSpilled() const { return SpillsCR; }
164 
165  void setSpillsVRSAVE() { SpillsVRSAVE = true; }
166  bool isVRSAVESpilled() const { return SpillsVRSAVE; }
167 
168  void setLRStoreRequired() { LRStoreRequired = true; }
169  bool isLRStoreRequired() const { return LRStoreRequired; }
170 
171  void setUsesTOCBasePtr() { UsesTOCBasePtr = true; }
172  bool usesTOCBasePtr() const { return UsesTOCBasePtr; }
173 
174  void setHasFastCall() { HasFastCall = true; }
175  bool hasFastCall() const { return HasFastCall;}
176 
177  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
178  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
179 
180  int getVarArgsStackOffset() const { return VarArgsStackOffset; }
181  void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
182 
183  unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
184  void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
185 
186  unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
187  void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
188 
189  int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
190  void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
191 
193  getMustSaveCRs() const { return MustSaveCRs; }
194  void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
195 
196  void setUsesPICBase(bool uses) { UsesPICBase = uses; }
197  bool usesPICBase() const { return UsesPICBase; }
198 
199  MCSymbol *getPICOffsetSymbol() const;
200 };
201 
202 } // end of namespace llvm
203 
204 
205 #endif
void push_back(const T &Elt)
Definition: SmallVector.h:222
void setVarArgsNumGPR(unsigned Num)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
void addMustSaveCR(unsigned Reg)
void setFramePointerSaveIndex(int Idx)
unsigned getVarArgsNumGPR() const
void setVarArgsNumFPR(unsigned Num)
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
void setVarArgsStackOffset(int Offset)
PPCFunctionInfo - This class is derived from MachineFunction private PowerPC target-specific informat...
PPCFunctionInfo(MachineFunction &MF)
unsigned getMinReservedArea() const
Reg
All possible values of the reg field in the ModR/M byte.
#define false
Definition: ConvertUTF.c:65
const SmallVectorImpl< unsigned > & getMustSaveCRs() const
unsigned getVarArgsNumFPR() const
void setVarArgsFrameIndex(int Index)
void setMinReservedArea(unsigned size)
void setPICBasePointerSaveIndex(int Idx)
void size_t size
MCSymbol * getPICOffsetSymbol() const
void setMustSaveLR(bool U)
MustSaveLR - This is set when the prolog/epilog inserter does its initial scan of the function...