]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
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 | ||
1a4d82fc JJ |
14 | #ifndef LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H |
15 | #define LLVM_LIB_TARGET_POWERPC_PPCMACHINEFUNCTIONINFO_H | |
223e47cc LB |
16 | |
17 | #include "llvm/CodeGen/MachineFunction.h" | |
18 | ||
19 | namespace llvm { | |
20 | ||
21 | /// PPCFunctionInfo - This class is derived from MachineFunction private | |
22 | /// PowerPC target-specific information for each MachineFunction. | |
23 | class 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 | ||
1a4d82fc JJ |
35 | /// Frame index where the old base pointer is stored. |
36 | int BasePointerSaveIndex; | |
37 | ||
85aaf69f SL |
38 | /// Frame index where the old PIC base pointer is stored. |
39 | int PICBasePointerSaveIndex; | |
40 | ||
223e47cc LB |
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 | ||
970d7e83 LB |
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 | ||
223e47cc LB |
53 | /// SpillsCR - Indicates whether CR is spilled in the current function. |
54 | bool SpillsCR; | |
55 | ||
1a4d82fc JJ |
56 | /// Indicates whether VRSAVE is spilled in the current function. |
57 | bool SpillsVRSAVE; | |
58 | ||
223e47cc LB |
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 | /// MinReservedArea - This is the frame size that is at least reserved in a | |
66 | /// potential caller (parameter+linkage area). | |
67 | unsigned MinReservedArea; | |
68 | ||
69 | /// TailCallSPDelta - Stack pointer delta used when tail calling. Maximum | |
70 | /// amount the stack pointer is adjusted to make the frame bigger for tail | |
71 | /// calls. Used for creating an area before the register spill area. | |
72 | int TailCallSPDelta; | |
73 | ||
74 | /// HasFastCall - Does this function contain a fast call. Used to determine | |
75 | /// how the caller's stack pointer should be calculated (epilog/dynamicalloc). | |
76 | bool HasFastCall; | |
77 | ||
78 | /// VarArgsFrameIndex - FrameIndex for start of varargs area. | |
79 | int VarArgsFrameIndex; | |
80 | /// VarArgsStackOffset - StackOffset for start of stack | |
81 | /// arguments. | |
82 | int VarArgsStackOffset; | |
83 | /// VarArgsNumGPR - Index of the first unused integer | |
84 | /// register for parameter passing. | |
85 | unsigned VarArgsNumGPR; | |
86 | /// VarArgsNumFPR - Index of the first unused double | |
87 | /// register for parameter passing. | |
88 | unsigned VarArgsNumFPR; | |
89 | ||
970d7e83 LB |
90 | /// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4. |
91 | int CRSpillFrameIndex; | |
92 | ||
1a4d82fc JJ |
93 | /// If any of CR[2-4] need to be saved in the prologue and restored in the |
94 | /// epilogue then they are added to this array. This is used for the | |
95 | /// 64-bit SVR4 ABI. | |
96 | SmallVector<unsigned, 3> MustSaveCRs; | |
97 | ||
98 | /// Hold onto our MachineFunction context. | |
99 | MachineFunction &MF; | |
100 | ||
101 | /// Whether this uses the PIC Base register or not. | |
102 | bool UsesPICBase; | |
103 | ||
223e47cc LB |
104 | public: |
105 | explicit PPCFunctionInfo(MachineFunction &MF) | |
106 | : FramePointerSaveIndex(0), | |
107 | ReturnAddrSaveIndex(0), | |
1a4d82fc | 108 | BasePointerSaveIndex(0), |
85aaf69f | 109 | PICBasePointerSaveIndex(0), |
970d7e83 LB |
110 | HasSpills(false), |
111 | HasNonRISpills(false), | |
223e47cc | 112 | SpillsCR(false), |
1a4d82fc | 113 | SpillsVRSAVE(false), |
223e47cc LB |
114 | LRStoreRequired(false), |
115 | MinReservedArea(0), | |
116 | TailCallSPDelta(0), | |
117 | HasFastCall(false), | |
118 | VarArgsFrameIndex(0), | |
119 | VarArgsStackOffset(0), | |
120 | VarArgsNumGPR(0), | |
970d7e83 | 121 | VarArgsNumFPR(0), |
1a4d82fc JJ |
122 | CRSpillFrameIndex(0), |
123 | MF(MF), | |
124 | UsesPICBase(0) {} | |
223e47cc LB |
125 | |
126 | int getFramePointerSaveIndex() const { return FramePointerSaveIndex; } | |
127 | void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; } | |
128 | ||
129 | int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; } | |
130 | void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; } | |
131 | ||
1a4d82fc JJ |
132 | int getBasePointerSaveIndex() const { return BasePointerSaveIndex; } |
133 | void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; } | |
134 | ||
85aaf69f SL |
135 | int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; } |
136 | void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; } | |
137 | ||
223e47cc LB |
138 | unsigned getMinReservedArea() const { return MinReservedArea; } |
139 | void setMinReservedArea(unsigned size) { MinReservedArea = size; } | |
140 | ||
141 | int getTailCallSPDelta() const { return TailCallSPDelta; } | |
142 | void setTailCallSPDelta(int size) { TailCallSPDelta = size; } | |
143 | ||
144 | /// MustSaveLR - This is set when the prolog/epilog inserter does its initial | |
145 | /// scan of the function. It is true if the LR/LR8 register is ever explicitly | |
146 | /// defined/clobbered in the machine function (e.g. by calls and movpctolr, | |
147 | /// which is used in PIC generation), or if the LR stack slot is explicitly | |
148 | /// referenced by builtin_return_address. | |
149 | void setMustSaveLR(bool U) { MustSaveLR = U; } | |
150 | bool mustSaveLR() const { return MustSaveLR; } | |
151 | ||
970d7e83 LB |
152 | void setHasSpills() { HasSpills = true; } |
153 | bool hasSpills() const { return HasSpills; } | |
154 | ||
155 | void setHasNonRISpills() { HasNonRISpills = true; } | |
156 | bool hasNonRISpills() const { return HasNonRISpills; } | |
157 | ||
223e47cc LB |
158 | void setSpillsCR() { SpillsCR = true; } |
159 | bool isCRSpilled() const { return SpillsCR; } | |
160 | ||
1a4d82fc JJ |
161 | void setSpillsVRSAVE() { SpillsVRSAVE = true; } |
162 | bool isVRSAVESpilled() const { return SpillsVRSAVE; } | |
163 | ||
223e47cc LB |
164 | void setLRStoreRequired() { LRStoreRequired = true; } |
165 | bool isLRStoreRequired() const { return LRStoreRequired; } | |
166 | ||
167 | void setHasFastCall() { HasFastCall = true; } | |
168 | bool hasFastCall() const { return HasFastCall;} | |
169 | ||
170 | int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } | |
171 | void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } | |
172 | ||
173 | int getVarArgsStackOffset() const { return VarArgsStackOffset; } | |
174 | void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; } | |
175 | ||
176 | unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; } | |
177 | void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; } | |
178 | ||
179 | unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; } | |
180 | void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; } | |
970d7e83 LB |
181 | |
182 | int getCRSpillFrameIndex() const { return CRSpillFrameIndex; } | |
183 | void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; } | |
1a4d82fc JJ |
184 | |
185 | const SmallVectorImpl<unsigned> & | |
186 | getMustSaveCRs() const { return MustSaveCRs; } | |
187 | void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); } | |
188 | ||
189 | void setUsesPICBase(bool uses) { UsesPICBase = uses; } | |
190 | bool usesPICBase() const { return UsesPICBase; } | |
191 | ||
192 | MCSymbol *getPICOffsetSymbol() const; | |
223e47cc LB |
193 | }; |
194 | ||
195 | } // end of namespace llvm | |
196 | ||
197 | ||
198 | #endif |