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 == 8, and GPRs-part-size mod 8 != 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 /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices 88 /// which belong to these spill areas. 89 BitVector GPRCS1Frames; 90 BitVector GPRCS2Frames; 91 BitVector DPRCSFrames; 92 93 /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in 94 /// the aligned portion of the stack frame. This is always a contiguous 95 /// sequence of D-registers starting from d8. 96 /// 97 /// We do not keep track of the frame indices used for these registers - they 98 /// behave like any other frame index in the aligned stack frame. These 99 /// registers also aren't included in DPRCSSize above. 100 unsigned NumAlignedDPRCS2Regs; 101 102 /// JumpTableUId - Unique id for jumptables. 103 /// 104 unsigned JumpTableUId; 105 106 unsigned PICLabelUId; 107 108 /// VarArgsFrameIndex - FrameIndex for start of varargs area. 109 int VarArgsFrameIndex; 110 111 /// HasITBlocks - True if IT blocks have been inserted. 112 bool HasITBlocks; 113 114 /// CPEClones - Track constant pool entries clones created by Constant Island 115 /// pass. 116 DenseMap<unsigned, unsigned> CPEClones; 117 118 /// GlobalBaseReg - keeps track of the virtual register initialized for 119 /// use as the global base register. This is used for PIC in some PIC 120 /// relocation models. 121 unsigned GlobalBaseReg; 122 123 public: 124 ARMFunctionInfo() : 125 isThumb(false), 126 hasThumb2(false), 127 ArgRegsSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false), 128 LRSpilledForFarJump(false), 129 FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0), 130 GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0), 131 GPRCS1Frames(0), GPRCS2Frames(0), DPRCSFrames(0), 132 NumAlignedDPRCS2Regs(0), 133 JumpTableUId(0), PICLabelUId(0), 134 VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {} 135 136 explicit ARMFunctionInfo(MachineFunction &MF) : 137 isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()), 138 hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()), 139 StByValParamsPadding(0), 140 ArgRegsSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false), 141 LRSpilledForFarJump(false), 142 FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0), 143 GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0), 144 GPRCS1Frames(32), GPRCS2Frames(32), DPRCSFrames(32), 145 JumpTableUId(0), PICLabelUId(0), 146 VarArgsFrameIndex(0), HasITBlocks(false), GlobalBaseReg(0) {} 147 148 bool isThumbFunction() const { return isThumb; } 149 bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; } 150 bool isThumb2Function() const { return isThumb && hasThumb2; } 151 152 unsigned getStoredByValParamsPadding() const { return StByValParamsPadding; } 153 void setStoredByValParamsPadding(unsigned p) { StByValParamsPadding = p; } 154 155 unsigned getArgRegsSaveSize(unsigned Align = 0) const { 156 if (!Align) 157 return ArgRegsSaveSize; 158 return (ArgRegsSaveSize + Align - 1) & ~(Align - 1); 159 } 160 void setArgRegsSaveSize(unsigned s) { ArgRegsSaveSize = 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 getDPRCalleeSavedAreaSize() const { return DPRCSSize; } 188 189 void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; } 190 void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; } 191 void setDPRCalleeSavedAreaSize(unsigned s) { DPRCSSize = s; } 192 193 bool isGPRCalleeSavedArea1Frame(int fi) const { 194 if (fi < 0 || fi >= (int)GPRCS1Frames.size()) 195 return false; 196 return GPRCS1Frames[fi]; 197 } 198 bool isGPRCalleeSavedArea2Frame(int fi) const { 199 if (fi < 0 || fi >= (int)GPRCS2Frames.size()) 200 return false; 201 return GPRCS2Frames[fi]; 202 } 203 bool isDPRCalleeSavedAreaFrame(int fi) const { 204 if (fi < 0 || fi >= (int)DPRCSFrames.size()) 205 return false; 206 return DPRCSFrames[fi]; 207 } 208 209 void addGPRCalleeSavedArea1Frame(int fi) { 210 if (fi >= 0) { 211 int Size = GPRCS1Frames.size(); 212 if (fi >= Size) { 213 Size *= 2; 214 if (fi >= Size) 215 Size = fi+1; 216 GPRCS1Frames.resize(Size); 217 } 218 GPRCS1Frames[fi] = true; 219 } 220 } 221 void addGPRCalleeSavedArea2Frame(int fi) { 222 if (fi >= 0) { 223 int Size = GPRCS2Frames.size(); 224 if (fi >= Size) { 225 Size *= 2; 226 if (fi >= Size) 227 Size = fi+1; 228 GPRCS2Frames.resize(Size); 229 } 230 GPRCS2Frames[fi] = true; 231 } 232 } 233 void addDPRCalleeSavedAreaFrame(int fi) { 234 if (fi >= 0) { 235 int Size = DPRCSFrames.size(); 236 if (fi >= Size) { 237 Size *= 2; 238 if (fi >= Size) 239 Size = fi+1; 240 DPRCSFrames.resize(Size); 241 } 242 DPRCSFrames[fi] = true; 243 } 244 } 245 246 unsigned createJumpTableUId() { 247 return JumpTableUId++; 248 } 249 250 unsigned getNumJumpTables() const { 251 return JumpTableUId; 252 } 253 254 void initPICLabelUId(unsigned UId) { 255 PICLabelUId = UId; 256 } 257 258 unsigned getNumPICLabels() const { 259 return PICLabelUId; 260 } 261 262 unsigned createPICLabelUId() { 263 return PICLabelUId++; 264 } 265 266 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } 267 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } 268 269 bool hasITBlocks() const { return HasITBlocks; } 270 void setHasITBlocks(bool h) { HasITBlocks = h; } 271 272 unsigned getGlobalBaseReg() const { return GlobalBaseReg; } 273 void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; } 274 275 void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) { 276 if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second) 277 assert(0 && "Duplicate entries!"); 278 } 279 280 unsigned getOriginalCPIdx(unsigned CloneIdx) const { 281 DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx); 282 if (I != CPEClones.end()) 283 return I->second; 284 else 285 return -1U; 286 } 287 }; 288 } // End llvm namespace 289 290 #endif // ARMMACHINEFUNCTIONINFO_H 291
