1 //===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the opaque LLVMContextImpl. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "LLVMContextImpl.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "llvm/IR/Attributes.h" 17 #include "llvm/IR/DiagnosticInfo.h" 18 #include "llvm/IR/Module.h" 19 #include <algorithm> 20 using namespace llvm; 21 22 LLVMContextImpl::LLVMContextImpl(LLVMContext &C) 23 : TheTrueVal(nullptr), TheFalseVal(nullptr), 24 VoidTy(C, Type::VoidTyID), 25 LabelTy(C, Type::LabelTyID), 26 HalfTy(C, Type::HalfTyID), 27 FloatTy(C, Type::FloatTyID), 28 DoubleTy(C, Type::DoubleTyID), 29 MetadataTy(C, Type::MetadataTyID), 30 TokenTy(C, Type::TokenTyID), 31 X86_FP80Ty(C, Type::X86_FP80TyID), 32 FP128Ty(C, Type::FP128TyID), 33 PPC_FP128Ty(C, Type::PPC_FP128TyID), 34 X86_MMXTy(C, Type::X86_MMXTyID), 35 Int1Ty(C, 1), 36 Int8Ty(C, 8), 37 Int16Ty(C, 16), 38 Int32Ty(C, 32), 39 Int64Ty(C, 64), 40 Int128Ty(C, 128) { 41 InlineAsmDiagHandler = nullptr; 42 InlineAsmDiagContext = nullptr; 43 DiagnosticHandler = nullptr; 44 DiagnosticContext = nullptr; 45 RespectDiagnosticFilters = false; 46 YieldCallback = nullptr; 47 YieldOpaqueHandle = nullptr; 48 NamedStructTypesUniqueID = 0; 49 } 50 51 namespace { 52 struct DropReferences { 53 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 54 // is a Constant*. 55 template <typename PairT> void operator()(const PairT &P) { 56 P.second->dropAllReferences(); 57 } 58 }; 59 60 // Temporary - drops pair.first instead of second. 61 struct DropFirst { 62 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 63 // is a Constant*. 64 template<typename PairT> 65 void operator()(const PairT &P) { 66 P.first->dropAllReferences(); 67 } 68 }; 69 } 70 71 LLVMContextImpl::~LLVMContextImpl() { 72 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor 73 // will call LLVMContextImpl::removeModule, thus invalidating iterators into 74 // the container. Avoid iterators during this operation: 75 while (!OwnedModules.empty()) 76 delete *OwnedModules.begin(); 77 78 // Drop references for MDNodes. Do this before Values get deleted to avoid 79 // unnecessary RAUW when nodes are still unresolved. 80 for (auto *I : DistinctMDNodes) 81 I->dropAllReferences(); 82 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 83 for (auto *I : CLASS##s) \ 84 I->dropAllReferences(); 85 #include "llvm/IR/Metadata.def" 86 87 // Also drop references that come from the Value bridges. 88 for (auto &Pair : ValuesAsMetadata) 89 Pair.second->dropUsers(); 90 for (auto &Pair : MetadataAsValues) 91 Pair.second->dropUse(); 92 93 // Destroy MDNodes. 94 for (MDNode *I : DistinctMDNodes) 95 I->deleteAsSubclass(); 96 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \ 97 for (CLASS * I : CLASS##s) \ 98 delete I; 99 #include "llvm/IR/Metadata.def" 100 101 // Free the constants. 102 std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), 103 DropFirst()); 104 std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), 105 DropFirst()); 106 std::for_each(StructConstants.map_begin(), StructConstants.map_end(), 107 DropFirst()); 108 std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), 109 DropFirst()); 110 ExprConstants.freeConstants(); 111 ArrayConstants.freeConstants(); 112 StructConstants.freeConstants(); 113 VectorConstants.freeConstants(); 114 DeleteContainerSeconds(CAZConstants); 115 DeleteContainerSeconds(CPNConstants); 116 DeleteContainerSeconds(UVConstants); 117 InlineAsms.freeConstants(); 118 DeleteContainerSeconds(IntConstants); 119 DeleteContainerSeconds(FPConstants); 120 121 for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(), 122 E = CDSConstants.end(); I != E; ++I) 123 delete I->second; 124 CDSConstants.clear(); 125 126 // Destroy attributes. 127 for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(), 128 E = AttrsSet.end(); I != E; ) { 129 FoldingSetIterator<AttributeImpl> Elem = I++; 130 delete &*Elem; 131 } 132 133 // Destroy attribute lists. 134 for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(), 135 E = AttrsLists.end(); I != E; ) { 136 FoldingSetIterator<AttributeSetImpl> Elem = I++; 137 delete &*Elem; 138 } 139 140 // Destroy attribute node lists. 141 for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(), 142 E = AttrsSetNodes.end(); I != E; ) { 143 FoldingSetIterator<AttributeSetNode> Elem = I++; 144 delete &*Elem; 145 } 146 147 // Destroy MetadataAsValues. 148 { 149 SmallVector<MetadataAsValue *, 8> MDVs; 150 MDVs.reserve(MetadataAsValues.size()); 151 for (auto &Pair : MetadataAsValues) 152 MDVs.push_back(Pair.second); 153 MetadataAsValues.clear(); 154 for (auto *V : MDVs) 155 delete V; 156 } 157 158 // Destroy ValuesAsMetadata. 159 for (auto &Pair : ValuesAsMetadata) 160 delete Pair.second; 161 162 // Destroy MDStrings. 163 MDStringCache.clear(); 164 } 165 166 void LLVMContextImpl::dropTriviallyDeadConstantArrays() { 167 bool Changed; 168 do { 169 Changed = false; 170 171 for (auto I = ArrayConstants.map_begin(), E = ArrayConstants.map_end(); 172 I != E; ) { 173 auto *C = I->first; 174 I++; 175 if (C->use_empty()) { 176 Changed = true; 177 C->destroyConstant(); 178 } 179 } 180 181 } while (Changed); 182 } 183 184 void Module::dropTriviallyDeadConstantArrays() { 185 Context.pImpl->dropTriviallyDeadConstantArrays(); 186 } 187 188 namespace llvm { 189 /// \brief Make MDOperand transparent for hashing. 190 /// 191 /// This overload of an implementation detail of the hashing library makes 192 /// MDOperand hash to the same value as a \a Metadata pointer. 193 /// 194 /// Note that overloading \a hash_value() as follows: 195 /// 196 /// \code 197 /// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); } 198 /// \endcode 199 /// 200 /// does not cause MDOperand to be transparent. In particular, a bare pointer 201 /// doesn't get hashed before it's combined, whereas \a MDOperand would. 202 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); } 203 } 204 205 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) { 206 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end()); 207 #ifndef NDEBUG 208 { 209 SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end()); 210 unsigned RawHash = calculateHash(MDs); 211 assert(Hash == RawHash && 212 "Expected hash of MDOperand to equal hash of Metadata*"); 213 } 214 #endif 215 return Hash; 216 } 217 218 unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) { 219 return hash_combine_range(Ops.begin(), Ops.end()); 220 } 221 222 StringMapEntry<uint32_t> *LLVMContextImpl::getOrInsertBundleTag(StringRef Tag) { 223 uint32_t NewIdx = BundleTagCache.size(); 224 return &*(BundleTagCache.insert(std::make_pair(Tag, NewIdx)).first); 225 } 226 227 void LLVMContextImpl::getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const { 228 Tags.resize(BundleTagCache.size()); 229 for (const auto &T : BundleTagCache) 230 Tags[T.second] = T.first(); 231 } 232 233 uint32_t LLVMContextImpl::getOperandBundleTagID(StringRef Tag) const { 234 auto I = BundleTagCache.find(Tag); 235 assert(I != BundleTagCache.end() && "Unknown tag!"); 236 return I->second; 237 } 238 239 // ConstantsContext anchors 240 void UnaryConstantExpr::anchor() { } 241 242 void BinaryConstantExpr::anchor() { } 243 244 void SelectConstantExpr::anchor() { } 245 246 void ExtractElementConstantExpr::anchor() { } 247 248 void InsertElementConstantExpr::anchor() { } 249 250 void ShuffleVectorConstantExpr::anchor() { } 251 252 void ExtractValueConstantExpr::anchor() { } 253 254 void InsertValueConstantExpr::anchor() { } 255 256 void GetElementPtrConstantExpr::anchor() { } 257 258 void CompareConstantExpr::anchor() { } 259 260
