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