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" |
16 | #include "llvm/ADT/StringMapEntry.h" |
17 | #include "llvm/ADT/iterator.h" |
18 | #include "llvm/ADT/iterator_range.h" |
19 | #include "llvm/IR/DiagnosticHandler.h" |
20 | #include "llvm/IR/LLVMRemarkStreamer.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" |
26 | #include "llvm/Remarks/RemarkStreamer.h" |
27 | #include "llvm/Support/CommandLine.h" |
28 | #include "llvm/Support/Compiler.h" |
29 | #include "llvm/Support/ErrorHandling.h" |
30 | #include "llvm/Support/TypeSize.h" |
31 | #include <cassert> |
32 | #include <utility> |
33 | |
34 | using namespace llvm; |
35 | |
36 | LLVMContextImpl::LLVMContextImpl(LLVMContext &C) |
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_MMXTy(C, Type::X86_MMXTyID), |
44 | X86_AMXTy(C, Type::X86_AMXTyID), Int1Ty(C, 1), Int8Ty(C, 8), |
45 | Int16Ty(C, 16), Int32Ty(C, 32), Int64Ty(C, 64), Int128Ty(C, 128) {} |
46 | |
47 | LLVMContextImpl::~LLVMContextImpl() { |
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 | #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(); |
109 | ArrayConstants.freeConstants(); |
110 | StructConstants.freeConstants(); |
111 | VectorConstants.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. |
128 | for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(), |
129 | E = AttrsSetNodes.end(); I != E; ) { |
130 | FoldingSetIterator<AttributeSetNode> Elem = I++; |
131 | delete &*Elem; |
132 | } |
133 | |
134 | // Destroy MetadataAsValues. |
135 | { |
136 | SmallVector<MetadataAsValue *, 8> MDVs; |
137 | MDVs.reserve(N: MetadataAsValues.size()); |
138 | for (auto &Pair : MetadataAsValues) |
139 | MDVs.push_back(Elt: 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 | |
150 | void LLVMContextImpl::dropTriviallyDeadConstantArrays() { |
151 | SmallSetVector<ConstantArray *, 4> WorkList; |
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. |
157 | for (ConstantArray *C : ArrayConstants) |
158 | if (C->use_empty()) |
159 | WorkList.insert(X: 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>(Val: Op)) |
166 | WorkList.insert(X: COp); |
167 | } |
168 | C->destroyConstant(); |
169 | } |
170 | } |
171 | } |
172 | |
173 | void Module::dropTriviallyDeadConstantArrays() { |
174 | Context.pImpl->dropTriviallyDeadConstantArrays(); |
175 | } |
176 | |
177 | namespace 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. |
192 | static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); } |
193 | |
194 | } // end namespace llvm |
195 | |
196 | unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) { |
197 | unsigned Hash = hash_combine_range(first: N->op_begin() + Offset, last: N->op_end()); |
198 | #ifndef NDEBUG |
199 | { |
200 | SmallVector<Metadata *, 8> MDs(drop_begin(RangeOrContainer: N->operands(), N: Offset)); |
201 | unsigned RawHash = calculateHash(Ops: MDs); |
202 | assert(Hash == RawHash && |
203 | "Expected hash of MDOperand to equal hash of Metadata*" ); |
204 | } |
205 | #endif |
206 | return Hash; |
207 | } |
208 | |
209 | unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) { |
210 | return hash_combine_range(first: Ops.begin(), last: Ops.end()); |
211 | } |
212 | |
213 | StringMapEntry<uint32_t> *LLVMContextImpl::getOrInsertBundleTag(StringRef Tag) { |
214 | uint32_t NewIdx = BundleTagCache.size(); |
215 | return &*(BundleTagCache.insert(KV: std::make_pair(x&: Tag, y&: NewIdx)).first); |
216 | } |
217 | |
218 | void LLVMContextImpl::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const { |
219 | Tags.resize(N: BundleTagCache.size()); |
220 | for (const auto &T : BundleTagCache) |
221 | Tags[T.second] = T.first(); |
222 | } |
223 | |
224 | uint32_t LLVMContextImpl::getOperandBundleTagID(StringRef Tag) const { |
225 | auto I = BundleTagCache.find(Key: Tag); |
226 | assert(I != BundleTagCache.end() && "Unknown tag!" ); |
227 | return I->second; |
228 | } |
229 | |
230 | SyncScope::ID LLVMContextImpl::getOrInsertSyncScopeID(StringRef SSN) { |
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(KV: std::make_pair(x&: SSN, y: SyncScope::ID(NewSSID))).first->second; |
235 | } |
236 | |
237 | void LLVMContextImpl::getSyncScopeNames( |
238 | SmallVectorImpl<StringRef> &SSNs) const { |
239 | SSNs.resize(N: SSC.size()); |
240 | for (const auto &SSE : SSC) |
241 | SSNs[SSE.second] = SSE.first(); |
242 | } |
243 | |
244 | /// Gets the OptPassGate for this LLVMContextImpl, which defaults to the |
245 | /// singleton OptBisect if not explicitly set. |
246 | OptPassGate &LLVMContextImpl::getOptPassGate() const { |
247 | if (!OPG) |
248 | OPG = &getGlobalPassGate(); |
249 | return *OPG; |
250 | } |
251 | |
252 | void LLVMContextImpl::setOptPassGate(OptPassGate& OPG) { |
253 | this->OPG = &OPG; |
254 | } |
255 | |