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> 19using namespace llvm; 20 21LLVMContextImpl::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 43namespace { 44struct 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. 54struct 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 64LLVMContextImpl::~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 138void UnaryConstantExpr::anchor() { } 139 140void BinaryConstantExpr::anchor() { } 141 142void SelectConstantExpr::anchor() { } 143 144void ExtractElementConstantExpr::anchor() { } 145 146void InsertElementConstantExpr::anchor() { } 147 148void ShuffleVectorConstantExpr::anchor() { } 149 150void ExtractValueConstantExpr::anchor() { } 151 152void InsertValueConstantExpr::anchor() { } 153 154void GetElementPtrConstantExpr::anchor() { } 155 156void CompareConstantExpr::anchor() { } 157