From ba3ddf391f5149b8fca073adc3cbca361353929c Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Fri, 15 Jul 2011 05:49:15 +0000 Subject: [PATCH] bump pointer allocate LLVM IR types, since they are never deallocated. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135248 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/VMCore/LLVMContextImpl.cpp | 16 -------------- lib/VMCore/LLVMContextImpl.h | 6 +++++- lib/VMCore/Type.cpp | 39 ++++++++++++++++------------------ 3 files changed, 23 insertions(+), 38 deletions(-) diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp index 2b6bb39167a..504b37267f7 100644 --- a/lib/VMCore/LLVMContextImpl.cpp +++ b/lib/VMCore/LLVMContextImpl.cpp @@ -91,20 +91,4 @@ LLVMContextImpl::~LLVMContextImpl() { "Destroying all MDNodes didn't empty the Context's sets."); // Destroy MDStrings. DeleteContainerSeconds(MDStringCache); - - // Destroy types. - DeleteContainerSeconds(IntegerTypes); - DeleteContainerSeconds(FunctionTypes); - DeleteContainerSeconds(AnonStructTypes); - DeleteContainerSeconds(ArrayTypes); - DeleteContainerSeconds(VectorTypes); - DeleteContainerSeconds(PointerTypes); - DeleteContainerSeconds(ASPointerTypes); - - for (StringMap::iterator I = NamedStructTypes.begin(), - E = NamedStructTypes.end(); I != E; ++I) - delete I->getValue(); - for (SmallPtrSet::iterator I = EmptyNamedStructTypes.begin(), - E = EmptyNamedStructTypes.end(); I != E; ++I) - delete *I; } diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index b26068d85f7..06a6f2a25a3 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -173,13 +173,17 @@ public: Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy; IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty; + + /// TypeAllocator - All dynamically allocated types are allocated from this. + /// They live forever until the context is torn down. + BumpPtrAllocator TypeAllocator; + DenseMap IntegerTypes; // TODO: Optimize FunctionTypes/AnonStructTypes! std::map, FunctionType*> FunctionTypes; std::map, StructType*> AnonStructTypes; StringMap NamedStructTypes; - SmallPtrSet EmptyNamedStructTypes; unsigned NamedStructTypesUniqueID; DenseMap, ArrayType*> ArrayTypes; diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index dc5053acc24..f874d1b2830 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -288,7 +288,7 @@ IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) { IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits]; if (Entry == 0) - Entry = new IntegerType(C, NumBits); + Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits); return Entry; } @@ -337,11 +337,13 @@ FunctionType *FunctionType::get(const Type *ReturnType, if (isVarArg) Key.push_back(0); - FunctionType *&FT = ReturnType->getContext().pImpl->FunctionTypes[Key]; + LLVMContextImpl *pImpl = ReturnType->getContext().pImpl; + FunctionType *&FT = pImpl->FunctionTypes[Key]; if (FT == 0) { - FT = (FunctionType*) operator new(sizeof(FunctionType) + - sizeof(Type*)*(Params.size()+1)); + FT = (FunctionType*) pImpl->TypeAllocator. + Allocate(sizeof(FunctionType) + sizeof(Type*)*(Params.size()+1), + AlignOf::Alignment); new (FT) FunctionType(ReturnType, Params, isVarArg); } @@ -386,11 +388,10 @@ StructType *StructType::get(LLVMContext &Context, ArrayRef ETypes, Key.push_back(0); StructType *&ST = Context.pImpl->AnonStructTypes[Key]; - if (ST) return ST; // Value not found. Create a new type! - ST = new StructType(Context); + ST = new (Context.pImpl->TypeAllocator) StructType(Context); ST->setSubclassData(SCDB_IsAnonymous); // Anonymous struct. ST->setBody(ETypes, isPacked); return ST; @@ -403,7 +404,8 @@ void StructType::setBody(ArrayRef Elements, bool isPacked) { if (isPacked) setSubclassData(getSubclassData() | SCDB_Packed); - Type **Elts = new Type*[Elements.size()]; + Type **Elts = getContext().pImpl-> + TypeAllocator.Allocate(Elements.size()); memcpy(Elts, Elements.data(), sizeof(Elements[0])*Elements.size()); ContainedTys = Elts; @@ -411,11 +413,9 @@ void StructType::setBody(ArrayRef Elements, bool isPacked) { } StructType *StructType::createNamed(LLVMContext &Context, StringRef Name) { - StructType *ST = new StructType(Context); + StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context); if (!Name.empty()) ST->setName(Name); - else - Context.pImpl->EmptyNamedStructTypes.insert(ST); return ST; } @@ -426,16 +426,11 @@ void StructType::setName(StringRef Name) { if (SymbolTableEntry) { getContext().pImpl->NamedStructTypes.erase(getName()); SymbolTableEntry = 0; - } else { - getContext().pImpl->EmptyNamedStructTypes.erase(this); } // If this is just removing the name, we're done. - if (Name.empty()) { - // Keep track of types with no names so we can free them. - getContext().pImpl->EmptyNamedStructTypes.insert(this); + if (Name.empty()) return; - } // Look up the entry for the name. StringMapEntry *Entry = @@ -614,11 +609,12 @@ ArrayType *ArrayType::get(const Type *elementType, uint64_t NumElements) { Type *ElementType = const_cast(elementType); assert(isValidElementType(ElementType) && "Invalid type for array element!"); - ArrayType *&Entry = ElementType->getContext().pImpl - ->ArrayTypes[std::make_pair(ElementType, NumElements)]; + LLVMContextImpl *pImpl = ElementType->getContext().pImpl; + ArrayType *&Entry = + pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)]; if (Entry == 0) - Entry = new ArrayType(ElementType, NumElements); + Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements); return Entry; } @@ -642,11 +638,12 @@ VectorType *VectorType::get(const Type *elementType, unsigned NumElements) { assert(isValidElementType(ElementType) && "Elements of a VectorType must be a primitive type"); + LLVMContextImpl *pImpl = ElementType->getContext().pImpl; VectorType *&Entry = ElementType->getContext().pImpl ->VectorTypes[std::make_pair(ElementType, NumElements)]; if (Entry == 0) - Entry = new VectorType(ElementType, NumElements); + Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements); return Entry; } @@ -670,7 +667,7 @@ PointerType *PointerType::get(const Type *eltTy, unsigned AddressSpace) { : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)]; if (Entry == 0) - Entry = new PointerType(EltTy, AddressSpace); + Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace); return Entry; }