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