LLVM 17.0.0git
ARMConstantPoolValue.h
Go to the documentation of this file.
1//===- ARMConstantPoolValue.h - ARM constantpool value ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the ARM specific constantpool value class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H
14#define LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H
15
17#include "llvm/ADT/StringRef.h"
21#include <string>
22#include <vector>
23
24namespace llvm {
25
26class BlockAddress;
27class Constant;
28class GlobalValue;
29class GlobalVariable;
30class LLVMContext;
31class MachineBasicBlock;
32class raw_ostream;
33class Type;
34
35namespace ARMCP {
36
37 enum ARMCPKind {
44 };
45
47 no_modifier, /// None
48 TLSGD, /// Thread Local Storage (General Dynamic Mode)
49 GOT_PREL, /// Global Offset Table, PC Relative
50 GOTTPOFF, /// Global Offset Table, Thread Pointer Offset
51 TPOFF, /// Thread Pointer Offset
52 SECREL, /// Section Relative (Windows TLS)
53 SBREL, /// Static Base Relative (RWPI)
54 };
55
56} // end namespace ARMCP
57
58/// ARMConstantPoolValue - ARM specific constantpool value. This is used to
59/// represent PC-relative displacement between the address of the load
60/// instruction and the constant being loaded, i.e. (&GV-(LPIC+8)).
62 unsigned LabelId; // Label id of the load.
63 ARMCP::ARMCPKind Kind; // Kind of constant.
64 unsigned char PCAdjust; // Extra adjustment if constantpool is pc-relative.
65 // 8 for ARM, 4 for Thumb.
66 ARMCP::ARMCPModifier Modifier; // GV modifier i.e. (&GV(modifier)-(LPIC+8))
67 bool AddCurrentAddress;
68
69protected:
70 ARMConstantPoolValue(Type *Ty, unsigned id, ARMCP::ARMCPKind Kind,
71 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
72 bool AddCurrentAddress);
73
75 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
76 bool AddCurrentAddress);
77
78 template <typename Derived>
80 const std::vector<MachineConstantPoolEntry> &Constants = CP->getConstants();
81 for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
82 if (Constants[i].isMachineConstantPoolEntry() &&
83 Constants[i].getAlign() >= Alignment) {
84 auto *CPV =
85 static_cast<ARMConstantPoolValue*>(Constants[i].Val.MachineCPVal);
86 if (Derived *APC = dyn_cast<Derived>(CPV))
87 if (cast<Derived>(this)->equals(APC))
88 return i;
89 }
90 }
91
92 return -1;
93 }
94
95public:
97
98 ARMCP::ARMCPModifier getModifier() const { return Modifier; }
100 bool hasModifier() const { return Modifier != ARMCP::no_modifier; }
101
102 bool mustAddCurrentAddress() const { return AddCurrentAddress; }
103
104 unsigned getLabelId() const { return LabelId; }
105 unsigned char getPCAdjustment() const { return PCAdjust; }
106
107 bool isGlobalValue() const { return Kind == ARMCP::CPValue; }
108 bool isExtSymbol() const { return Kind == ARMCP::CPExtSymbol; }
109 bool isBlockAddress() const { return Kind == ARMCP::CPBlockAddress; }
110 bool isLSDA() const { return Kind == ARMCP::CPLSDA; }
111 bool isMachineBasicBlock() const{ return Kind == ARMCP::CPMachineBasicBlock; }
112 bool isPromotedGlobal() const{ return Kind == ARMCP::CPPromotedGlobal; }
113
115 Align Alignment) override;
116
118
119 /// hasSameValue - Return true if this ARM constpool value can share the same
120 /// constantpool entry as another ARM constpool value.
121 virtual bool hasSameValue(ARMConstantPoolValue *ACPV);
122
123 bool equals(const ARMConstantPoolValue *A) const {
124 return this->LabelId == A->LabelId &&
125 this->PCAdjust == A->PCAdjust &&
126 this->Modifier == A->Modifier;
127 }
128
129 void print(raw_ostream &O) const override;
130 void print(raw_ostream *O) const { if (O) print(*O); }
131 void dump() const;
132};
133
135 V.print(O);
136 return O;
137}
138
139/// ARMConstantPoolConstant - ARM-specific constant pool values for Constants,
140/// Functions, and BlockAddresses.
142 const Constant *CVal; // Constant being loaded.
144
146 unsigned ID,
147 ARMCP::ARMCPKind Kind,
148 unsigned char PCAdj,
149 ARMCP::ARMCPModifier Modifier,
150 bool AddCurrentAddress);
152 unsigned ID,
153 ARMCP::ARMCPKind Kind,
154 unsigned char PCAdj,
155 ARMCP::ARMCPModifier Modifier,
156 bool AddCurrentAddress);
158
159public:
160 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID);
162 ARMCP::ARMCPModifier Modifier);
164 const Constant *Initializer);
165 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
166 ARMCP::ARMCPKind Kind,
167 unsigned char PCAdj);
168 static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
169 ARMCP::ARMCPKind Kind,
170 unsigned char PCAdj,
171 ARMCP::ARMCPModifier Modifier,
172 bool AddCurrentAddress);
173
174 const GlobalValue *getGV() const;
175 const BlockAddress *getBlockAddress() const;
176
178
180 return iterator_range<promoted_iterator>(GVars.begin(), GVars.end());
181 }
182
184 return CVal;
185 }
186
188 Align Alignment) override;
189
190 /// hasSameValue - Return true if this ARM constpool value can share the same
191 /// constantpool entry as another ARM constpool value.
192 bool hasSameValue(ARMConstantPoolValue *ACPV) override;
193
195
196 void print(raw_ostream &O) const override;
197
198 static bool classof(const ARMConstantPoolValue *APV) {
199 return APV->isGlobalValue() || APV->isBlockAddress() || APV->isLSDA() ||
200 APV->isPromotedGlobal();
201 }
202
203 bool equals(const ARMConstantPoolConstant *A) const {
204 return CVal == A->CVal && ARMConstantPoolValue::equals(A);
205 }
206};
207
208/// ARMConstantPoolSymbol - ARM-specific constantpool values for external
209/// symbols.
211 const std::string S; // ExtSymbol being loaded.
212
214 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
215 bool AddCurrentAddress);
216
217public:
219 unsigned char PCAdj);
220
221 StringRef getSymbol() const { return S; }
222
224 Align Alignment) override;
225
227
228 /// hasSameValue - Return true if this ARM constpool value can share the same
229 /// constantpool entry as another ARM constpool value.
230 bool hasSameValue(ARMConstantPoolValue *ACPV) override;
231
232 void print(raw_ostream &O) const override;
233
234 static bool classof(const ARMConstantPoolValue *ACPV) {
235 return ACPV->isExtSymbol();
236 }
237
238 bool equals(const ARMConstantPoolSymbol *A) const {
239 return S == A->S && ARMConstantPoolValue::equals(A);
240 }
241};
242
243/// ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic
244/// block.
246 const MachineBasicBlock *MBB; // Machine basic block.
247
248 ARMConstantPoolMBB(LLVMContext &C, const MachineBasicBlock *mbb, unsigned id,
249 unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
250 bool AddCurrentAddress);
251
252public:
254 const MachineBasicBlock *mbb,
255 unsigned ID, unsigned char PCAdj);
256
257 const MachineBasicBlock *getMBB() const { return MBB; }
258
260 Align Alignment) override;
261
263
264 /// hasSameValue - Return true if this ARM constpool value can share the same
265 /// constantpool entry as another ARM constpool value.
266 bool hasSameValue(ARMConstantPoolValue *ACPV) override;
267
268 void print(raw_ostream &O) const override;
269
270 static bool classof(const ARMConstantPoolValue *ACPV) {
271 return ACPV->isMachineBasicBlock();
272 }
273
274 bool equals(const ARMConstantPoolMBB *A) const {
275 return MBB == A->MBB && ARMConstantPoolValue::equals(A);
276 }
277};
278
279} // end namespace llvm
280
281#endif // LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H
MachineBasicBlock & MBB
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
RelocType Type
Definition: COFFYAML.cpp:390
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
This file defines the SmallPtrSet class.
ARMConstantPoolConstant - ARM-specific constant pool values for Constants, Functions,...
const GlobalValue * getGV() const
bool equals(const ARMConstantPoolConstant *A) const
static bool classof(const ARMConstantPoolValue *APV)
static ARMConstantPoolConstant * Create(const Constant *C, unsigned ID)
iterator_range< promoted_iterator > promotedGlobals()
const Constant * getPromotedGlobalInit() const
bool hasSameValue(ARMConstantPoolValue *ACPV) override
hasSameValue - Return true if this ARM constpool value can share the same constantpool entry as anoth...
void print(raw_ostream &O) const override
print - Implement operator<<
const BlockAddress * getBlockAddress() const
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic block.
bool equals(const ARMConstantPoolMBB *A) const
const MachineBasicBlock * getMBB() const
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
static ARMConstantPoolMBB * Create(LLVMContext &C, const MachineBasicBlock *mbb, unsigned ID, unsigned char PCAdj)
bool hasSameValue(ARMConstantPoolValue *ACPV) override
hasSameValue - Return true if this ARM constpool value can share the same constantpool entry as anoth...
void print(raw_ostream &O) const override
print - Implement operator<<
static bool classof(const ARMConstantPoolValue *ACPV)
ARMConstantPoolSymbol - ARM-specific constantpool values for external symbols.
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
bool hasSameValue(ARMConstantPoolValue *ACPV) override
hasSameValue - Return true if this ARM constpool value can share the same constantpool entry as anoth...
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
void print(raw_ostream &O) const override
print - Implement operator<<
static ARMConstantPoolSymbol * Create(LLVMContext &C, StringRef s, unsigned ID, unsigned char PCAdj)
static bool classof(const ARMConstantPoolValue *ACPV)
bool equals(const ARMConstantPoolSymbol *A) const
ARMConstantPoolValue - ARM specific constantpool value.
unsigned char getPCAdjustment() const
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
void print(raw_ostream *O) const
void print(raw_ostream &O) const override
print - Implement operator<<
int getExistingMachineCPValueImpl(MachineConstantPool *CP, Align Alignment)
bool equals(const ARMConstantPoolValue *A) const
ARMCP::ARMCPModifier getModifier() const
virtual bool hasSameValue(ARMConstantPoolValue *ACPV)
hasSameValue - Return true if this ARM constpool value can share the same constantpool entry as anoth...
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
The address of a basic block.
Definition: Constants.h:875
This is an important base class in LLVM.
Definition: Constant.h:41
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:318
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
Abstract base class for all machine specific constantpool value subclasses.
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
iterator end() const
Definition: SmallPtrSet.h:408
iterator begin() const
Definition: SmallPtrSet.h:403
SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
Definition: SmallPtrSet.h:268
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
@ SECREL
Thread Pointer Offset.
@ GOT_PREL
Thread Local Storage (General Dynamic Mode)
@ SBREL
Section Relative (Windows TLS)
@ GOTTPOFF
Global Offset Table, PC Relative.
@ TPOFF
Global Offset Table, Thread Pointer Offset.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ BlockAddress
Definition: ISDOpcodes.h:84
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool getAlign(const Function &F, unsigned index, unsigned &align)
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39