1 //===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the opaque LLVMContextImpl.
12 //===----------------------------------------------------------------------===//
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"
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 X86_FP80Ty(C, Type::X86_FP80TyID),
31 FP128Ty(C, Type::FP128TyID),
32 PPC_FP128Ty(C, Type::PPC_FP128TyID),
33 X86_MMXTy(C, Type::X86_MMXTyID),
39 InlineAsmDiagHandler = nullptr;
40 InlineAsmDiagContext = nullptr;
41 DiagnosticHandler = nullptr;
42 DiagnosticContext = nullptr;
43 RespectDiagnosticFilters = false;
44 YieldCallback = nullptr;
45 YieldOpaqueHandle = nullptr;
46 NamedStructTypesUniqueID = 0;
50 struct DropReferences {
51 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
53 template <typename PairT> void operator()(const PairT &P) {
54 P.second->dropAllReferences();
58 // Temporary - drops pair.first instead of second.
60 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second'
62 template<typename PairT>
63 void operator()(const PairT &P) {
64 P.first->dropAllReferences();
69 LLVMContextImpl::~LLVMContextImpl() {
70 // NOTE: We need to delete the contents of OwnedModules, but Module's dtor
71 // will call LLVMContextImpl::removeModule, thus invalidating iterators into
72 // the container. Avoid iterators during this operation:
73 while (!OwnedModules.empty())
74 delete *OwnedModules.begin();
76 // Drop references for MDNodes. Do this before Values get deleted to avoid
77 // unnecessary RAUW when nodes are still unresolved.
78 for (auto *I : DistinctMDNodes)
79 I->dropAllReferences();
80 #define HANDLE_MDNODE_LEAF(CLASS) \
81 for (auto *I : CLASS##s) \
82 I->dropAllReferences();
83 #include "llvm/IR/Metadata.def"
85 // Also drop references that come from the Value bridges.
86 for (auto &Pair : ValuesAsMetadata)
87 Pair.second->dropUsers();
88 for (auto &Pair : MetadataAsValues)
89 Pair.second->dropUse();
92 for (MDNode *I : DistinctMDNodes)
93 I->deleteAsSubclass();
94 #define HANDLE_MDNODE_LEAF(CLASS) \
95 for (CLASS *I : CLASS##s) \
97 #include "llvm/IR/Metadata.def"
99 // Free the constants.
100 std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(),
102 std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(),
104 std::for_each(StructConstants.map_begin(), StructConstants.map_end(),
106 std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(),
108 ExprConstants.freeConstants();
109 ArrayConstants.freeConstants();
110 StructConstants.freeConstants();
111 VectorConstants.freeConstants();
112 DeleteContainerSeconds(CAZConstants);
113 DeleteContainerSeconds(CPNConstants);
114 DeleteContainerSeconds(UVConstants);
115 InlineAsms.freeConstants();
116 DeleteContainerSeconds(IntConstants);
117 DeleteContainerSeconds(FPConstants);
119 for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(),
120 E = CDSConstants.end(); I != E; ++I)
122 CDSConstants.clear();
124 // Destroy attributes.
125 for (FoldingSetIterator<AttributeImpl> I = AttrsSet.begin(),
126 E = AttrsSet.end(); I != E; ) {
127 FoldingSetIterator<AttributeImpl> Elem = I++;
131 // Destroy attribute lists.
132 for (FoldingSetIterator<AttributeSetImpl> I = AttrsLists.begin(),
133 E = AttrsLists.end(); I != E; ) {
134 FoldingSetIterator<AttributeSetImpl> Elem = I++;
138 // Destroy attribute node lists.
139 for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),
140 E = AttrsSetNodes.end(); I != E; ) {
141 FoldingSetIterator<AttributeSetNode> Elem = I++;
145 // Destroy MetadataAsValues.
147 SmallVector<MetadataAsValue *, 8> MDVs;
148 MDVs.reserve(MetadataAsValues.size());
149 for (auto &Pair : MetadataAsValues)
150 MDVs.push_back(Pair.second);
151 MetadataAsValues.clear();
156 // Destroy ValuesAsMetadata.
157 for (auto &Pair : ValuesAsMetadata)
160 // Destroy MDStrings.
161 MDStringCache.clear();
164 void LLVMContextImpl::dropTriviallyDeadConstantArrays() {
169 for (auto I = ArrayConstants.map_begin(), E = ArrayConstants.map_end();
173 if (C->use_empty()) {
175 C->destroyConstant();
182 void Module::dropTriviallyDeadConstantArrays() {
183 Context.pImpl->dropTriviallyDeadConstantArrays();
187 /// \brief Make MDOperand transparent for hashing.
189 /// This overload of an implementation detail of the hashing library makes
190 /// MDOperand hash to the same value as a \a Metadata pointer.
192 /// Note that overloading \a hash_value() as follows:
195 /// size_t hash_value(const MDOperand &X) { return hash_value(X.get()); }
198 /// does not cause MDOperand to be transparent. In particular, a bare pointer
199 /// doesn't get hashed before it's combined, whereas \a MDOperand would.
200 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
203 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
204 unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
207 SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end());
208 unsigned RawHash = calculateHash(MDs);
209 assert(Hash == RawHash &&
210 "Expected hash of MDOperand to equal hash of Metadata*");
216 unsigned MDNodeOpsKey::calculateHash(ArrayRef<Metadata *> Ops) {
217 return hash_combine_range(Ops.begin(), Ops.end());
220 // ConstantsContext anchors
221 void UnaryConstantExpr::anchor() { }
223 void BinaryConstantExpr::anchor() { }
225 void SelectConstantExpr::anchor() { }
227 void ExtractElementConstantExpr::anchor() { }
229 void InsertElementConstantExpr::anchor() { }
231 void ShuffleVectorConstantExpr::anchor() { }
233 void ExtractValueConstantExpr::anchor() { }
235 void InsertValueConstantExpr::anchor() { }
237 void GetElementPtrConstantExpr::anchor() { }
239 void CompareConstantExpr::anchor() { }