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 
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 
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   /// 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 
90   /// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4.
91   int CRSpillFrameIndex;
92 
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 
104 public:
PPCFunctionInfo(MachineFunction & MF)105   explicit PPCFunctionInfo(MachineFunction &MF)
106     : FramePointerSaveIndex(0),
107       ReturnAddrSaveIndex(0),
108       BasePointerSaveIndex(0),
109       PICBasePointerSaveIndex(0),
110       HasSpills(false),
111       HasNonRISpills(false),
112       SpillsCR(false),
113       SpillsVRSAVE(false),
114       LRStoreRequired(false),
115       MinReservedArea(0),
116       TailCallSPDelta(0),
117       HasFastCall(false),
118       VarArgsFrameIndex(0),
119       VarArgsStackOffset(0),
120       VarArgsNumGPR(0),
121       VarArgsNumFPR(0),
122       CRSpillFrameIndex(0),
123       MF(MF),
124       UsesPICBase(0) {}
125 
getFramePointerSaveIndex()126   int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
setFramePointerSaveIndex(int Idx)127   void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
128 
getReturnAddrSaveIndex()129   int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
setReturnAddrSaveIndex(int idx)130   void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
131 
getBasePointerSaveIndex()132   int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
setBasePointerSaveIndex(int Idx)133   void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
134 
getPICBasePointerSaveIndex()135   int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
setPICBasePointerSaveIndex(int Idx)136   void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
137 
getMinReservedArea()138   unsigned getMinReservedArea() const { return MinReservedArea; }
setMinReservedArea(unsigned size)139   void setMinReservedArea(unsigned size) { MinReservedArea = size; }
140 
getTailCallSPDelta()141   int getTailCallSPDelta() const { return TailCallSPDelta; }
setTailCallSPDelta(int size)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.
setMustSaveLR(bool U)149   void setMustSaveLR(bool U) { MustSaveLR = U; }
mustSaveLR()150   bool mustSaveLR() const    { return MustSaveLR; }
151 
setHasSpills()152   void setHasSpills()      { HasSpills = true; }
hasSpills()153   bool hasSpills() const   { return HasSpills; }
154 
setHasNonRISpills()155   void setHasNonRISpills()    { HasNonRISpills = true; }
hasNonRISpills()156   bool hasNonRISpills() const { return HasNonRISpills; }
157 
setSpillsCR()158   void setSpillsCR()       { SpillsCR = true; }
isCRSpilled()159   bool isCRSpilled() const { return SpillsCR; }
160 
setSpillsVRSAVE()161   void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
isVRSAVESpilled()162   bool isVRSAVESpilled() const { return SpillsVRSAVE; }
163 
setLRStoreRequired()164   void setLRStoreRequired() { LRStoreRequired = true; }
isLRStoreRequired()165   bool isLRStoreRequired() const { return LRStoreRequired; }
166 
setHasFastCall()167   void setHasFastCall() { HasFastCall = true; }
hasFastCall()168   bool hasFastCall() const { return HasFastCall;}
169 
getVarArgsFrameIndex()170   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
setVarArgsFrameIndex(int Index)171   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
172 
getVarArgsStackOffset()173   int getVarArgsStackOffset() const { return VarArgsStackOffset; }
setVarArgsStackOffset(int Offset)174   void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
175 
getVarArgsNumGPR()176   unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
setVarArgsNumGPR(unsigned Num)177   void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
178 
getVarArgsNumFPR()179   unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
setVarArgsNumFPR(unsigned Num)180   void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
181 
getCRSpillFrameIndex()182   int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
setCRSpillFrameIndex(int idx)183   void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
184 
185   const SmallVectorImpl<unsigned> &
getMustSaveCRs()186     getMustSaveCRs() const { return MustSaveCRs; }
addMustSaveCR(unsigned Reg)187   void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
188 
setUsesPICBase(bool uses)189   void setUsesPICBase(bool uses) { UsesPICBase = uses; }
usesPICBase()190   bool usesPICBase() const { return UsesPICBase; }
191 
192   MCSymbol *getPICOffsetSymbol() const;
193 };
194 
195 } // end of namespace llvm
196 
197 
198 #endif
199