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   /// MustSaveLR - Indicates whether LR is defined (or clobbered) in the current
  39   /// function.  This is only valid after the initial scan of the function by
  40   /// PEI.
  41   bool MustSaveLR;
  42
  43   /// Does this function have any stack spills.
  44   bool HasSpills;
  45
  46   /// Does this function spill using instructions with only r+r (not r+i)
  47   /// forms.
  48   bool HasNonRISpills;
  49
  50   /// SpillsCR - Indicates whether CR is spilled in the current function.
  51   bool SpillsCR;
  52
  53   /// Indicates whether VRSAVE is spilled in the current function.
  54   bool SpillsVRSAVE;
  55
  56   /// LRStoreRequired - The bool indicates whether there is some explicit use of
  57   /// the LR/LR8 stack slot that is not obvious from scanning the code.  This
  58   /// requires that the code generator produce a store of LR to the stack on
  59   /// entry, even though LR may otherwise apparently not be used.
  60   bool LRStoreRequired;
  61
  62   /// MinReservedArea - This is the frame size that is at least reserved in a
  63   /// potential caller (parameter+linkage area).
  64   unsigned MinReservedArea;
  65
  66   /// TailCallSPDelta - Stack pointer delta used when tail calling. Maximum
  67   /// amount the stack pointer is adjusted to make the frame bigger for tail
  68   /// calls. Used for creating an area before the register spill area.
  69   int TailCallSPDelta;
  70
  71   /// HasFastCall - Does this function contain a fast call. Used to determine
  72   /// how the caller's stack pointer should be calculated (epilog/dynamicalloc).
  73   bool HasFastCall;
  74
  75   /// VarArgsFrameIndex - FrameIndex for start of varargs area.
  76   int VarArgsFrameIndex;
  77   /// VarArgsStackOffset - StackOffset for start of stack
  78   /// arguments.
  79   int VarArgsStackOffset;
  80   /// VarArgsNumGPR - Index of the first unused integer
  81   /// register for parameter passing.
  82   unsigned VarArgsNumGPR;
  83   /// VarArgsNumFPR - Index of the first unused double
  84   /// register for parameter passing.
  85   unsigned VarArgsNumFPR;
  86
  87   /// CRSpillFrameIndex - FrameIndex for CR spill slot for 32-bit SVR4.
  88   int CRSpillFrameIndex;
  89
  90   /// If any of CR[2-4] need to be saved in the prologue and restored in the
  91   /// epilogue then they are added to this array. This is used for the
  92   /// 64-bit SVR4 ABI.
  93   SmallVector<unsigned, 3> MustSaveCRs;
  94
  95   /// Hold onto our MachineFunction context.
  96   MachineFunction &MF;
  97
  98   /// Whether this uses the PIC Base register or not.
  99   bool UsesPICBase;
 100
 101 public:
 102   explicit PPCFunctionInfo(MachineFunction &MF)
 103     : FramePointerSaveIndex(0),
 104       ReturnAddrSaveIndex(0),
 105       BasePointerSaveIndex(0),
 106       HasSpills(false),
 107       HasNonRISpills(false),
 108       SpillsCR(false),
 109       SpillsVRSAVE(false),
 110       LRStoreRequired(false),
 111       MinReservedArea(0),
 112       TailCallSPDelta(0),
 113       HasFastCall(false),
 114       VarArgsFrameIndex(0),
 115       VarArgsStackOffset(0),
 116       VarArgsNumGPR(0),
 117       VarArgsNumFPR(0),
 118       CRSpillFrameIndex(0),
 119       MF(MF),
 120       UsesPICBase(0) {}
 121
 122   int getFramePointerSaveIndex() const { return FramePointerSaveIndex; }
 123   void setFramePointerSaveIndex(int Idx) { FramePointerSaveIndex = Idx; }
 124
 125   int getReturnAddrSaveIndex() const { return ReturnAddrSaveIndex; }
 126   void setReturnAddrSaveIndex(int idx) { ReturnAddrSaveIndex = idx; }
 127
 128   int getBasePointerSaveIndex() const { return BasePointerSaveIndex; }
 129   void setBasePointerSaveIndex(int Idx) { BasePointerSaveIndex = Idx; }
 130
 131   unsigned getMinReservedArea() const { return MinReservedArea; }
 132   void setMinReservedArea(unsigned size) { MinReservedArea = size; }
 133
 134   int getTailCallSPDelta() const { return TailCallSPDelta; }
 135   void setTailCallSPDelta(int size) { TailCallSPDelta = size; }
 136
 137   /// MustSaveLR - This is set when the prolog/epilog inserter does its initial
 138   /// scan of the function. It is true if the LR/LR8 register is ever explicitly
 139   /// defined/clobbered in the machine function (e.g. by calls and movpctolr,
 140   /// which is used in PIC generation), or if the LR stack slot is explicitly
 141   /// referenced by builtin_return_address.
 142   void setMustSaveLR(bool U) { MustSaveLR = U; }
 143   bool mustSaveLR() const    { return MustSaveLR; }
 144
 145   void setHasSpills()      { HasSpills = true; }
 146   bool hasSpills() const   { return HasSpills; }
 147
 148   void setHasNonRISpills()    { HasNonRISpills = true; }
 149   bool hasNonRISpills() const { return HasNonRISpills; }
 150
 151   void setSpillsCR()       { SpillsCR = true; }
 152   bool isCRSpilled() const { return SpillsCR; }
 153
 154   void setSpillsVRSAVE()       { SpillsVRSAVE = true; }
 155   bool isVRSAVESpilled() const { return SpillsVRSAVE; }
 156
 157   void setLRStoreRequired() { LRStoreRequired = true; }
 158   bool isLRStoreRequired() const { return LRStoreRequired; }
 159
 160   void setHasFastCall() { HasFastCall = true; }
 161   bool hasFastCall() const { return HasFastCall;}
 162
 163   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 164   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 165
 166   int getVarArgsStackOffset() const { return VarArgsStackOffset; }
 167   void setVarArgsStackOffset(int Offset) { VarArgsStackOffset = Offset; }
 168
 169   unsigned getVarArgsNumGPR() const { return VarArgsNumGPR; }
 170   void setVarArgsNumGPR(unsigned Num) { VarArgsNumGPR = Num; }
 171
 172   unsigned getVarArgsNumFPR() const { return VarArgsNumFPR; }
 173   void setVarArgsNumFPR(unsigned Num) { VarArgsNumFPR = Num; }
 174
 175   int getCRSpillFrameIndex() const { return CRSpillFrameIndex; }
 176   void setCRSpillFrameIndex(int idx) { CRSpillFrameIndex = idx; }
 177
 178   const SmallVectorImpl<unsigned> &
 179     getMustSaveCRs() const { return MustSaveCRs; }
 180   void addMustSaveCR(unsigned Reg) { MustSaveCRs.push_back(Reg); }
 181
 182   void setUsesPICBase(bool uses) { UsesPICBase = uses; }
 183   bool usesPICBase() const { return UsesPICBase; }
 184
 185   MCSymbol *getPICOffsetSymbol() const;
 186 };
 187
 188 } // end of namespace llvm
 189
 190
 191 #endif