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