lib/Target/ARM/ARMMachineFunctionInfo.h

   1 //===-- ARMMachineFuctionInfo.h - ARM machine function info -----*- 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 ARM-specific per-machine-function information.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef ARMMACHINEFUNCTIONINFO_H
  15 #define ARMMACHINEFUNCTIONINFO_H
  16
  17 #include "ARMSubtarget.h"
  18 #include "llvm/ADT/BitVector.h"
  19 #include "llvm/CodeGen/MachineFunction.h"
  20 #include "llvm/Target/TargetMachine.h"
  21 #include "llvm/Target/TargetRegisterInfo.h"
  22
  23 namespace llvm {
  24
  25 /// ARMFunctionInfo - This class is derived from MachineFunctionInfo and
  26 /// contains private ARM-specific information for each MachineFunction.
  27 class ARMFunctionInfo : public MachineFunctionInfo {
  28   virtual void anchor();
  29
  30   /// isThumb - True if this function is compiled under Thumb mode.
  31   /// Used to initialized Align, so must precede it.
  32   bool isThumb;
  33
  34   /// hasThumb2 - True if the target architecture supports Thumb2. Do not use
  35   /// to determine if function is compiled under Thumb mode, for that use
  36   /// 'isThumb'.
  37   bool hasThumb2;
  38
  39   /// StByValParamsPadding - For parameter that is split between
  40   /// GPRs and memory; while recovering GPRs part, when
  41   /// StackAlignment > 4, and GPRs-part-size mod StackAlignment != 0,
  42   /// we need to insert gap before parameter start address. It allows to
  43   /// "attach" GPR-part to the part that was passed via stack.
  44   unsigned StByValParamsPadding;
  45
  46   /// VarArgsRegSaveSize - Size of the register save area for vararg functions.
  47   ///
  48   unsigned ArgRegsSaveSize;
  49
  50   /// HasStackFrame - True if this function has a stack frame. Set by
  51   /// processFunctionBeforeCalleeSavedScan().
  52   bool HasStackFrame;
  53
  54   /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by
  55   /// emitPrologue.
  56   bool RestoreSPFromFP;
  57
  58   /// LRSpilledForFarJump - True if the LR register has been for spilled to
  59   /// enable far jump.
  60   bool LRSpilledForFarJump;
  61
  62   /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer
  63   /// spill stack offset.
  64   unsigned FramePtrSpillOffset;
  65
  66   /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved
  67   /// register spills areas. For Mac OS X:
  68   ///
  69   /// GPR callee-saved (1) : r4, r5, r6, r7, lr
  70   /// --------------------------------------------
  71   /// GPR callee-saved (2) : r8, r10, r11
  72   /// --------------------------------------------
  73   /// DPR callee-saved : d8 - d15
  74   ///
  75   /// Also see AlignedDPRCSRegs below. Not all D-regs need to go in area 3.
  76   /// Some may be spilled after the stack has been realigned.
  77   unsigned GPRCS1Offset;
  78   unsigned GPRCS2Offset;
  79   unsigned DPRCSOffset;
  80
  81   /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills
  82   /// areas.
  83   unsigned GPRCS1Size;
  84   unsigned GPRCS2Size;
  85   unsigned DPRCSSize;
  86
  87   /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in
  88   /// the aligned portion of the stack frame.  This is always a contiguous
  89   /// sequence of D-registers starting from d8.
  90   ///
  91   /// We do not keep track of the frame indices used for these registers - they
  92   /// behave like any other frame index in the aligned stack frame.  These
  93   /// registers also aren't included in DPRCSSize above.
  94   unsigned NumAlignedDPRCS2Regs;
  95
  96   /// JumpTableUId - Unique id for jumptables.
  97   ///
  98   unsigned JumpTableUId;
  99
 100   unsigned PICLabelUId;
 101
 102   /// VarArgsFrameIndex - FrameIndex for start of varargs area.
 103   int VarArgsFrameIndex;
 104
 105   /// HasITBlocks - True if IT blocks have been inserted.
 106   bool HasITBlocks;
 107
 108   /// CPEClones - Track constant pool entries clones created by Constant Island
 109   /// pass.
 110   DenseMap<unsigned, unsigned> CPEClones;
 111
 112   /// GlobalBaseReg - keeps track of the virtual register initialized for
 113   /// use as the global base register. This is used for PIC in some PIC
 114   /// relocation models.
 115   unsigned GlobalBaseReg;
 116
 117   /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
 118   /// being passed on the stack
 119   unsigned ArgumentStackSize;
 120
 121 public:
 122   ARMFunctionInfo() :
 123     isThumb(false),
 124     hasThumb2(false),
 125     ArgRegsSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false),
 126     LRSpilledForFarJump(false),
 127     FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
 128     GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
 129     NumAlignedDPRCS2Regs(0),
 130     JumpTableUId(0), PICLabelUId(0),
 131     VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
 132
 133   explicit ARMFunctionInfo(MachineFunction &MF) :
 134     isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()),
 135     hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()),
 136     StByValParamsPadding(0),
 137     ArgRegsSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false),
 138     LRSpilledForFarJump(false),
 139     FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
 140     GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0),
 141     JumpTableUId(0), PICLabelUId(0),
 142     VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
 143
 144   bool isThumbFunction() const { return isThumb; }
 145   bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
 146   bool isThumb2Function() const { return isThumb && hasThumb2; }
 147
 148   unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; }
 149   void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; }
 150
 151   unsigned getArgRegsSaveSize(unsigned Align = 0) const {
 152     if (!Align)
 153       return ArgRegsSaveSize;
 154     return (ArgRegsSaveSize + Align - 1) & ~(Align - 1);
 155   }
 156   void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
 157
 158   bool hasStackFrame() const { return HasStackFrame; }
 159   void setHasStackFrame(bool s) { HasStackFrame = s; }
 160
 161   bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
 162   void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
 163
 164   bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
 165   void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
 166
 167   unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
 168   void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
 169
 170   unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
 171   void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
 172
 173   unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
 174   unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
 175   unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
 176
 177   void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
 178   void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
 179   void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
 180
 181   unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
 182   unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
 183   unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
 184
 185   void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
 186   void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
 187   void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
 188
 189   unsigned getArgumentStackSize() const { return ArgumentStackSize; }
 190   void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
 191
 192   unsigned createJumpTableUId() {
 193     return JumpTableUId++;
 194   }
 195
 196   unsigned getNumJumpTables() const {
 197     return JumpTableUId;
 198   }
 199
 200   void initPICLabelUId(unsigned UId) {
 201     PICLabelUId = UId;
 202   }
 203
 204   unsigned getNumPICLabels() const {
 205     return PICLabelUId;
 206   }
 207
 208   unsigned createPICLabelUId() {
 209     return PICLabelUId++;
 210   }
 211
 212   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 213   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 214
 215   bool hasITBlocks() const { return HasITBlocks; }
 216   void setHasITBlocks(bool h) { HasITBlocks = h; }
 217
 218   unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
 219   void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
 220
 221   void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
 222     if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
 223       assert(0 && "Duplicate entries!");
 224   }
 225
 226   unsigned getOriginalCPIdx(unsigned CloneIdx) const {
 227     DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
 228     if (I != CPEClones.end())
 229       return I->second;
 230     else
 231       return -1U;
 232   }
 233 };
 234 } // End llvm namespace
 235
 236 #endif // ARMMACHINEFUNCTIONINFO_H