• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   /// 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 
111 public:
PPCFunctionInfo(MachineFunction & MF)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 
getFramePointerSaveIndex()135   int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
setFramePointerSaveIndex(int Idx)136   void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
137 
getReturnAddrSaveIndex()138   int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
setReturnAddrSaveIndex(int idx)139   void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
140 
getBasePointerSaveIndex()141   int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
setBasePointerSaveIndex(int Idx)142   void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
143 
getPICBasePointerSaveIndex()144   int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
setPICBasePointerSaveIndex(int Idx)145   void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
146 
getMinReservedArea()147   unsigned getMinReservedArea() const { return MinReservedArea; }
setMinReservedArea(unsigned size)148   void setMinReservedArea(unsigned size) { MinReservedArea = size; }
149 
getTailCallSPDelta()150   int getTailCallSPDelta() const { return TailCallSPDelta; }
setTailCallSPDelta(int size)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.
setMustSaveLR(bool U)158   void setMustSaveLR(bool U) { MustSaveLR = U; }
mustSaveLR()159   bool mustSaveLR() const    { return MustSaveLR; }
160 
setHasSpills()161   void setHasSpills()      { HasSpills = true; }
hasSpills()162   bool hasSpills() const   { return HasSpills; }
163 
setHasNonRISpills()164   void setHasNonRISpills()    { HasNonRISpills = true; }
hasNonRISpills()165   bool hasNonRISpills() const { return HasNonRISpills; }
166 
setSpillsCR()167   void setSpillsCR()       { SpillsCR = true; }
isCRSpilled()168   bool isCRSpilled() const { return SpillsCR; }
169 
setSpillsVRSAVE()170   void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
isVRSAVESpilled()171   bool isVRSAVESpilled() const { return SpillsVRSAVE; }
172 
setLRStoreRequired()173   void setLRStoreRequired() { LRStoreRequired = true; }
isLRStoreRequired()174   bool isLRStoreRequired() const { return LRStoreRequired; }
175 
setUsesTOCBasePtr()176   void setUsesTOCBasePtr()    { UsesTOCBasePtr = true; }
usesTOCBasePtr()177   bool usesTOCBasePtr() const { return UsesTOCBasePtr; }
178 
setHasFastCall()179   void setHasFastCall() { HasFastCall = true; }
hasFastCall()180   bool hasFastCall() const { return HasFastCall;}
181 
getVarArgsFrameIndex()182   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
setVarArgsFrameIndex(int Index)183   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
184 
getVarArgsStackOffset()185   int getVarArgsStackOffset() const { return VarArgsStackOffset; }
setVarArgsStackOffset(int Offset)186   void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
187 
getVarArgsNumGPR()188   unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
setVarArgsNumGPR(unsigned Num)189   void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
190 
getVarArgsNumFPR()191   unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
setVarArgsNumFPR(unsigned Num)192   void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
193 
getCRSpillFrameIndex()194   int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
setCRSpillFrameIndex(int idx)195   void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
196 
197   const SmallVectorImpl<unsigned> &
getMustSaveCRs()198     getMustSaveCRs() const { return MustSaveCRs; }
addMustSaveCR(unsigned Reg)199   void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
200 
setUsesPICBase(bool uses)201   void setUsesPICBase(bool uses) { UsesPICBase = uses; }
usesPICBase()202   bool usesPICBase() const { return UsesPICBase; }
203 
isSplitCSR()204   bool isSplitCSR() const { return IsSplitCSR; }
setIsSplitCSR(bool s)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