X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FLLVMContextImpl.cpp;h=a86363b632a35f80ffa1c09885d4c79d315f1d70;hb=3756e70af69096a82b367ee9667e7720ca2201e4;hp=72e415cd66b66fbd1f40097312845df70fd493f9;hpb=1fd7096407d5e598ed3366a1141548e71273f1c5;p=oota-llvm.git diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp index 72e415cd66b..a86363b632a 100644 --- a/lib/VMCore/LLVMContextImpl.cpp +++ b/lib/VMCore/LLVMContextImpl.cpp @@ -1,4 +1,4 @@ -//===--------------- LLVMContextImpl.cpp - Implementation ------*- C++ -*--===// +//===-- LLVMContextImpl.cpp - Implement LLVMContextImpl -------------------===// // // The LLVM Compiler Infrastructure // @@ -7,118 +7,134 @@ // //===----------------------------------------------------------------------===// // -// This file implements LLVMContextImpl, the opaque implementation -// of LLVMContext. +// This file implements the opaque LLVMContextImpl. // //===----------------------------------------------------------------------===// #include "LLVMContextImpl.h" -#include "llvm/Constants.h" -#include "llvm/DerivedTypes.h" -#include "llvm/LLVMContext.h" -#include "llvm/MDNode.h" +#include "llvm/Attributes.h" +#include "llvm/Module.h" +#include "llvm/ADT/STLExtras.h" +#include using namespace llvm; -static char getValType(ConstantAggregateZero *CPZ) { return 0; } - -static std::vector getValType(ConstantVector *CP) { - std::vector Elements; - Elements.reserve(CP->getNumOperands()); - for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) - Elements.push_back(CP->getOperand(i)); - return Elements; +LLVMContextImpl::LLVMContextImpl(LLVMContext &C) + : TheTrueVal(0), TheFalseVal(0), + VoidTy(C, Type::VoidTyID), + LabelTy(C, Type::LabelTyID), + HalfTy(C, Type::HalfTyID), + FloatTy(C, Type::FloatTyID), + DoubleTy(C, Type::DoubleTyID), + MetadataTy(C, Type::MetadataTyID), + X86_FP80Ty(C, Type::X86_FP80TyID), + FP128Ty(C, Type::FP128TyID), + PPC_FP128Ty(C, Type::PPC_FP128TyID), + X86_MMXTy(C, Type::X86_MMXTyID), + Int1Ty(C, 1), + Int8Ty(C, 8), + Int16Ty(C, 16), + Int32Ty(C, 32), + Int64Ty(C, 64) { + InlineAsmDiagHandler = 0; + InlineAsmDiagContext = 0; + NamedStructTypesUniqueID = 0; } - -LLVMContextImpl::LLVMContextImpl(LLVMContext &C) : - Context(C), TheTrueVal(0), TheFalseVal(0) { } - -MDString *LLVMContextImpl::getMDString(const char *StrBegin, - unsigned StrLength) { - sys::SmartScopedWriter Writer(ConstantsLock); - StringMapEntry &Entry = - MDStringCache.GetOrCreateValue(StringRef(StrBegin, StrLength)); - MDString *&S = Entry.getValue(); - if (!S) S = new MDString(Entry.getKeyData(), - Entry.getKeyLength()); - - return S; +namespace { +struct DropReferences { + // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' + // is a Constant*. + template + void operator()(const PairT &P) { + P.second->dropAllReferences(); + } +}; + +// Temporary - drops pair.first instead of second. +struct DropFirst { + // Takes the value_type of a ConstantUniqueMap's internal map, whose 'second' + // is a Constant*. + template + void operator()(const PairT &P) { + P.first->dropAllReferences(); + } +}; } -MDNode *LLVMContextImpl::getMDNode(Value*const* Vals, unsigned NumVals) { - FoldingSetNodeID ID; - for (unsigned i = 0; i != NumVals; ++i) - ID.AddPointer(Vals[i]); - - ConstantsLock.reader_acquire(); - void *InsertPoint; - MDNode *N = MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); - ConstantsLock.reader_release(); +LLVMContextImpl::~LLVMContextImpl() { + // NOTE: We need to delete the contents of OwnedModules, but we have to + // duplicate it into a temporary vector, because the destructor of Module + // will try to remove itself from OwnedModules set. This would cause + // iterator invalidation if we iterated on the set directly. + std::vector Modules(OwnedModules.begin(), OwnedModules.end()); + DeleteContainerPointers(Modules); - if (!N) { - sys::SmartScopedWriter Writer(ConstantsLock); - N = MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint); - if (!N) { - // InsertPoint will have been set by the FindNodeOrInsertPos call. - N = new MDNode(Vals, NumVals); - MDNodeSet.InsertNode(N, InsertPoint); - } - } - - return N; + // Free the constants. This is important to do here to ensure that they are + // freed before the LeakDetector is torn down. + std::for_each(ExprConstants.map_begin(), ExprConstants.map_end(), + DropReferences()); + std::for_each(ArrayConstants.map_begin(), ArrayConstants.map_end(), + DropFirst()); + std::for_each(StructConstants.map_begin(), StructConstants.map_end(), + DropFirst()); + std::for_each(VectorConstants.map_begin(), VectorConstants.map_end(), + DropFirst()); + ExprConstants.freeConstants(); + ArrayConstants.freeConstants(); + StructConstants.freeConstants(); + VectorConstants.freeConstants(); + DeleteContainerSeconds(CAZConstants); + DeleteContainerSeconds(CPNConstants); + DeleteContainerSeconds(UVConstants); + InlineAsms.freeConstants(); + DeleteContainerSeconds(IntConstants); + DeleteContainerSeconds(FPConstants); + + for (StringMap::iterator I = CDSConstants.begin(), + E = CDSConstants.end(); I != E; ++I) + delete I->second; + CDSConstants.clear(); + + // Destroy attributes. + for (FoldingSetIterator I = AttrsSet.begin(), + E = AttrsSet.end(); I != E; ++I) + delete &*I; + + // Destroy MDNodes. ~MDNode can move and remove nodes between the MDNodeSet + // and the NonUniquedMDNodes sets, so copy the values out first. + SmallVector MDNodes; + MDNodes.reserve(MDNodeSet.size() + NonUniquedMDNodes.size()); + for (FoldingSetIterator I = MDNodeSet.begin(), E = MDNodeSet.end(); + I != E; ++I) + MDNodes.push_back(&*I); + MDNodes.append(NonUniquedMDNodes.begin(), NonUniquedMDNodes.end()); + for (SmallVectorImpl::iterator I = MDNodes.begin(), + E = MDNodes.end(); I != E; ++I) + (*I)->destroy(); + assert(MDNodeSet.empty() && NonUniquedMDNodes.empty() && + "Destroying all MDNodes didn't empty the Context's sets."); + + // Destroy MDStrings. + DeleteContainerSeconds(MDStringCache); } -ConstantAggregateZero* -LLVMContextImpl::getConstantAggregateZero(const Type *Ty) { - assert((isa(Ty) || isa(Ty) || isa(Ty)) && - "Cannot create an aggregate zero of non-aggregate type!"); +// ConstantsContext anchors +void UnaryConstantExpr::anchor() { } - // Implicitly locked. - return AggZeroConstants.getOrCreate(Ty, 0); -} +void BinaryConstantExpr::anchor() { } -Constant *LLVMContextImpl::getConstantVector(const VectorType *Ty, - const std::vector &V) { - assert(!V.empty() && "Vectors can't be empty"); - // If this is an all-undef or alll-zero vector, return a - // ConstantAggregateZero or UndefValue. - Constant *C = V[0]; - bool isZero = C->isNullValue(); - bool isUndef = isa(C); - - if (isZero || isUndef) { - for (unsigned i = 1, e = V.size(); i != e; ++i) - if (V[i] != C) { - isZero = isUndef = false; - break; - } - } - - if (isZero) - return Context.getConstantAggregateZero(Ty); - if (isUndef) - return Context.getUndef(Ty); - - // Implicitly locked. - return VectorConstants.getOrCreate(Ty, V); -} +void SelectConstantExpr::anchor() { } -// *** erase methods *** +void ExtractElementConstantExpr::anchor() { } -void LLVMContextImpl::erase(MDString *M) { - sys::SmartScopedWriter Writer(ConstantsLock); - MDStringCache.erase(MDStringCache.find(M->getString())); -} +void InsertElementConstantExpr::anchor() { } -void LLVMContextImpl::erase(MDNode *M) { - sys::SmartScopedWriter Writer(ConstantsLock); - MDNodeSet.RemoveNode(M); -} +void ShuffleVectorConstantExpr::anchor() { } -void LLVMContextImpl::erase(ConstantAggregateZero *Z) { - AggZeroConstants.remove(Z); -} +void ExtractValueConstantExpr::anchor() { } -void LLVMContextImpl::erase(ConstantVector *V) { - VectorConstants.remove(V); -} +void InsertValueConstantExpr::anchor() { } + +void GetElementPtrConstantExpr::anchor() { } + +void CompareConstantExpr::anchor() { }