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