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/Module.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include <algorithm> 18 using namespace llvm; 19 20 LLVMContextImpl::LLVMContextImpl(LLVMContext &C) 21 : TheTrueVal(0), TheFalseVal(0), 22 VoidTy(C, Type::VoidTyID), 23 LabelTy(C, Type::LabelTyID), 24 HalfTy(C, Type::HalfTyID), 25 FloatTy(C, Type::FloatTyID), 26 DoubleTy(C, Type::DoubleTyID), 27 MetadataTy(C, Type::MetadataTyID), 28 X86_FP80Ty(C, Type::X86_FP80TyID), 29 FP128Ty(C, Type::FP128TyID), 30 PPC_FP128Ty(C, Type::PPC_FP128TyID), 31 X86_MMXTy(C, Type::X86_MMXTyID), 32 Int1Ty(C, 1), 33 Int8Ty(C, 8), 34 Int16Ty(C, 16), 35 Int32Ty(C, 32), 36 Int64Ty(C, 64) { 37 InlineAsmDiagHandler = 0; 38 InlineAsmDiagContext = 0; 39 NamedStructTypesUniqueID = 0; 40 } 41 42 namespace { 43 struct DropReferences { 44 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 45 // is a Constant*. 46 template<typename PairT> 47 void operator()(const PairT &P) { 48 P.second->dropAllReferences(); 49 } 50 }; 51 52 // Temporary - drops pair.first instead of second. 53 struct DropFirst { 54 // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' 55 // is a Constant*. 56 template<typename PairT> 57 void operator()(const PairT &P) { 58 P.first->dropAllReferences(); 59 } 60 }; 61 } 62 63 LLVMContextImpl::~LLVMContextImpl() { 64 // NOTE: We need to delete the contents of OwnedModules, but we have to 65 // duplicate it into a temporary vector, because the destructor of Module 66 // will try to remove itself from OwnedModules set. This would cause 67 // iterator invalidation if we iterated on the set directly. 68 std::vector<Module*> Modules(OwnedModules.begin(), OwnedModules.end()); 69 DeleteContainerPointers(Modules); 70 71 // Free the constants. This is important to do here to ensure that they are 72 // freed before the LeakDetector is torn down. 73 std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), 74 DropReferences()); 75 std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), 76 DropFirst()); 77 std::for_each(StructConstants.map_begin(), StructConstants.map_end(), 78 DropFirst()); 79 std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), 80 DropFirst()); 81 ExprConstants.freeConstants(); 82 ArrayConstants.freeConstants(); 83 StructConstants.freeConstants(); 84 VectorConstants.freeConstants(); 85 DeleteContainerSeconds(CAZConstants); 86 DeleteContainerSeconds(CPNConstants); 87 DeleteContainerSeconds(UVConstants); 88 InlineAsms.freeConstants(); 89 DeleteContainerSeconds(IntConstants); 90 DeleteContainerSeconds(FPConstants); 91 92 for (StringMap<ConstantDataSequential*>::iterator I = CDSConstants.begin(), 93 E = CDSConstants.end(); I != E; ++I) 94 delete I->second; 95 CDSConstants.clear(); 96 97 // Destroy MDNodes. ~MDNode can move and remove nodes between the MDNodeSet 98 // and the NonUniquedMDNodes sets, so copy the values out first. 99 SmallVector<MDNode*, 8> MDNodes; 100 MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size()); 101 for (FoldingSetIterator<MDNode> I = MDNodeSet.begin(), E = MDNodeSet.end(); 102 I != E; ++I) 103 MDNodes.push_back(&*I); 104 MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end()); 105 for (SmallVectorImpl<MDNode *>::iterator I = MDNodes.begin(), 106 E = MDNodes.end(); I != E; ++I) 107 (*I)->destroy(); 108 assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() && 109 "Destroying all MDNodes didn't empty the Context's sets."); 110 // Destroy MDStrings. 111 DeleteContainerSeconds(MDStringCache); 112 } 113 114 // ConstantsContext anchors 115 void UnaryConstantExpr::anchor() { } 116 117 void BinaryConstantExpr::anchor() { } 118 119 void SelectConstantExpr::anchor() { } 120 121 void ExtractElementConstantExpr::anchor() { } 122 123 void InsertElementConstantExpr::anchor() { } 124 125 void ShuffleVectorConstantExpr::anchor() { } 126 127 void ExtractValueConstantExpr::anchor() { } 128 129 void InsertValueConstantExpr::anchor() { } 130 131 void GetElementPtrConstantExpr::anchor() { } 132 133 void CompareConstantExpr::anchor() { } 134