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   /// determineCalleeSaves().
  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   unsigned PICLabelUId;
 102
 103   /// VarArgsFrameIndex - FrameIndex for start of varargs area.
 104   int VarArgsFrameIndex;
 105
 106   /// HasITBlocks - True if IT blocks have been inserted.
 107   bool HasITBlocks;
 108
 109   /// CPEClones - Track constant pool entries clones created by Constant Island
 110   /// pass.
 111   DenseMap<unsigned, unsigned> CPEClones;
 112
 113   /// GlobalBaseReg - keeps track of the virtual register initialized for
 114   /// use as the global base register. This is used for PIC in some PIC
 115   /// relocation models.
 116   unsigned GlobalBaseReg;
 117
 118   /// ArgumentStackSize - amount of bytes on stack consumed by the arguments
 119   /// being passed on the stack
 120   unsigned ArgumentStackSize;
 121
 122   /// CoalescedWeights - mapping of basic blocks to the rolling counter of
 123   /// coalesced weights.
 124   DenseMap<const MachineBasicBlock*, unsigned> CoalescedWeights;
 125
 126 public:
 127   ARMFunctionInfo() :
 128     isThumb(false),
 129     hasThumb2(false),
 130     ArgRegsSaveSize(0), ReturnRegsCount(0), HasStackFrame(false),
 131     RestoreSPFromFP(false),
 132     LRSpilledForFarJump(false),
 133     FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0),
 134     GPRCS1Size(0), GPRCS2Size(0), DPRCSAlignGapSize(0), DPRCSSize(0),
 135     NumAlignedDPRCS2Regs(0), PICLabelUId(0),
 136     VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {}
 137
 138   explicit ARMFunctionInfo(MachineFunction &MF);
 139
 140   bool isThumbFunction() const { return isThumb; }
 141   bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; }
 142   bool isThumb2Function() const { return isThumb && hasThumb2; }
 143
 144   unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; }
 145   void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; }
 146
 147   unsigned getArgRegsSaveSize() const { return ArgRegsSaveSize; }
 148   void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; }
 149
 150   unsigned getReturnRegsCount() const { return ReturnRegsCount; }
 151   void setReturnRegsCount(unsigned s) { ReturnRegsCount = s; }
 152
 153   bool hasStackFrame() const { return HasStackFrame; }
 154   void setHasStackFrame(bool s) { HasStackFrame = s; }
 155
 156   bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; }
 157   void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; }
 158
 159   bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; }
 160   void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; }
 161
 162   unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; }
 163   void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; }
 164
 165   unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; }
 166   void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; }
 167
 168   unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; }
 169   unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; }
 170   unsigned getDPRCalleeSavedAreaOffset()  const { return DPRCSOffset; }
 171
 172   void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; }
 173   void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; }
 174   void setDPRCalleeSavedAreaOffset(unsigned o)  { DPRCSOffset = o; }
 175
 176   unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; }
 177   unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; }
 178   unsigned getDPRCalleeSavedGapSize() const   { return DPRCSAlignGapSize; }
 179   unsigned getDPRCalleeSavedAreaSize()  const { return DPRCSSize; }
 180
 181   void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; }
 182   void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; }
 183   void setDPRCalleeSavedGapSize(unsigned s)   { DPRCSAlignGapSize = s; }
 184   void setDPRCalleeSavedAreaSize(unsigned s)  { DPRCSSize = s; }
 185
 186   unsigned getArgumentStackSize() const { return ArgumentStackSize; }
 187   void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
 188
 189   void initPICLabelUId(unsigned UId) {
 190     PICLabelUId = UId;
 191   }
 192
 193   unsigned getNumPICLabels() const {
 194     return PICLabelUId;
 195   }
 196
 197   unsigned createPICLabelUId() {
 198     return PICLabelUId++;
 199   }
 200
 201   int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
 202   void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
 203
 204   bool hasITBlocks() const { return HasITBlocks; }
 205   void setHasITBlocks(bool h) { HasITBlocks = h; }
 206
 207   unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
 208   void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
 209
 210   void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) {
 211     if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second)
 212       llvm_unreachable("Duplicate entries!");
 213   }
 214
 215   unsigned getOriginalCPIdx(unsigned CloneIdx) const {
 216     DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
 217     if (I != CPEClones.end())
 218       return I->second;
 219     else
 220       return -1U;
 221   }
 222
 223   DenseMap<const MachineBasicBlock*, unsigned>::iterator getCoalescedWeight(
 224                                                   MachineBasicBlock* MBB) {
 225     auto It = CoalescedWeights.find(MBB);
 226     if (It == CoalescedWeights.end()) {
 227       It = CoalescedWeights.insert(std::make_pair(MBB, 0)).first;
 228     }
 229     return It;
 230   }
 231 };
 232 } // End llvm namespace
 233
 234 #endif