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