revert r148691 and 148693

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148698 91177308-0d34-0410-b5e6-96231b3b80d8

lib/VMCore/Constants.cpp

@@ -993,33 +993,18 @@ bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
 //===----------------------------------------------------------------------===//
 //                      Factory Function Implementation
 
-ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
+ConstantAggregateZero* ConstantAggregateZero::get(Type* Ty) {
   assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) &&
          "Cannot create an aggregate zero of non-aggregate type!");
   
-  OwningPtr<ConstantAggregateZero> &Entry =
-    Ty->getContext().pImpl->CAZConstants[Ty];
-  if (Entry == 0)
-    Entry.reset(new ConstantAggregateZero(Ty));
-  
-  return Entry.get();
+  LLVMContextImpl *pImpl = Ty->getContext().pImpl;
+  return pImpl->AggZeroConstants.getOrCreate(Ty, 0);
 }
 
 /// destroyConstant - Remove the constant from the constant table...
 ///
 void ConstantAggregateZero::destroyConstant() {
-  // Drop ownership of the CAZ object before removing the entry so that it
-  // doesn't get double deleted.
-  LLVMContextImpl::CAZMapTy &CAZConstants = getContext().pImpl->CAZConstants;
-  LLVMContextImpl::CAZMapTy::iterator I = CAZConstants.find(getType());
-  assert(I != CAZConstants.end() && "CAZ object not in uniquing map");
-  I->second.take();
-  
-  // Actually remove the entry from the DenseMap now, which won't free the
-  // constant.
-  CAZConstants.erase(I);
-  
-  // Free the constant and any dangling references to it.
+  getType()->getContext().pImpl->AggZeroConstants.remove(this);
   destroyConstantImpl();
 }
 
@@ -1127,29 +1112,13 @@ Constant *ConstantVector::getSplatValue() const {
 //
 
 ConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) {
-  OwningPtr<ConstantPointerNull> &Entry =
-    Ty->getContext().pImpl->CPNConstants[Ty];
-  if (Entry == 0)
-    Entry.reset(new ConstantPointerNull(Ty));
-  
-  return Entry.get();
+  return Ty->getContext().pImpl->NullPtrConstants.getOrCreate(Ty, 0);
 }
 
 // destroyConstant - Remove the constant from the constant table...
 //
 void ConstantPointerNull::destroyConstant() {
-  // Drop ownership of the CPN object before removing the entry so that it
-  // doesn't get double deleted.
-  LLVMContextImpl::CPNMapTy &CPNConstants = getContext().pImpl->CPNConstants;
-  LLVMContextImpl::CPNMapTy::iterator I = CPNConstants.find(getType());
-  assert(I != CPNConstants.end() && "CPN object not in uniquing map");
-  I->second.take();
-  
-  // Actually remove the entry from the DenseMap now, which won't free the
-  // constant.
-  CPNConstants.erase(I);
-  
-  // Free the constant and any dangling references to it.
+  getType()->getContext().pImpl->NullPtrConstants.remove(this);
   destroyConstantImpl();
 }
 
@@ -1158,28 +1127,13 @@ void ConstantPointerNull::destroyConstant() {
 //
 
 UndefValue *UndefValue::get(Type *Ty) {
-  OwningPtr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
-  if (Entry == 0)
-    Entry.reset(new UndefValue(Ty));
-  
-  return Entry.get();
+  return Ty->getContext().pImpl->UndefValueConstants.getOrCreate(Ty, 0);
 }
 
 // destroyConstant - Remove the constant from the constant table.
 //
 void UndefValue::destroyConstant() {
-  // Drop ownership of the object before removing the entry so that it
-  // doesn't get double deleted.
-  LLVMContextImpl::UVMapTy &UVConstants = getContext().pImpl->UVConstants;
-  LLVMContextImpl::UVMapTy::iterator I = UVConstants.find(getType());
-  assert(I != UVConstants.end() && "UV object not in uniquing map");
-  I->second.take();
-  
-  // Actually remove the entry from the DenseMap now, which won't free the
-  // constant.
-  UVConstants.erase(I);
-  
-  // Free the constant and any dangling references to it.
+  getType()->getContext().pImpl->UndefValueConstants.remove(this);
   destroyConstantImpl();
 }
 

lib/VMCore/ConstantsContext.h

@@ -477,6 +477,13 @@ struct ConstantKeyData<ConstantExpr> {
   }
 };
 
