1 //===- ARMConstantPoolValue.h - ARM constantpool value ----------*- 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 implements the ARM specific constantpool value class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H 15 #define LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H 16 17 #include "llvm/ADT/SmallPtrSet.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/iterator_range.h" 20 #include "llvm/CodeGen/MachineConstantPool.h" 21 #include "llvm/Support/Casting.h" 22 #include <string> 23 #include <vector> 24 25 namespace llvm { 26 27 class BlockAddress; 28 class Constant; 29 class GlobalValue; 30 class GlobalVariable; 31 class LLVMContext; 32 class MachineBasicBlock; 33 class raw_ostream; 34 class Type; 35 36 namespace ARMCP { 37 38 enum ARMCPKind { 39 CPValue, 40 CPExtSymbol, 41 CPBlockAddress, 42 CPLSDA, 43 CPMachineBasicBlock, 44 CPPromotedGlobal 45 }; 46 47 enum ARMCPModifier { 48 no_modifier, /// None 49 TLSGD, /// Thread Local Storage (General Dynamic Mode) 50 GOT_PREL, /// Global Offset Table, PC Relative 51 GOTTPOFF, /// Global Offset Table, Thread Pointer Offset 52 TPOFF, /// Thread Pointer Offset 53 SECREL, /// Section Relative (Windows TLS) 54 SBREL, /// Static Base Relative (RWPI) 55 }; 56 57 } // end namespace ARMCP 58 59 /// ARMConstantPoolValue - ARM specific constantpool value. This is used to 60 /// represent PC-relative displacement between the address of the load 61 /// instruction and the constant being loaded, i.e. (&GV-(LPIC+8)). 62 class ARMConstantPoolValue : public MachineConstantPoolValue { 63 unsigned LabelId; // Label id of the load. 64 ARMCP::ARMCPKind Kind; // Kind of constant. 65 unsigned char PCAdjust; // Extra adjustment if constantpool is pc-relative. 66 // 8 for ARM, 4 for Thumb. 67 ARMCP::ARMCPModifier Modifier; // GV modifier i.e. (&GV(modifier)-(LPIC+8)) 68 bool AddCurrentAddress; 69 70 protected: 71 ARMConstantPoolValue(Type *Ty, unsigned id, ARMCP::ARMCPKind Kind, 72 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier, 73 bool AddCurrentAddress); 74 75 ARMConstantPoolValue(LLVMContext &C, unsigned id, ARMCP::ARMCPKind Kind, 76 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier, 77 bool AddCurrentAddress); 78 79 template <typename Derived> 80 int getExistingMachineCPValueImpl(MachineConstantPool *CP, 81 unsigned Alignment) { 82 unsigned AlignMask = Alignment - 1; 83 const std::vector<MachineConstantPoolEntry> &Constants = CP->getConstants(); 84 for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 85 if (Constants[i].isMachineConstantPoolEntry() && 86 (Constants[i].getAlignment() & AlignMask) == 0) { 87 auto *CPV = 88 static_cast<ARMConstantPoolValue*>(Constants[i].Val.MachineCPVal); 89 if (Derived *APC = dyn_cast<Derived>(CPV)) 90 if (cast<Derived>(this)->equals(APC)) 91 return i; 92 } 93 } 94 95 return -1; 96 } 97 98 public: 99 ~ARMConstantPoolValue() override; 100 101 ARMCP::ARMCPModifier getModifier() const { return Modifier; } 102 StringRef getModifierText() const; 103 bool hasModifier() const { return Modifier != ARMCP::no_modifier; } 104 105 bool mustAddCurrentAddress() const { return AddCurrentAddress; } 106 107 unsigned getLabelId() const { return LabelId; } 108 unsigned char getPCAdjustment() const { return PCAdjust; } 109 110 bool isGlobalValue() const { return Kind == ARMCP::CPValue; } 111 bool isExtSymbol() const { return Kind == ARMCP::CPExtSymbol; } 112 bool isBlockAddress() const { return Kind == ARMCP::CPBlockAddress; } 113 bool isLSDA() const { return Kind == ARMCP::CPLSDA; } 114 bool isMachineBasicBlock() const{ return Kind == ARMCP::CPMachineBasicBlock; } 115 bool isPromotedGlobal() const{ return Kind == ARMCP::CPPromotedGlobal; } 116 117 int getExistingMachineCPValue(MachineConstantPool *CP, 118 unsigned Alignment) override; 119 120 void addSelectionDAGCSEId(FoldingSetNodeID &ID) override; 121 122 /// hasSameValue - Return true if this ARM constpool value can share the same 123 /// constantpool entry as another ARM constpool value. 124 virtual bool hasSameValue(ARMConstantPoolValue *ACPV); 125 126 bool equals(const ARMConstantPoolValue *A) const { 127 return this->LabelId == A->LabelId && 128 this->PCAdjust == A->PCAdjust && 129 this->Modifier == A->Modifier; 130 } 131 132 void print(raw_ostream &O) const override; 133 void print(raw_ostream *O) const { if (O) print(*O); } 134 void dump() const; 135 }; 136 137 inline raw_ostream &operator<<(raw_ostream &O, const ARMConstantPoolValue &V) { 138 V.print(O); 139 return O; 140 } 141 142 /// ARMConstantPoolConstant - ARM-specific constant pool values for Constants, 143 /// Functions, and BlockAddresses. 144 class ARMConstantPoolConstant : public ARMConstantPoolValue { 145 const Constant *CVal; // Constant being loaded. 146 SmallPtrSet<const GlobalVariable*, 1> GVars; 147 148 ARMConstantPoolConstant(const Constant *C, 149 unsigned ID, 150 ARMCP::ARMCPKind Kind, 151 unsigned char PCAdj, 152 ARMCP::ARMCPModifier Modifier, 153 bool AddCurrentAddress); 154 ARMConstantPoolConstant(Type *Ty, const Constant *C, 155 unsigned ID, 156 ARMCP::ARMCPKind Kind, 157 unsigned char PCAdj, 158 ARMCP::ARMCPModifier Modifier, 159 bool AddCurrentAddress); 160 ARMConstantPoolConstant(const GlobalVariable *GV, const Constant *Init); 161 162 public: 163 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID); 164 static ARMConstantPoolConstant *Create(const GlobalValue *GV, 165 ARMCP::ARMCPModifier Modifier); 166 static ARMConstantPoolConstant *Create(const GlobalVariable *GV, 167 const Constant *Initializer); 168 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID, 169 ARMCP::ARMCPKind Kind, 170 unsigned char PCAdj); 171 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID, 172 ARMCP::ARMCPKind Kind, 173 unsigned char PCAdj, 174 ARMCP::ARMCPModifier Modifier, 175 bool AddCurrentAddress); 176 177 const GlobalValue *getGV() const; 178 const BlockAddress *getBlockAddress() const; 179 180 using promoted_iterator = SmallPtrSet<const GlobalVariable *, 1>::iterator; 181 182 iterator_range<promoted_iterator> promotedGlobals() { 183 return iterator_range<promoted_iterator>(GVars.begin(), GVars.end()); 184 } 185 186 const Constant *getPromotedGlobalInit() const { 187 return CVal; 188 } 189 190 int getExistingMachineCPValue(MachineConstantPool *CP, 191 unsigned Alignment) override; 192 193 /// hasSameValue - Return true if this ARM constpool value can share the same 194 /// constantpool entry as another ARM constpool value. 195 bool hasSameValue(ARMConstantPoolValue *ACPV) override; 196 197 void addSelectionDAGCSEId(FoldingSetNodeID &ID) override; 198 199 void print(raw_ostream &O) const override; 200 201 static bool classof(const ARMConstantPoolValue *APV) { 202 return APV->isGlobalValue() || APV->isBlockAddress() || APV->isLSDA() || 203 APV->isPromotedGlobal(); 204 } 205 206 bool equals(const ARMConstantPoolConstant *A) const { 207 return CVal == A->CVal && ARMConstantPoolValue::equals(A); 208 } 209 }; 210 211 /// ARMConstantPoolSymbol - ARM-specific constantpool values for external 212 /// symbols. 213 class ARMConstantPoolSymbol : public ARMConstantPoolValue { 214 const std::string S; // ExtSymbol being loaded. 215 216 ARMConstantPoolSymbol(LLVMContext &C, StringRef s, unsigned id, 217 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier, 218 bool AddCurrentAddress); 219 220 public: 221 static ARMConstantPoolSymbol *Create(LLVMContext &C, StringRef s, unsigned ID, 222 unsigned char PCAdj); 223 224 StringRef getSymbol() const { return S; } 225 226 int getExistingMachineCPValue(MachineConstantPool *CP, 227 unsigned Alignment) override; 228 229 void addSelectionDAGCSEId(FoldingSetNodeID &ID) override; 230 231 /// hasSameValue - Return true if this ARM constpool value can share the same 232 /// constantpool entry as another ARM constpool value. 233 bool hasSameValue(ARMConstantPoolValue *ACPV) override; 234 235 void print(raw_ostream &O) const override; 236 237 static bool classof(const ARMConstantPoolValue *ACPV) { 238 return ACPV->isExtSymbol(); 239 } 240 241 bool equals(const ARMConstantPoolSymbol *A) const { 242 return S == A->S && ARMConstantPoolValue::equals(A); 243 } 244 }; 245 246 /// ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic 247 /// block. 248 class ARMConstantPoolMBB : public ARMConstantPoolValue { 249 const MachineBasicBlock *MBB; // Machine basic block. 250 251 ARMConstantPoolMBB(LLVMContext &C, const MachineBasicBlock *mbb, unsigned id, 252 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier, 253 bool AddCurrentAddress); 254 255 public: 256 static ARMConstantPoolMBB *Create(LLVMContext &C, 257 const MachineBasicBlock *mbb, 258 unsigned ID, unsigned char PCAdj); 259 260 const MachineBasicBlock *getMBB() const { return MBB; } 261 262 int getExistingMachineCPValue(MachineConstantPool *CP, 263 unsigned Alignment) override; 264 265 void addSelectionDAGCSEId(FoldingSetNodeID &ID) override; 266 267 /// hasSameValue - Return true if this ARM constpool value can share the same 268 /// constantpool entry as another ARM constpool value. 269 bool hasSameValue(ARMConstantPoolValue *ACPV) override; 270 271 void print(raw_ostream &O) const override; 272 273 static bool classof(const ARMConstantPoolValue *ACPV) { 274 return ACPV->isMachineBasicBlock(); 275 } 276 277 bool equals(const ARMConstantPoolMBB *A) const { 278 return MBB == A->MBB && ARMConstantPoolValue::equals(A); 279 } 280 }; 281 282 } // end namespace llvm 283 284 #endif // LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H 285
