Line data Source code
1 : //===- ARMConstantPoolValue.cpp - ARM constantpool value ------------------===//
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 : #include "ARMConstantPoolValue.h"
15 : #include "llvm/ADT/FoldingSet.h"
16 : #include "llvm/CodeGen/MachineBasicBlock.h"
17 : #include "llvm/Config/llvm-config.h"
18 : #include "llvm/IR/Constant.h"
19 : #include "llvm/IR/Constants.h"
20 : #include "llvm/IR/GlobalValue.h"
21 : #include "llvm/IR/Type.h"
22 : #include "llvm/Support/Casting.h"
23 : #include "llvm/Support/Compiler.h"
24 : #include "llvm/Support/ErrorHandling.h"
25 : #include "llvm/Support/raw_ostream.h"
26 :
27 : using namespace llvm;
28 :
29 : //===----------------------------------------------------------------------===//
30 : // ARMConstantPoolValue
31 : //===----------------------------------------------------------------------===//
32 :
33 614 : ARMConstantPoolValue::ARMConstantPoolValue(Type *Ty, unsigned id,
34 : ARMCP::ARMCPKind kind,
35 : unsigned char PCAdj,
36 : ARMCP::ARMCPModifier modifier,
37 614 : bool addCurrentAddress)
38 : : MachineConstantPoolValue(Ty), LabelId(id), Kind(kind),
39 : PCAdjust(PCAdj), Modifier(modifier),
40 614 : AddCurrentAddress(addCurrentAddress) {}
41 :
42 67 : ARMConstantPoolValue::ARMConstantPoolValue(LLVMContext &C, unsigned id,
43 : ARMCP::ARMCPKind kind,
44 : unsigned char PCAdj,
45 : ARMCP::ARMCPModifier modifier,
46 67 : bool addCurrentAddress)
47 67 : : MachineConstantPoolValue((Type*)Type::getInt32Ty(C)),
48 : LabelId(id), Kind(kind), PCAdjust(PCAdj), Modifier(modifier),
49 67 : AddCurrentAddress(addCurrentAddress) {}
50 :
51 : ARMConstantPoolValue::~ARMConstantPoolValue() = default;
52 :
53 4 : StringRef ARMConstantPoolValue::getModifierText() const {
54 4 : switch (Modifier) {
55 : // FIXME: Are these case sensitive? It'd be nice to lower-case all the
56 : // strings if that's legal.
57 : case ARMCP::no_modifier:
58 0 : return "none";
59 : case ARMCP::TLSGD:
60 0 : return "tlsgd";
61 : case ARMCP::GOT_PREL:
62 0 : return "GOT_PREL";
63 : case ARMCP::GOTTPOFF:
64 0 : return "gottpoff";
65 : case ARMCP::TPOFF:
66 0 : return "tpoff";
67 : case ARMCP::SBREL:
68 4 : return "SBREL";
69 : case ARMCP::SECREL:
70 0 : return "secrel32";
71 : }
72 0 : llvm_unreachable("Unknown modifier!");
73 : }
74 :
75 0 : int ARMConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
76 : unsigned Alignment) {
77 0 : llvm_unreachable("Shouldn't be calling this directly!");
78 : }
79 :
80 : void
81 294 : ARMConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
82 294 : ID.AddInteger(LabelId);
83 294 : ID.AddInteger(PCAdjust);
84 294 : }
85 :
86 : bool
87 1 : ARMConstantPoolValue::hasSameValue(ARMConstantPoolValue *ACPV) {
88 1 : if (ACPV->Kind == Kind &&
89 1 : ACPV->PCAdjust == PCAdjust &&
90 1 : ACPV->Modifier == Modifier &&
91 1 : ACPV->LabelId == LabelId &&
92 0 : ACPV->AddCurrentAddress == AddCurrentAddress) {
93 : // Two PC relative constpool entries containing the same GV address or
94 : // external symbols. FIXME: What about blockaddress?
95 0 : if (Kind == ARMCP::CPValue || Kind == ARMCP::CPExtSymbol)
96 0 : return true;
97 : }
98 : return false;
99 : }
100 :
101 : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
102 : LLVM_DUMP_METHOD void ARMConstantPoolValue::dump() const {
103 : errs() << " " << *this;
104 : }
105 : #endif
106 :
107 6 : void ARMConstantPoolValue::print(raw_ostream &O) const {
108 6 : if (Modifier) O << "(" << getModifierText() << ")";
109 6 : if (PCAdjust != 0) {
110 2 : O << "-(LPC" << LabelId << "+" << (unsigned)PCAdjust;
111 2 : if (AddCurrentAddress) O << "-.";
112 2 : O << ")";
113 : }
114 6 : }
115 :
116 : //===----------------------------------------------------------------------===//
117 : // ARMConstantPoolConstant
118 : //===----------------------------------------------------------------------===//
119 :
120 91 : ARMConstantPoolConstant::ARMConstantPoolConstant(Type *Ty,
121 : const Constant *C,
122 : unsigned ID,
123 : ARMCP::ARMCPKind Kind,
124 : unsigned char PCAdj,
125 : ARMCP::ARMCPModifier Modifier,
126 91 : bool AddCurrentAddress)
127 : : ARMConstantPoolValue(Ty, ID, Kind, PCAdj, Modifier, AddCurrentAddress),
128 91 : CVal(C) {}
129 :
130 437 : ARMConstantPoolConstant::ARMConstantPoolConstant(const Constant *C,
131 : unsigned ID,
132 : ARMCP::ARMCPKind Kind,
133 : unsigned char PCAdj,
134 : ARMCP::ARMCPModifier Modifier,
135 437 : bool AddCurrentAddress)
136 : : ARMConstantPoolValue((Type*)C->getType(), ID, Kind, PCAdj, Modifier,
137 : AddCurrentAddress),
138 437 : CVal(C) {}
139 :
140 86 : ARMConstantPoolConstant::ARMConstantPoolConstant(const GlobalVariable *GV,
141 86 : const Constant *C)
142 : : ARMConstantPoolValue((Type *)C->getType(), 0, ARMCP::CPPromotedGlobal, 0,
143 86 : ARMCP::no_modifier, false), CVal(C) {
144 86 : GVars.insert(GV);
145 86 : }
146 :
147 : ARMConstantPoolConstant *
148 0 : ARMConstantPoolConstant::Create(const Constant *C, unsigned ID) {
149 : return new ARMConstantPoolConstant(C, ID, ARMCP::CPValue, 0,
150 0 : ARMCP::no_modifier, false);
151 : }
152 :
153 : ARMConstantPoolConstant *
154 86 : ARMConstantPoolConstant::Create(const GlobalVariable *GVar,
155 : const Constant *Initializer) {
156 86 : return new ARMConstantPoolConstant(GVar, Initializer);
157 : }
158 :
159 : ARMConstantPoolConstant *
160 91 : ARMConstantPoolConstant::Create(const GlobalValue *GV,
161 : ARMCP::ARMCPModifier Modifier) {
162 91 : return new ARMConstantPoolConstant((Type*)Type::getInt32Ty(GV->getContext()),
163 : GV, 0, ARMCP::CPValue, 0,
164 91 : Modifier, false);
165 : }
166 :
167 : ARMConstantPoolConstant *
168 59 : ARMConstantPoolConstant::Create(const Constant *C, unsigned ID,
169 : ARMCP::ARMCPKind Kind, unsigned char PCAdj) {
170 : return new ARMConstantPoolConstant(C, ID, Kind, PCAdj,
171 59 : ARMCP::no_modifier, false);
172 : }
173 :
174 : ARMConstantPoolConstant *
175 378 : ARMConstantPoolConstant::Create(const Constant *C, unsigned ID,
176 : ARMCP::ARMCPKind Kind, unsigned char PCAdj,
177 : ARMCP::ARMCPModifier Modifier,
178 : bool AddCurrentAddress) {
179 : return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, Modifier,
180 378 : AddCurrentAddress);
181 : }
182 :
183 468 : const GlobalValue *ARMConstantPoolConstant::getGV() const {
184 468 : return dyn_cast_or_null<GlobalValue>(CVal);
185 : }
186 :
187 18 : const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const {
188 18 : return dyn_cast_or_null<BlockAddress>(CVal);
189 : }
190 :
191 618 : int ARMConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
192 : unsigned Alignment) {
193 : int index =
194 618 : getExistingMachineCPValueImpl<ARMConstantPoolConstant>(CP, Alignment);
195 618 : if (index != -1) {
196 : auto *CPV = static_cast<ARMConstantPoolValue*>(
197 11 : CP->getConstants()[index].Val.MachineCPVal);
198 : auto *Constant = cast<ARMConstantPoolConstant>(CPV);
199 11 : Constant->GVars.insert(GVars.begin(), GVars.end());
200 : }
201 618 : return index;
202 : }
203 :
204 1 : bool ARMConstantPoolConstant::hasSameValue(ARMConstantPoolValue *ACPV) {
205 : const ARMConstantPoolConstant *ACPC = dyn_cast<ARMConstantPoolConstant>(ACPV);
206 1 : return ACPC && ACPC->CVal == CVal && ARMConstantPoolValue::hasSameValue(ACPV);
207 : }
208 :
209 284 : void ARMConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
210 284 : ID.AddPointer(CVal);
211 374 : for (const auto *GV : GVars)
212 90 : ID.AddPointer(GV);
213 284 : ARMConstantPoolValue::addSelectionDAGCSEId(ID);
214 284 : }
215 :
216 6 : void ARMConstantPoolConstant::print(raw_ostream &O) const {
217 6 : O << CVal->getName();
218 6 : ARMConstantPoolValue::print(O);
219 6 : }
220 :
221 : //===----------------------------------------------------------------------===//
222 : // ARMConstantPoolSymbol
223 : //===----------------------------------------------------------------------===//
224 :
225 35 : ARMConstantPoolSymbol::ARMConstantPoolSymbol(LLVMContext &C, StringRef s,
226 : unsigned id, unsigned char PCAdj,
227 : ARMCP::ARMCPModifier Modifier,
228 35 : bool AddCurrentAddress)
229 : : ARMConstantPoolValue(C, id, ARMCP::CPExtSymbol, PCAdj, Modifier,
230 : AddCurrentAddress),
231 35 : S(s) {}
232 :
233 35 : ARMConstantPoolSymbol *ARMConstantPoolSymbol::Create(LLVMContext &C,
234 : StringRef s, unsigned ID,
235 : unsigned char PCAdj) {
236 35 : return new ARMConstantPoolSymbol(C, s, ID, PCAdj, ARMCP::no_modifier, false);
237 : }
238 :
239 35 : int ARMConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
240 : unsigned Alignment) {
241 35 : return getExistingMachineCPValueImpl<ARMConstantPoolSymbol>(CP, Alignment);
242 : }
243 :
244 0 : bool ARMConstantPoolSymbol::hasSameValue(ARMConstantPoolValue *ACPV) {
245 : const ARMConstantPoolSymbol *ACPS = dyn_cast<ARMConstantPoolSymbol>(ACPV);
246 0 : return ACPS && ACPS->S == S && ARMConstantPoolValue::hasSameValue(ACPV);
247 : }
248 :
249 10 : void ARMConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
250 10 : ID.AddString(S);
251 10 : ARMConstantPoolValue::addSelectionDAGCSEId(ID);
252 10 : }
253 :
254 0 : void ARMConstantPoolSymbol::print(raw_ostream &O) const {
255 : O << S;
256 0 : ARMConstantPoolValue::print(O);
257 0 : }
258 :
259 : //===----------------------------------------------------------------------===//
260 : // ARMConstantPoolMBB
261 : //===----------------------------------------------------------------------===//
262 :
263 32 : ARMConstantPoolMBB::ARMConstantPoolMBB(LLVMContext &C,
264 : const MachineBasicBlock *mbb,
265 : unsigned id, unsigned char PCAdj,
266 : ARMCP::ARMCPModifier Modifier,
267 32 : bool AddCurrentAddress)
268 : : ARMConstantPoolValue(C, id, ARMCP::CPMachineBasicBlock, PCAdj,
269 : Modifier, AddCurrentAddress),
270 32 : MBB(mbb) {}
271 :
272 32 : ARMConstantPoolMBB *ARMConstantPoolMBB::Create(LLVMContext &C,
273 : const MachineBasicBlock *mbb,
274 : unsigned ID,
275 : unsigned char PCAdj) {
276 32 : return new ARMConstantPoolMBB(C, mbb, ID, PCAdj, ARMCP::no_modifier, false);
277 : }
278 :
279 32 : int ARMConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
280 : unsigned Alignment) {
281 32 : return getExistingMachineCPValueImpl<ARMConstantPoolMBB>(CP, Alignment);
282 : }
283 :
284 0 : bool ARMConstantPoolMBB::hasSameValue(ARMConstantPoolValue *ACPV) {
285 : const ARMConstantPoolMBB *ACPMBB = dyn_cast<ARMConstantPoolMBB>(ACPV);
286 0 : return ACPMBB && ACPMBB->MBB == MBB &&
287 0 : ARMConstantPoolValue::hasSameValue(ACPV);
288 : }
289 :
290 0 : void ARMConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
291 0 : ID.AddPointer(MBB);
292 0 : ARMConstantPoolValue::addSelectionDAGCSEId(ID);
293 0 : }
294 :
295 0 : void ARMConstantPoolMBB::print(raw_ostream &O) const {
296 0 : O << printMBBReference(*MBB);
297 0 : ARMConstantPoolValue::print(O);
298 0 : }
|