+// ConstantAggregateZero does not take extra "value" argument...
+template<class ValType>
+struct ConstantCreator<ConstantAggregateZero, Type, ValType> {
+  static ConstantAggregateZero *create(Type *Ty, const ValType &V){
+    return new ConstantAggregateZero(Ty);
+  }
+};
 
 template<>
 struct ConstantKeyData<ConstantVector> {
@@ -490,6 +497,14 @@ struct ConstantKeyData<ConstantVector> {
   }
 };
 
+template<>
+struct ConstantKeyData<ConstantAggregateZero> {
+  typedef char ValType;
+  static ValType getValType(ConstantAggregateZero *C) {
+    return 0;
+  }
+};
+
 template<>
 struct ConstantKeyData<ConstantArray> {
   typedef std::vector<Constant*> ValType;
@@ -514,6 +529,37 @@ struct ConstantKeyData<ConstantStruct> {
   }
 };
 
+// ConstantPointerNull does not take extra "value" argument...
+template<class ValType>
+struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
+  static ConstantPointerNull *create(PointerType *Ty, const ValType &V){
+    return new ConstantPointerNull(Ty);
+  }
+};
+
+template<>
+struct ConstantKeyData<ConstantPointerNull> {
+  typedef char ValType;
+  static ValType getValType(ConstantPointerNull *C) {
+    return 0;
+  }
+};
+
+// UndefValue does not take extra "value" argument...
+template<class ValType>
+struct ConstantCreator<UndefValue, Type, ValType> {
+  static UndefValue *create(Type *Ty, const ValType &V) {
+    return new UndefValue(Ty);
+  }
+};
+
+template<>
+struct ConstantKeyData<UndefValue> {
+  typedef char ValType;
+  static ValType getValType(UndefValue *C) {
+    return 0;
+  }
+};
 
 template<>
 struct ConstantCreator<InlineAsm, PointerType, InlineAsmKeyType> {

lib/VMCore/LLVMContextImpl.cpp

@@ -58,8 +58,6 @@ LLVMContextImpl::~LLVMContextImpl() {
   std::vector<Module*> Modules(OwnedModules.begin(), OwnedModules.end());
   DeleteContainerPointers(Modules);
   
-  // 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(),
@@ -72,9 +70,9 @@ LLVMContextImpl::~LLVMContextImpl() {
   ArrayConstants.freeConstants();
   StructConstants.freeConstants();
   VectorConstants.freeConstants();
-  CAZConstants.clear();
-  CPNConstants.clear();
-  UVConstants.clear();
+  AggZeroConstants.freeConstants();
+  NullPtrConstants.freeConstants();
+  UndefValueConstants.freeConstants();
   InlineAsms.freeConstants();
   DeleteContainerSeconds(IntConstants);
   DeleteContainerSeconds(FPConstants);

lib/VMCore/LLVMContextImpl.h

@@ -27,7 +27,6 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include <vector>
@@ -139,8 +138,7 @@ public:
   // on Context destruction.
   SmallPtrSet<MDNode*, 1> NonUniquedMDNodes;
   
-  typedef DenseMap<Type*, OwningPtr<ConstantAggregateZero> > CAZMapTy;
-  CAZMapTy CAZConstants;
+  ConstantUniqueMap<char, char, Type, ConstantAggregateZero> AggZeroConstants;
 
   typedef ConstantUniqueMap<std::vector<Constant*>, ArrayRef<Constant*>,
     ArrayType, ConstantArray, true /*largekey*/> ArrayConstantsTy;
@@ -154,11 +152,9 @@ public:
                             VectorType, ConstantVector> VectorConstantsTy;
   VectorConstantsTy VectorConstants;
   
-  typedef DenseMap<PointerType*, OwningPtr<ConstantPointerNull> > CPNMapTy;
-  CPNMapTy CPNConstants;
-
-  typedef DenseMap<Type*, OwningPtr<UndefValue> > UVMapTy;
-  UVMapTy UVConstants;
+  ConstantUniqueMap<char, char, PointerType, ConstantPointerNull>
+    NullPtrConstants;
+  ConstantUniqueMap<char, char, Type, UndefValue> UndefValueConstants;
   
   DenseMap<std::pair<Function*, BasicBlock*> , BlockAddress*> BlockAddresses;
   ConstantUniqueMap<ExprMapKeyType, const ExprMapKeyType&, Type, ConstantExpr>