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/StringMapEntry.h" 16 #include "llvm/ADT/iterator.h" 17 #include "llvm/IR/DiagnosticHandler.h" 18 #include "llvm/IR/LLVMRemarkStreamer.h" 19 #include "llvm/IR/Module.h" 20 #include "llvm/IR/OptBisect.h" 21 #include "llvm/IR/Type.h" 22 #include "llvm/IR/Use.h" 23 #include "llvm/IR/User.h" 24 #include "llvm/Remarks/RemarkStreamer.h" 25 #include "llvm/Support/Compiler.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include <cassert> 28 #include <utility> 29 30 using namespace llvm; 31 32 LLVMContextImpl::LLVMContextImpl(LLVMContext &C) 33 : DiagHandler(std::make_unique<DiagnosticHandler>()), 34 VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID), 35 HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID), 36 FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID), 37 MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID), 38 X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID), 39 PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_AMXTy(C, Type::X86_AMXTyID), 40 Int1Ty(C, 1), Int8Ty(C, 8), Int16Ty(C, 16), Int32Ty(C, 32), 41 Int64Ty(C, 64), Int128Ty(C, 128) {} 42 43 LLVMContextImpl::~LLVMContextImpl() { 44 #ifndef NDEBUG 45 // Check that any variable location records that fell off the end of a block 46 // when it's terminator was removed were eventually replaced. This assertion 47 // firing indicates that DbgVariableRecords went missing during the lifetime 48 // of the LLVMContext. 49 assert(TrailingDbgRecords.empty() && "DbgRecords in blocks not cleaned"); 50 #endif 51 52 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor 53 // will call LLVMContextImpl::removeModule, thus invalidating iterators into 54 // the container. Avoid iterators during this operation: 55 while (!OwnedModules.empty()) 56 delete *OwnedModules.begin(); 57 58 #ifndef NDEBUG 59 // Check for metadata references from leaked Values. 60 for (auto &Pair : ValueMetadata) 61 Pair.first->dump(); 62 assert(ValueMetadata.empty() && "Values with metadata have been leaked"); 63 #endif 64 65 // Drop references for MDNodes. Do this before Values get deleted to avoid 66 // unnecessary RAUW when nodes are still unresolved. 67 for (auto *I : DistinctMDNodes) 68 I->dropAllReferences(); 69 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 70 for (auto *I : CLASS##s) \ 71 I->dropAllReferences(); 72 #include "llvm/IR/Metadata.def" 73 74 // Also drop references that come from the Value bridges. 75 for (auto &Pair : ValuesAsMetadata) 76 Pair.second->dropUsers(); 77 for (auto &Pair : MetadataAsValues) 78 Pair.second->dropUse(); 79 // Do not untrack ValueAsMetadata references for DIArgLists, as they have 80 // already been more efficiently untracked above. 81 for (DIArgList *AL : DIArgLists) { 82 AL->dropAllReferences(/* Untrack */ false); 83 delete AL; 84 } 85 DIArgLists.clear(); 86 87 // Destroy MDNodes. 88 for (MDNode *I : DistinctMDNodes) 89 I->deleteAsSubclass(); 90 91 for (auto *ConstantRangeListAttribute : ConstantRangeListAttributes) 92 ConstantRangeListAttribute->~ConstantRangeListAttributeImpl(); 93 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 94 for (CLASS * I : CLASS##s) \ 95 delete I; 96 #include "llvm/IR/Metadata.def" 97 98 // Free the constants. 99 for (auto *I : ExprConstants) 100 I->dropAllReferences(); 101 for (auto *I : ArrayConstants) 102 I->dropAllReferences(); 103 for (auto *I : StructConstants) 104 I->dropAllReferences(); 105 for (auto *I : VectorConstants) 106 I->dropAllReferences(); 107 ExprConstants.freeConstants(); 108 ArrayConstants.freeConstants(); 109 StructConstants.freeConstants(); 110 VectorConstants.freeConstants(); 111 InlineAsms.freeConstants(); 112 113 CAZConstants.clear(); 114 CPNConstants.clear(); 115 CTNConstants.clear(); 116 UVConstants.clear(); 117 PVConstants.clear(); 118 IntZeroConstants.clear(); 119 IntOneConstants.clear(); 120 IntConstants.clear(); 121 IntSplatConstants.clear(); 122 FPConstants.clear(); 123 FPSplatConstants.clear(); 124 CDSConstants.clear(); 125 126 // Destroy attribute node lists. 127 for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(), 128 E = AttrsSetNodes.end(); I != E; ) { 129 FoldingSetIterator<AttributeSetNode> Elem = I++; 130 delete &*Elem; 131 } 132 133 // Destroy MetadataAsValues. 134 { 135 SmallVector<MetadataAsValue *, 8> MDVs; 136 MDVs.reserve(MetadataAsValues.size()); 137 for (auto &Pair : MetadataAsValues) 138 MDVs.push_back(Pair.second); 139 MetadataAsValues.clear(); 140 for (auto *V : MDVs) 141 delete V; 142 } 143 144 // Destroy ValuesAsMetadata. 145 for (auto &Pair : ValuesAsMetadata) 146 delete Pair.second; 147 } 148 149 namespace llvm { 150 151 /// Make MDOperand transparent for hashing. 152 /// 153 /// This overload of an implementation detail of the hashing library makes 154 /// MDOperand hash to the same value as a \a Metadata pointer. 155 /// 156 /// Note that overloading \a hash_value() as follows: 157 /// 158 /// \code 159 /// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); } 160 /// \endcode 161 /// 162 /// does not cause MDOperand to be transparent. In particular, a bare pointer 163 /// doesn't get hashed before it's combined, whereas \a MDOperand would. 164 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); } 165 166 } // end namespace llvm 167 168 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) { 169 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end()); 170 #ifndef NDEBUG 171 { 172 SmallVector<Metadata *, 8> MDs(drop_begin(N->operands(), Offset)); 173 unsigned RawHash = calculateHash(MDs); 174 assert(Hash == RawHash && 175 "Expected hash of MDOperand to equal hash of Metadata*"); 176 } 177 #endif 178 return Hash; 179 } 180 181 unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) { 182 return hash_combine_range(Ops); 183 } 184 185 StringMapEntry<uint32_t> *LLVMContextImpl::getOrInsertBundleTag(StringRef Tag) { 186 uint32_t NewIdx = BundleTagCache.size(); 187 return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first); 188 } 189 190 void LLVMContextImpl::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const { 191 Tags.resize(BundleTagCache.size()); 192 for (const auto &T : BundleTagCache) 193 Tags[T.second] = T.first(); 194 } 195 196 uint32_t LLVMContextImpl::getOperandBundleTagID(StringRef Tag) const { 197 auto I = BundleTagCache.find(Tag); 198 assert(I != BundleTagCache.end() && "Unknown tag!"); 199 return I->second; 200 } 201 202 SyncScope::ID LLVMContextImpl::getOrInsertSyncScopeID(StringRef SSN) { 203 auto NewSSID = SSC.size(); 204 assert(NewSSID < std::numeric_limits<SyncScope::ID>::max() && 205 "Hit the maximum number of synchronization scopes allowed!"); 206 return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second; 207 } 208 209 void LLVMContextImpl::getSyncScopeNames( 210 SmallVectorImpl<StringRef> &SSNs) const { 211 SSNs.resize(SSC.size()); 212 for (const auto &SSE : SSC) 213 SSNs[SSE.second] = SSE.first(); 214 } 215 216 std::optional<StringRef> 217 LLVMContextImpl::getSyncScopeName(SyncScope::ID Id) const { 218 for (const auto &SSE : SSC) { 219 if (SSE.second != Id) 220 continue; 221 return SSE.first(); 222 } 223 return std::nullopt; 224 } 225 226 /// Gets the OptPassGate for this LLVMContextImpl, which defaults to the 227 /// singleton OptBisect if not explicitly set. 228 OptPassGate &LLVMContextImpl::getOptPassGate() const { 229 if (!OPG) 230 OPG = &getGlobalPassGate(); 231 return *OPG; 232 } 233 234 void LLVMContextImpl::setOptPassGate(OptPassGate& OPG) { 235 this->OPG = &OPG; 236 } 237