lib/Target/PowerPC/PPCMachineFunctionInfo.h

   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:
 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
 130   int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
 131   void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
 132
 133   int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
 134   void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
 135
 136   int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
 137   void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
 138
 139   int getPICBasePointerSaveIndex() const { return PICBasePointerSaveIndex; }
 140   void setPICBasePointerSaveIndex(int Idx) { PICBasePointerSaveIndex = Idx; }
 141
 142   unsigned getMinReservedArea() const { return MinReservedArea; }
 143   void setMinReservedArea(unsigned size) { MinReservedArea = size; }
 144
 145   int getTailCallSPDelta() const { return TailCallSPDelta; }
 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.
 153   void setMustSaveLR(bool U) { MustSaveLR = U; }
 154   bool mustSaveLR() const    { return MustSaveLR; }
 155
 156   void setHasSpills()      { HasSpills = true; }
 157   bool hasSpills() const   { return HasSpills; }
 158
 159   void setHasNonRISpills()    { HasNonRISpills = true; }
 160   bool hasNonRISpills() const { return HasNonRISpills; }
 161
 162   void setSpillsCR()       { SpillsCR = true; }
 163   bool isCRSpilled() const { return SpillsCR; }
 164
 165   void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
 166   bool isVRSAVESpilled() const { return SpillsVRSAVE; }
 167
 168   void setLRStoreRequired() { LRStoreRequired = true; }
 169   bool isLRStoreRequired() const { return LRStoreRequired; }
 170
 171   void setUsesTOCBasePtr()    { UsesTOCBasePtr = true; }
 172   bool usesTOCBasePtr() const { return UsesTOCBasePtr; }
 173
 174   void setHasFastCall() { HasFastCall = true; }
 175   bool hasFastCall() const { return HasFastCall;}
 176
 177   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 178   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 179
 180   int getVarArgsStackOffset() const { return VarArgsStackOffset; }
 181   void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
 182
 183   unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
 184   void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
 185
 186   unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
 187   void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
 188
 189   int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
 190   void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
 191
 192   const SmallVectorImpl<unsigned> &
 193     getMustSaveCRs() const { return MustSaveCRs; }
 194   void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
 195
 196   void setUsesPICBase(bool uses) { UsesPICBase = uses; }
 197   bool usesPICBase() const { return UsesPICBase; }
 198
 199   MCSymbol *getPICOffsetSymbol() const;
 200 };
 201
 202 } // end of namespace llvm
 203
 204
 205 #endif