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"
21#include "llvm/IR/Module.h"
22#include "llvm/IR/OptBisect.h"
23#include "llvm/IR/Type.h"
24#include "llvm/IR/Use.h"
25#include "llvm/IR/User.h"
31#include <cassert>
32#include <utility>
33
34using namespace llvm;
35
37 : DiagHandler(std::make_unique<DiagnosticHandler>()),
38 VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
39 HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
40 FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID),
41 MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
42 X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
43 PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_AMXTy(C, Type::X86_AMXTyID),
44 Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), Int32Ty(C, 32),
45 Int64Ty(C, 64), Int128Ty(C, 128) {}
46
48#ifndef NDEBUG
49 // Check that any variable location records that fell off the end of a block
50 // when it's terminator was removed were eventually replaced. This assertion
51 // firing indicates that DbgVariableRecords went missing during the lifetime
52 // of the LLVMContext.
53 assert(TrailingDbgRecords.empty() && "DbgRecords in blocks not cleaned");
54#endif
55
56 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
57 // will call LLVMContextImpl::removeModule, thus invalidating iterators into
58 // the container. Avoid iterators during this operation:
59 while (!OwnedModules.empty())
60 delete *OwnedModules.begin();
61
62#ifndef NDEBUG
63 // Check for metadata references from leaked Values.
64 for (auto &Pair : ValueMetadata)
65 Pair.first->dump();
66 assert(ValueMetadata.empty() && "Values with metadata have been leaked");
67#endif
68
69 // Drop references for MDNodes. Do this before Values get deleted to avoid
70 // unnecessary RAUW when nodes are still unresolved.
71 for (auto *I : DistinctMDNodes)
72 I->dropAllReferences();
73#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
74 for (auto *I : CLASS##s) \
75 I->dropAllReferences();
76#include "llvm/IR/Metadata.def"
77
78 // Also drop references that come from the Value bridges.
79 for (auto &Pair : ValuesAsMetadata)
80 Pair.second->dropUsers();
81 for (auto &Pair : MetadataAsValues)
82 Pair.second->dropUse();
83 // Do not untrack ValueAsMetadata references for DIArgLists, as they have
84 // already been more efficiently untracked above.
85 for (DIArgList *AL : DIArgLists) {
86 AL->dropAllReferences(/* Untrack */ false);
87 delete AL;
88 }
89 DIArgLists.clear();
90
91 // Destroy MDNodes.
92 for (MDNode *I : DistinctMDNodes)
93 I->deleteAsSubclass();
94
95 for (auto *ConstantRangeListAttribute : ConstantRangeListAttributes)
96 ConstantRangeListAttribute->~ConstantRangeListAttributeImpl();
97#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
98 for (CLASS * I : CLASS##s) \
99 delete I;
100#include "llvm/IR/Metadata.def"
101
102 // Free the constants.
103 for (auto *I : ExprConstants)
104 I->dropAllReferences();
105 for (auto *I : ArrayConstants)
106 I->dropAllReferences();
107 for (auto *I : StructConstants)
108 I->dropAllReferences();
109 for (auto *I : VectorConstants)
110 I->dropAllReferences();
111 ExprConstants.freeConstants();
115 InlineAsms.freeConstants();
116
117 CAZConstants.clear();
118 CPNConstants.clear();
119 CTNConstants.clear();
120 UVConstants.clear();
121 PVConstants.clear();
122 IntZeroConstants.clear();
123 IntOneConstants.clear();
124 IntConstants.clear();
125 IntSplatConstants.clear();
126 FPConstants.clear();
127 FPSplatConstants.clear();
128 CDSConstants.clear();
129
130 // Destroy attribute node lists.
132 E = AttrsSetNodes.end(); I != E; ) {
134 delete &*Elem;
135 }
136
137 // Destroy MetadataAsValues.
138 {
140 MDVs.reserve(MetadataAsValues.size());
141 for (auto &Pair : MetadataAsValues)
142 MDVs.push_back(Pair.second);
143 MetadataAsValues.clear();
144 for (auto *V : MDVs)
145 delete V;
146 }
147
148 // Destroy ValuesAsMetadata.
149 for (auto &Pair : ValuesAsMetadata)
150 delete Pair.second;
151}
152
155
156 // When ArrayConstants are of substantial size and only a few in them are
157 // dead, starting WorkList with all elements of ArrayConstants can be
158 // wasteful. Instead, starting WorkList with only elements that have empty
159 // uses.
161 if (C->use_empty())
162 WorkList.insert(C);
163
164 while (!WorkList.empty()) {
165 ConstantArray *C = WorkList.pop_back_val();
166 if (C->use_empty()) {
167 for (const Use &Op : C->operands()) {
168 if (auto *COp = dyn_cast<ConstantArray>(Op))
169 WorkList.insert(COp);
170 }
171 C->destroyConstant();
172 }
173 }
174}
175
178}
179
180namespace llvm {
181
182/// Make MDOperand transparent for hashing.
183///
184/// This overload of an implementation detail of the hashing library makes
185/// MDOperand hash to the same value as a \a Metadata pointer.
186///
187/// Note that overloading \a hash_value() as follows:
188///
189/// \code
190/// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
191/// \endcode
192///
193/// does not cause MDOperand to be transparent. In particular, a bare pointer
194/// doesn't get hashed before it's combined, whereas \a MDOperand would.
195static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
196
197} // end namespace llvm
198
200 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
201#ifndef NDEBUG
202 {
204 unsigned RawHash = calculateHash(MDs);
205 assert(Hash == RawHash &&
206 "Expected hash of MDOperand to equal hash of Metadata*");
207 }
208#endif
209 return Hash;
210}
211
213 return hash_combine_range(Ops.begin(), Ops.end());
214}
215
217 uint32_t NewIdx = BundleTagCache.size();
218 return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first);
219}
220
222 Tags.resize(BundleTagCache.size());
223 for (const auto &T : BundleTagCache)
224 Tags[T.second] = T.first();
225}
226
228 auto I = BundleTagCache.find(Tag);
229 assert(I != BundleTagCache.end() && "Unknown tag!");
230 return I->second;
231}
232
234 auto NewSSID = SSC.size();
235 assert(NewSSID < std::numeric_limits<SyncScope::ID>::max() &&
236 "Hit the maximum number of synchronization scopes allowed!");
237 return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second;
238}
239
241 SmallVectorImpl<StringRef> &SSNs) const {
242 SSNs.resize(SSC.size());
243 for (const auto &SSE : SSC)
244 SSNs[SSE.second] = SSE.first();
245}
246
247/// Gets the OptPassGate for this LLVMContextImpl, which defaults to the
248/// singleton OptBisect if not explicitly set.
250 if (!OPG)
252 return *OPG;
253}
254
256 this->OPG = &OPG;
257}
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")
This defines the Use class.
#define I(x, y, z)
Definition: MD5.cpp:58
const Type::TypeID FloatTyID
const Type::TypeID DoubleTyID
Module.h This file contains the declarations for the Module class.
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:154
iterator begin() const
Definition: ArrayRef.h:153
ConstantArray - Constant Array Declarations.
Definition: Constants.h:424
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
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:456
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:587
void reserve(size_type N)
Definition: SmallVector.h:677
void resize(size_type N)
Definition: SmallVector.h:652
void push_back(const T &Elt)
Definition: SmallVector.h:427
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1210
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:50
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
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
@ 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:471
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.