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: ARMFunctionInfo()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 isThumbFunction()145 bool isThumbFunction() const { return isThumb; } isThumb1OnlyFunction()146 bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; } isThumb2Function()147 bool isThumb2Function() const { return isThumb && hasThumb2; } 148 getStoredByValParamsPadding()149 unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; } setStoredByValParamsPadding(unsigned p)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 } setArgRegsSaveSize(unsigned s)157 void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = s; } 158 getReturnRegsCount()159 unsigned getReturnRegsCount() const { return ReturnRegsCount; } setReturnRegsCount(unsigned s)160 void setReturnRegsCount(unsigned s) { ReturnRegsCount = s; } 161 hasStackFrame()162 bool hasStackFrame() const { return HasStackFrame; } setHasStackFrame(bool s)163 void setHasStackFrame(bool s) { HasStackFrame = s; } 164 shouldRestoreSPFromFP()165 bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; } setShouldRestoreSPFromFP(bool s)166 void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; } 167 isLRSpilledForFarJump()168 bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; } setLRIsSpilledForFarJump(bool s)169 void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; } 170 getFramePtrSpillOffset()171 unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; } setFramePtrSpillOffset(unsigned o)172 void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; } 173 getNumAlignedDPRCS2Regs()174 unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; } setNumAlignedDPRCS2Regs(unsigned n)175 void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; } 176 getGPRCalleeSavedArea1Offset()177 unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; } getGPRCalleeSavedArea2Offset()178 unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; } getDPRCalleeSavedAreaOffset()179 unsigned getDPRCalleeSavedAreaOffset() const { return DPRCSOffset; } 180 setGPRCalleeSavedArea1Offset(unsigned o)181 void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; } setGPRCalleeSavedArea2Offset(unsigned o)182 void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; } setDPRCalleeSavedAreaOffset(unsigned o)183 void setDPRCalleeSavedAreaOffset(unsigned o) { DPRCSOffset = o; } 184 getGPRCalleeSavedArea1Size()185 unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; } getGPRCalleeSavedArea2Size()186 unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; } getDPRCalleeSavedGapSize()187 unsigned getDPRCalleeSavedGapSize() const { return DPRCSAlignGapSize; } getDPRCalleeSavedAreaSize()188 unsigned getDPRCalleeSavedAreaSize() const { return DPRCSSize; } 189 setGPRCalleeSavedArea1Size(unsigned s)190 void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; } setGPRCalleeSavedArea2Size(unsigned s)191 void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; } setDPRCalleeSavedGapSize(unsigned s)192 void setDPRCalleeSavedGapSize(unsigned s) { DPRCSAlignGapSize = s; } setDPRCalleeSavedAreaSize(unsigned s)193 void setDPRCalleeSavedAreaSize(unsigned s) { DPRCSSize = s; } 194 getArgumentStackSize()195 unsigned getArgumentStackSize() const { return ArgumentStackSize; } setArgumentStackSize(unsigned size)196 void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; } 197 createJumpTableUId()198 unsigned createJumpTableUId() { 199 return JumpTableUId++; 200 } 201 getNumJumpTables()202 unsigned getNumJumpTables() const { 203 return JumpTableUId; 204 } 205 initPICLabelUId(unsigned UId)206 void initPICLabelUId(unsigned UId) { 207 PICLabelUId = UId; 208 } 209 getNumPICLabels()210 unsigned getNumPICLabels() const { 211 return PICLabelUId; 212 } 213 createPICLabelUId()214 unsigned createPICLabelUId() { 215 return PICLabelUId++; 216 } 217 getVarArgsFrameIndex()218 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } setVarArgsFrameIndex(int Index)219 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } 220 hasITBlocks()221 bool hasITBlocks() const { return HasITBlocks; } setHasITBlocks(bool h)222 void setHasITBlocks(bool h) { HasITBlocks = h; } 223 getGlobalBaseReg()224 unsigned getGlobalBaseReg() const { return GlobalBaseReg; } setGlobalBaseReg(unsigned Reg)225 void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; } 226 recordCPEClone(unsigned CPIdx,unsigned CPCloneIdx)227 void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) { 228 if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second) 229 llvm_unreachable("Duplicate entries!"); 230 } 231 getOriginalCPIdx(unsigned CloneIdx)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 getCoalescedWeight(MachineBasicBlock * MBB)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 252