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
17#include "llvm/CodeGen/MachineFunction.h"
18
19namespace llvm {
20
21/// PPCFunctionInfo - This class is derived from MachineFunction private
22/// PowerPC target-specific information for each MachineFunction.
23class PPCFunctionInfo : public MachineFunctionInfo {
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  /// True if this function has a subset of CSRs that is handled explicitly via
108  /// copies
109  bool IsSplitCSR;
110
111public:
112  explicit PPCFunctionInfo(MachineFunction &MF)
113    : FramePointerSaveIndex(0),
114      ReturnAddrSaveIndex(0),
115      BasePointerSaveIndex(0),
116      PICBasePointerSaveIndex(0),
117      HasSpills(false),
118      HasNonRISpills(false),
119      SpillsCR(false),
120      SpillsVRSAVE(false),
121      LRStoreRequired(false),
122      UsesTOCBasePtr(false),
123      MinReservedArea(0),
124      TailCallSPDelta(0),
125      HasFastCall(false),
126      VarArgsFrameIndex(0),
127      VarArgsStackOffset(0),
128      VarArgsNumGPR(0),
129      VarArgsNumFPR(0),
130      CRSpillFrameIndex(0),
131      MF(MF),
132      UsesPICBase(0),
133      IsSplitCSR(false) {}
134
135  int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
136  void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
137
138  int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
139  void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
140
141  int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
142  void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
143
144  int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
145  void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
146
147  unsigned getMinReservedArea() const { return MinReservedArea; }
148  void setMinReservedArea(unsigned size) { MinReservedArea = size; }
149
150  int getTailCallSPDelta() const { return TailCallSPDelta; }
151  void setTailCallSPDelta(int size) { TailCallSPDelta = size; }
152
153  /// MustSaveLR - This is set when the prolog/epilog inserter does its initial
154  /// scan of the function. It is true if the LR/LR8 register is ever explicitly
155  /// defined/clobbered in the machine function (e.g. by calls and movpctolr,
156  /// which is used in PIC generation), or if the LR stack slot is explicitly
157  /// referenced by builtin_return_address.
158  void setMustSaveLR(bool U) { MustSaveLR = U; }
159  bool mustSaveLR() const    { return MustSaveLR; }
160
161  void setHasSpills()      { HasSpills = true; }
162  bool hasSpills() const   { return HasSpills; }
163
164  void setHasNonRISpills()    { HasNonRISpills = true; }
165  bool hasNonRISpills() const { return HasNonRISpills; }
166
167  void setSpillsCR()       { SpillsCR = true; }
168  bool isCRSpilled() const { return SpillsCR; }
169
170  void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
171  bool isVRSAVESpilled() const { return SpillsVRSAVE; }
172
173  void setLRStoreRequired() { LRStoreRequired = true; }
174  bool isLRStoreRequired() const { return LRStoreRequired; }
175
176  void setUsesTOCBasePtr()    { UsesTOCBasePtr = true; }
177  bool usesTOCBasePtr() const { return UsesTOCBasePtr; }
178
179  void setHasFastCall() { HasFastCall = true; }
180  bool hasFastCall() const { return HasFastCall;}
181
182  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
183  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
184
185  int getVarArgsStackOffset() const { return VarArgsStackOffset; }
186  void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
187
188  unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
189  void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
190
191  unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
192  void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
193
194  int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
195  void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
196
197  const SmallVectorImpl<unsigned> &
198    getMustSaveCRs() const { return MustSaveCRs; }
199  void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
200
201  void setUsesPICBase(bool uses) { UsesPICBase = uses; }
202  bool usesPICBase() const { return UsesPICBase; }
203
204  bool isSplitCSR() const { return IsSplitCSR; }
205  void setIsSplitCSR(bool s) { IsSplitCSR = s; }
206
207  MCSymbol *getPICOffsetSymbol() const;
208
209  MCSymbol *getGlobalEPSymbol() const;
210  MCSymbol *getLocalEPSymbol() const;
211  MCSymbol *getTOCOffsetSymbol() const;
212};
213
214} // end of namespace llvm
215
216
217#endif
218