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/CodeGen/MachineFunction.h" 19 #include "llvm/Target/TargetRegisterInfo.h" 20 #include "llvm/Target/TargetMachine.h" 21 #include "llvm/ADT/BitVector.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 /// VarArgsRegSaveSize - Size of the register save area for vararg functions. 40 /// 41 unsigned VarArgsRegSaveSize; 42 43 /// HasStackFrame - True if this function has a stack frame. Set by 44 /// processFunctionBeforeCalleeSavedScan(). 45 bool HasStackFrame; 46 47 /// RestoreSPFromFP - True if epilogue should restore SP from FP. Set by 48 /// emitPrologue. 49 bool RestoreSPFromFP; 50 51 /// LRSpilledForFarJump - True if the LR register has been for spilled to 52 /// enable far jump. 53 bool LRSpilledForFarJump; 54 55 /// FramePtrSpillOffset - If HasStackFrame, this records the frame pointer 56 /// spill stack offset. 57 unsigned FramePtrSpillOffset; 58 59 /// GPRCS1Offset, GPRCS2Offset, DPRCSOffset - Starting offset of callee saved 60 /// register spills areas. For Mac OS X: 61 /// 62 /// GPR callee-saved (1) : r4, r5, r6, r7, lr 63 /// -------------------------------------------- 64 /// GPR callee-saved (2) : r8, r10, r11 65 /// -------------------------------------------- 66 /// DPR callee-saved : d8 - d15 67 /// 68 /// Also see AlignedDPRCSRegs below. Not all D-regs need to go in area 3. 69 /// Some may be spilled after the stack has been realigned. 70 unsigned GPRCS1Offset; 71 unsigned GPRCS2Offset; 72 unsigned DPRCSOffset; 73 74 /// GPRCS1Size, GPRCS2Size, DPRCSSize - Sizes of callee saved register spills 75 /// areas. 76 unsigned GPRCS1Size; 77 unsigned GPRCS2Size; 78 unsigned DPRCSSize; 79 80 /// GPRCS1Frames, GPRCS2Frames, DPRCSFrames - Keeps track of frame indices 81 /// which belong to these spill areas. 82 BitVector GPRCS1Frames; 83 BitVector GPRCS2Frames; 84 BitVector DPRCSFrames; 85 86 /// NumAlignedDPRCS2Regs - The number of callee-saved DPRs that are saved in 87 /// the aligned portion of the stack frame. This is always a contiguous 88 /// sequence of D-registers starting from d8. 89 /// 90 /// We do not keep track of the frame indices used for these registers - they 91 /// behave like any other frame index in the aligned stack frame. These 92 /// registers also aren't included in DPRCSSize above. 93 unsigned NumAlignedDPRCS2Regs; 94 95 /// JumpTableUId - Unique id for jumptables. 96 /// 97 unsigned JumpTableUId; 98 99 unsigned PICLabelUId; 100 101 /// VarArgsFrameIndex - FrameIndex for start of varargs area. 102 int VarArgsFrameIndex; 103 104 /// HasITBlocks - True if IT blocks have been inserted. 105 bool HasITBlocks; 106 107 /// CPEClones - Track constant pool entries clones created by Constant Island 108 /// pass. 109 DenseMap<unsigned, unsigned> CPEClones; 110 111 public: 112 ARMFunctionInfo() : 113 isThumb(false), 114 hasThumb2(false), 115 VarArgsRegSaveSize(0), HasStackFrame(false), RestoreSPFromFP(false), 116 LRSpilledForFarJump(false), 117 FramePtrSpillOffset(0), GPRCS1Offset(0), GPRCS2Offset(0), DPRCSOffset(0), 118 GPRCS1Size(0), GPRCS2Size(0), DPRCSSize(0), 119 GPRCS1Frames(0), GPRCS2Frames(0), DPRCSFrames(0), 120 NumAlignedDPRCS2Regs(0), 121 JumpTableUId(0), PICLabelUId(0), 122 VarArgsFrameIndex(0), HasITBlocks(false) {} 123 124 explicit ARMFunctionInfo(MachineFunction &MF) : 125 isThumb(MF.getTarget().getSubtarget<ARMSubtarget>().isThumb()), 126 hasThumb2(MF.getTarget().getSubtarget<ARMSubtarget>().hasThumb2()), 127 VarArgsRegSaveSize(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(32), GPRCS2Frames(32), DPRCSFrames(32), 132 JumpTableUId(0), PICLabelUId(0), 133 VarArgsFrameIndex(0), HasITBlocks(false) {} 134 135 bool isThumbFunction() const { return isThumb; } 136 bool isThumb1OnlyFunction() const { return isThumb && !hasThumb2; } 137 bool isThumb2Function() const { return isThumb && hasThumb2; } 138 139 unsigned getVarArgsRegSaveSize() const { return VarArgsRegSaveSize; } 140 void setVarArgsRegSaveSize(unsigned s) { VarArgsRegSaveSize = s; } 141 142 bool hasStackFrame() const { return HasStackFrame; } 143 void setHasStackFrame(bool s) { HasStackFrame = s; } 144 145 bool shouldRestoreSPFromFP() const { return RestoreSPFromFP; } 146 void setShouldRestoreSPFromFP(bool s) { RestoreSPFromFP = s; } 147 148 bool isLRSpilledForFarJump() const { return LRSpilledForFarJump; } 149 void setLRIsSpilledForFarJump(bool s) { LRSpilledForFarJump = s; } 150 151 unsigned getFramePtrSpillOffset() const { return FramePtrSpillOffset; } 152 void setFramePtrSpillOffset(unsigned o) { FramePtrSpillOffset = o; } 153 154 unsigned getNumAlignedDPRCS2Regs() const { return NumAlignedDPRCS2Regs; } 155 void setNumAlignedDPRCS2Regs(unsigned n) { NumAlignedDPRCS2Regs = n; } 156 157 unsigned getGPRCalleeSavedArea1Offset() const { return GPRCS1Offset; } 158 unsigned getGPRCalleeSavedArea2Offset() const { return GPRCS2Offset; } 159 unsigned getDPRCalleeSavedAreaOffset() const { return DPRCSOffset; } 160 161 void setGPRCalleeSavedArea1Offset(unsigned o) { GPRCS1Offset = o; } 162 void setGPRCalleeSavedArea2Offset(unsigned o) { GPRCS2Offset = o; } 163 void setDPRCalleeSavedAreaOffset(unsigned o) { DPRCSOffset = o; } 164 165 unsigned getGPRCalleeSavedArea1Size() const { return GPRCS1Size; } 166 unsigned getGPRCalleeSavedArea2Size() const { return GPRCS2Size; } 167 unsigned getDPRCalleeSavedAreaSize() const { return DPRCSSize; } 168 169 void setGPRCalleeSavedArea1Size(unsigned s) { GPRCS1Size = s; } 170 void setGPRCalleeSavedArea2Size(unsigned s) { GPRCS2Size = s; } 171 void setDPRCalleeSavedAreaSize(unsigned s) { DPRCSSize = s; } 172 173 bool isGPRCalleeSavedArea1Frame(int fi) const { 174 if (fi < 0 || fi >= (int)GPRCS1Frames.size()) 175 return false; 176 return GPRCS1Frames[fi]; 177 } 178 bool isGPRCalleeSavedArea2Frame(int fi) const { 179 if (fi < 0 || fi >= (int)GPRCS2Frames.size()) 180 return false; 181 return GPRCS2Frames[fi]; 182 } 183 bool isDPRCalleeSavedAreaFrame(int fi) const { 184 if (fi < 0 || fi >= (int)DPRCSFrames.size()) 185 return false; 186 return DPRCSFrames[fi]; 187 } 188 189 void addGPRCalleeSavedArea1Frame(int fi) { 190 if (fi >= 0) { 191 int Size = GPRCS1Frames.size(); 192 if (fi >= Size) { 193 Size *= 2; 194 if (fi >= Size) 195 Size = fi+1; 196 GPRCS1Frames.resize(Size); 197 } 198 GPRCS1Frames[fi] = true; 199 } 200 } 201 void addGPRCalleeSavedArea2Frame(int fi) { 202 if (fi >= 0) { 203 int Size = GPRCS2Frames.size(); 204 if (fi >= Size) { 205 Size *= 2; 206 if (fi >= Size) 207 Size = fi+1; 208 GPRCS2Frames.resize(Size); 209 } 210 GPRCS2Frames[fi] = true; 211 } 212 } 213 void addDPRCalleeSavedAreaFrame(int fi) { 214 if (fi >= 0) { 215 int Size = DPRCSFrames.size(); 216 if (fi >= Size) { 217 Size *= 2; 218 if (fi >= Size) 219 Size = fi+1; 220 DPRCSFrames.resize(Size); 221 } 222 DPRCSFrames[fi] = true; 223 } 224 } 225 226 unsigned createJumpTableUId() { 227 return JumpTableUId++; 228 } 229 230 unsigned getNumJumpTables() const { 231 return JumpTableUId; 232 } 233 234 void initPICLabelUId(unsigned UId) { 235 PICLabelUId = UId; 236 } 237 238 unsigned getNumPICLabels() const { 239 return PICLabelUId; 240 } 241 242 unsigned createPICLabelUId() { 243 return PICLabelUId++; 244 } 245 246 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } 247 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } 248 249 bool hasITBlocks() const { return HasITBlocks; } 250 void setHasITBlocks(bool h) { HasITBlocks = h; } 251 252 void recordCPEClone(unsigned CPIdx, unsigned CPCloneIdx) { 253 if (!CPEClones.insert(std::make_pair(CPCloneIdx, CPIdx)).second) 254 assert(0 && "Duplicate entries!"); 255 } 256 257 unsigned getOriginalCPIdx(unsigned CloneIdx) const { 258 DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx); 259 if (I != CPEClones.end()) 260 return I->second; 261 else 262 return -1U; 263 } 264 }; 265 } // End llvm namespace 266 267 #endif // ARMMACHINEFUNCTIONINFO_H 268
