LLVM 20.0.0git
LLVMContextImpl.cpp
Go to the documentation of this file.
1//===- LLVMContextImpl.cpp - Implement LLVMContextImpl --------------------===//
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 opaque LLVMContextImpl.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LLVMContextImpl.h"
14#include "AttributeImpl.h"
15#include "llvm/ADT/SetVector.h"
17#include "llvm/ADT/iterator.h"
20#include "llvm/IR/Module.h"
21#include "llvm/IR/OptBisect.h"
22#include "llvm/IR/Type.h"
23#include "llvm/IR/Use.h"
24#include "llvm/IR/User.h"
28#include <cassert>
29#include <utility>
30
31using namespace llvm;
32
34 : DiagHandler(std::make_unique<DiagnosticHandler>()),
35 VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
36 HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
37 FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID),
38 MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
39 X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
40 PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_AMXTy(C, Type::X86_AMXTyID),
41 Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), Int32Ty(C, 32),
42 Int64Ty(C, 64), Int128Ty(C, 128) {}
43
45#ifndef NDEBUG
46 // Check that any variable location records that fell off the end of a block
47 // when it's terminator was removed were eventually replaced. This assertion
48 // firing indicates that DbgVariableRecords went missing during the lifetime
49 // of the LLVMContext.
50 assert(TrailingDbgRecords.empty() && "DbgRecords in blocks not cleaned");
51#endif
52
53 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
54 // will call LLVMContextImpl::removeModule, thus invalidating iterators into
55 // the container. Avoid iterators during this operation:
56 while (!OwnedModules.empty())
57 delete *OwnedModules.begin();
58
59#ifndef NDEBUG
60 // Check for metadata references from leaked Values.
61 for (auto &Pair : ValueMetadata)
62 Pair.first->dump();
63 assert(ValueMetadata.empty() && "Values with metadata have been leaked");
64#endif
65
66 // Drop references for MDNodes. Do this before Values get deleted to avoid
67 // unnecessary RAUW when nodes are still unresolved.
68 for (auto *I : DistinctMDNodes)
69 I->dropAllReferences();
70#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
71 for (auto *I : CLASS##s) \
72 I->dropAllReferences();
73#include "llvm/IR/Metadata.def"
74
75 // Also drop references that come from the Value bridges.
76 for (auto &Pair : ValuesAsMetadata)
77 Pair.second->dropUsers();
78 for (auto &Pair : MetadataAsValues)
79 Pair.second->dropUse();
80 // Do not untrack ValueAsMetadata references for DIArgLists, as they have
81 // already been more efficiently untracked above.
82 for (DIArgList *AL : DIArgLists) {
83 AL->dropAllReferences(/* Untrack */ false);
84 delete AL;
85 }
86 DIArgLists.clear();
87
88 // Destroy MDNodes.
89 for (MDNode *I : DistinctMDNodes)
90 I->deleteAsSubclass();
91
92 for (auto *ConstantRangeListAttribute : ConstantRangeListAttributes)
93 ConstantRangeListAttribute->~ConstantRangeListAttributeImpl();
94#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
95 for (CLASS * I : CLASS##s) \
96 delete I;
97#include "llvm/IR/Metadata.def"
98
99 // Free the constants.
100 for (auto *I : ExprConstants)
101 I->dropAllReferences();
102 for (auto *I : ArrayConstants)
103 I->dropAllReferences();
104 for (auto *I : StructConstants)
105 I->dropAllReferences();
106 for (auto *I : VectorConstants)
107 I->dropAllReferences();
108 ExprConstants.freeConstants();
112 InlineAsms.freeConstants();
113
114 CAZConstants.clear();
115 CPNConstants.clear();
116 CTNConstants.clear();
117 UVConstants.clear();
118 PVConstants.clear();
119 IntZeroConstants.clear();
120 IntOneConstants.clear();
121 IntConstants.clear();
122 IntSplatConstants.clear();
123 FPConstants.clear();
124 FPSplatConstants.clear();
125 CDSConstants.clear();
126
127 // Destroy attribute node lists.
129 E = AttrsSetNodes.end(); I != E; ) {
131 delete &*Elem;
132 }
133
134 // Destroy MetadataAsValues.
135 {
137 MDVs.reserve(MetadataAsValues.size());
138 for (auto &Pair : MetadataAsValues)
139 MDVs.push_back(Pair.second);
140 MetadataAsValues.clear();
141 for (auto *V : MDVs)
142 delete V;
143 }
144
145 // Destroy ValuesAsMetadata.
146 for (auto &Pair : ValuesAsMetadata)
147 delete Pair.second;
148}
149
152
153 // When ArrayConstants are of substantial size and only a few in them are
154 // dead, starting WorkList with all elements of ArrayConstants can be
155 // wasteful. Instead, starting WorkList with only elements that have empty
156 // uses.
158 if (C->use_empty())
159 WorkList.insert(C);
160
161 while (!WorkList.empty()) {
162 ConstantArray *C = WorkList.pop_back_val();
163 if (C->use_empty()) {
164 for (const Use &Op : C->operands()) {
165 if (auto *COp = dyn_cast<ConstantArray>(Op))
166 WorkList.insert(COp);
167 }
168 C->destroyConstant();
169 }
170 }
171}
172
175}
176
177namespace llvm {
178
179/// Make MDOperand transparent for hashing.
180///
181/// This overload of an implementation detail of the hashing library makes
182/// MDOperand hash to the same value as a \a Metadata pointer.
183///
184/// Note that overloading \a hash_value() as follows:
185///
186/// \code
187/// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
188/// \endcode
189///
190/// does not cause MDOperand to be transparent. In particular, a bare pointer
191/// doesn't get hashed before it's combined, whereas \a MDOperand would.
192static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
193
194} // end namespace llvm
195
197 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
198#ifndef NDEBUG
199 {
201 unsigned RawHash = calculateHash(MDs);
202 assert(Hash == RawHash &&
203 "Expected hash of MDOperand to equal hash of Metadata*");
204 }
205#endif
206 return Hash;
207}
208
210 return hash_combine_range(Ops.begin(), Ops.end());
211}
212
214 uint32_t NewIdx = BundleTagCache.size();
215 return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first);
216}
217
219 Tags.resize(BundleTagCache.size());
220 for (const auto &T : BundleTagCache)
221 Tags[T.second] = T.first();
222}
223
225 auto I = BundleTagCache.find(Tag);
226 assert(I != BundleTagCache.end() && "Unknown tag!");
227 return I->second;
228}
229
231 auto NewSSID = SSC.size();
232 assert(NewSSID < std::numeric_limits<SyncScope::ID>::max() &&
233 "Hit the maximum number of synchronization scopes allowed!");
234 return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second;
235}
236
238 SmallVectorImpl<StringRef> &SSNs) const {
239 SSNs.resize(SSC.size());
240 for (const auto &SSE : SSC)
241 SSNs[SSE.second] = SSE.first();
242}
243
244std::optional<StringRef>
246 for (const auto &SSE : SSC) {
247 if (SSE.second != Id)
248 continue;
249 return SSE.first();
250 }
251 return std::nullopt;
252}
253
254/// Gets the OptPassGate for this LLVMContextImpl, which defaults to the
255/// singleton OptBisect if not explicitly set.
257 if (!OPG)
259 return *OPG;
260}
261
263 this->OPG = &OPG;
264}
This file defines the StringMapEntry class - it is intended to be a low dependency implementation det...
This file defines various helper methods and classes used by LLVMContextImpl for creating and managin...
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Module.h This file contains the declarations for the Module class.
This defines the Use class.
#define I(x, y, z)
Definition: MD5.cpp:58
const Type::TypeID FloatTyID
const Type::TypeID DoubleTyID
This file declares the interface for bisecting optimizations.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
static void DiagHandler(const SMDiagnostic &Diag, void *Context)
Definition: TextStub.cpp:1060
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:157
iterator begin() const
Definition: ArrayRef.h:156
ConstantArray - Constant Array Declarations.
Definition: Constants.h:427
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
This class represents an Operation in the Expression.
DenseMap< unsigned, std::unique_ptr< ConstantInt > > IntOneConstants
void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const
getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...
DenseMap< unsigned, std::unique_ptr< ConstantInt > > IntZeroConstants
DenseMap< Metadata *, MetadataAsValue * > MetadataAsValues
DenseMap< APFloat, std::unique_ptr< ConstantFP > > FPConstants
SmallPtrSet< Module *, 4 > OwnedModules
OwnedModules - The set of modules instantiated in this context, and which will be automatically delet...
DenseMap< PointerType *, std::unique_ptr< ConstantPointerNull > > CPNConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
DenseMap< Type *, std::unique_ptr< PoisonValue > > PVConstants
DenseMap< APInt, std::unique_ptr< ConstantInt > > IntConstants
std::vector< MDNode * > DistinctMDNodes
SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)
getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.
void dropTriviallyDeadConstantArrays()
Destroy the ConstantArrays if they are not used.
void setOptPassGate(OptPassGate &)
Set the object which can disable optional passes and individual optimizations at compile time.
VectorConstantsTy VectorConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time.
DenseMap< const Value *, MDAttachments > ValueMetadata
Collection of metadata used in this context.
StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef Tag)
StringMap< uint32_t > BundleTagCache
A set of interned tags for operand bundles.
StringMap< std::unique_ptr< ConstantDataSequential > > CDSConstants
StructConstantsTy StructConstants
void getOperandBundleTags(SmallVectorImpl< StringRef > &Tags) const
FoldingSet< AttributeSetNode > AttrsSetNodes
DenseMap< TargetExtType *, std::unique_ptr< ConstantTargetNone > > CTNConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
uint32_t getOperandBundleTagID(StringRef Tag) const
StringMap< SyncScope::ID > SSC
A set of interned synchronization scopes.
DenseMap< std::pair< ElementCount, APInt >, std::unique_ptr< ConstantInt > > IntSplatConstants
std::vector< ConstantRangeListAttributeImpl * > ConstantRangeListAttributes
DenseSet< DIArgList *, DIArgListInfo > DIArgLists
std::optional< StringRef > getSyncScopeName(SyncScope::ID Id) const
getSyncScopeName - Returns the name of a SyncScope::ID registered with LLVMContext,...
ArrayConstantsTy ArrayConstants
DenseMap< Value *, ValueAsMetadata * > ValuesAsMetadata
ConstantUniqueMap< InlineAsm > InlineAsms
LLVMContextImpl(LLVMContext &C)
SmallDenseMap< BasicBlock *, DbgMarker * > TrailingDbgRecords
Mapping of blocks to collections of "trailing" DbgVariableRecords.
DenseMap< std::pair< ElementCount, APFloat >, std::unique_ptr< ConstantFP > > FPSplatConstants
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:69
static unsigned calculateHash(MDNode *N, unsigned Offset=0)
Metadata node.
Definition: Metadata.h:1069
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:891
Root of the metadata hierarchy.
Definition: Metadata.h:62
void dropTriviallyDeadConstantArrays()
Destroy ConstantArrays in LLVMContext if they are not used.
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
Definition: OptBisect.h:24
bool empty() const
Determine if the SetVector is empty or not.
Definition: SetVector.h:93
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:162
value_type pop_back_val()
Definition: SetVector.h:285
iterator begin() const
Definition: SmallPtrSet.h:472
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:370
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:573
void reserve(size_type N)
Definition: SmallVector.h:663
void resize(size_type N)
Definition: SmallVector.h:638
void push_back(const T &Elt)
Definition: SmallVector.h:413
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
unsigned size() const
Definition: StringMap.h:104
iterator end()
Definition: StringMap.h:220
iterator find(StringRef Key)
Definition: StringMap.h:233
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:308
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:329
@ Offset
Definition: DWP.cpp:480
static const Metadata * get_hashable_data(const MDOperand &X)
Make MDOperand transparent for hashing.
OptPassGate & getGlobalPassGate()
Singleton instance of the OptBisect class, so multiple pass managers don't need to coordinate their u...
Definition: OptBisect.cpp:60
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:468
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
This is the base class for diagnostic handling in LLVM.