Privatize the ConstantVector tables.

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

include/llvm/Constants.h

@@ -390,9 +390,6 @@ class ConstantVector : public Constant {
 protected:
   ConstantVector(const VectorType *T, const std::vector<Constant*> &Val);
 public:
-  /// get() - Static factory methods - Return objects of the specified value
-  static Constant *get(const VectorType *T, const std::vector<Constant*> &);
-  
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 

include/llvm/LLVMContext.h

@@ -276,6 +276,7 @@ public:
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *Z);
   void erase(ConstantStruct *S);
+  void erase(ConstantVector *V);
   
   // RAUW helpers
   Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,

lib/VMCore/Constants.cpp

@@ -1107,66 +1107,11 @@ void ConstantStruct::destroyConstant() {
   destroyConstantImpl();
 }
 
-//---- ConstantVector::get() implementation...
-//
-namespace llvm {
-  template<>
-  struct ConvertConstantType<ConstantVector, VectorType> {
-    static void convert(ConstantVector *OldC, const VectorType *NewTy) {
-      // Make everyone now use a constant of the new type...
-      std::vector<Constant*> C;
-      for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
-        C.push_back(cast<Constant>(OldC->getOperand(i)));
-      Constant *New = ConstantVector::get(NewTy, C);
-      assert(New != OldC && "Didn't replace constant??");
-      OldC->uncheckedReplaceAllUsesWith(New);
-      OldC->destroyConstant();    // This constant is now dead, destroy it.
-    }
-  };
-}
-
-static std::vector<Constant*> getValType(ConstantVector *CP) {
-  std::vector<Constant*> Elements;
-  Elements.reserve(CP->getNumOperands());
-  for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
-    Elements.push_back(CP->getOperand(i));
-  return Elements;
-}
-
-static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType,
-                              ConstantVector> > VectorConstants;
-
-Constant *ConstantVector::get(const VectorType *Ty,
-                              const std::vector<Constant*> &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<UndefValue>(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 Ty->getContext().getConstantAggregateZero(Ty);
-  if (isUndef)
-    return UndefValue::get(Ty);
-    
-  // Implicitly locked.
-  return VectorConstants->getOrCreate(Ty, V);
-}
-
 // destroyConstant - Remove the constant from the constant table...
 //
 void ConstantVector::destroyConstant() {
   // Implicitly locked.
-  VectorConstants->remove(this);
+  getType()->getContext().erase(this);
   destroyConstantImpl();
 }
 
@@ -2099,7 +2044,8 @@ void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To,
     Values.push_back(Val);
   }
   
-  Constant *Replacement = ConstantVector::get(getType(), Values);
+  Constant *Replacement =
+    getType()->getContext().getConstantVector(getType(), Values);
   assert(Replacement != this && "I didn't contain From!");
   
   // Everyone using this now uses the replacement.

lib/VMCore/LLVMContext.cpp

@@ -531,7 +531,7 @@ ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) {
 // ConstantVector accessors.
 Constant* LLVMContext::getConstantVector(const VectorType* T,
                             const std::vector<Constant*>& V) {
-  return ConstantVector::get(T, V);
+  return pImpl->getConstantVector(T, V);
 }
 
 Constant* LLVMContext::getConstantVector(const std::vector<Constant*>& V) {
@@ -662,6 +662,10 @@ void LLVMContext::erase(ConstantStruct *S) {
   pImpl->erase(S);
 }
 
+void LLVMContext::erase(ConstantVector *V) {
+  pImpl->erase(V);
+}
+
 Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA,
                                                Value *From, Value *To, Use *U) {
   return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);

lib/VMCore/LLVMContextImpl.cpp

@@ -37,6 +37,14 @@ static std::vector<Constant*> getValType(ConstantStruct *CS) {
   return Elements;
 }
 
+static std::vector<Constant*> getValType(ConstantVector *CP) {
+  std::vector<Constant*> Elements;
+  Elements.reserve(CP->getNumOperands());
+  for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
+    Elements.push_back(CP->getOperand(i));
+  return Elements;
+}
+
 namespace llvm {
 template<typename T, typename Alloc>
 struct VISIBILITY_HIDDEN ConstantTraits< std::vector<T, Alloc> > {
@@ -106,6 +114,20 @@ struct ConvertConstantType<ConstantStruct, StructType> {
     OldC->destroyConstant();    // This constant is now dead, destroy it.
   }
 };
+
+template<>
+struct ConvertConstantType<ConstantVector, VectorType> {
+  static void convert(ConstantVector *OldC, const VectorType *NewTy) {
+    // Make everyone now use a constant of the new type...
+    std::vector<Constant*> C;
+    for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
+      C.push_back(cast<Constant>(OldC->getOperand(i)));
+    Constant *New = OldC->getContext().getConstantVector(NewTy, C);
+    assert(New != OldC && "Didn't replace constant??");
+    OldC->uncheckedReplaceAllUsesWith(New);
+    OldC->destroyConstant();    // This constant is now dead, destroy it.
+  }
+};
 }
   
 template<class ValType, class TypeClass, class ConstantClass,
@@ -348,12 +370,14 @@ LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
   AggZeroConstants = new ValueMap<char, Type, ConstantAggregateZero>();
   ArrayConstants = new ArrayConstantsTy();
   StructConstants = new StructConstantsTy();
+  VectorConstants = new VectorConstantsTy();
 }
 
 LLVMContextImpl::~LLVMContextImpl() {
   delete AggZeroConstants;
   delete ArrayConstants;
   delete StructConstants;
+  delete VectorConstants;
 }
 
 // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap 
@@ -492,6 +516,32 @@ Constant *LLVMContextImpl::getConstantStruct(const StructType *Ty,
   return Context.getConstantAggregateZero(Ty);
 }
 
+Constant *LLVMContextImpl::getConstantVector(const VectorType *Ty,
+                              const std::vector<Constant*> &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<UndefValue>(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);
+}
+
 // *** erase methods ***
 
 void LLVMContextImpl::erase(MDString *M) {
@@ -517,6 +567,10 @@ void LLVMContextImpl::erase(ConstantStruct *S) {
   StructConstants->remove(S);
 }
 
+void LLVMContextImpl::erase(ConstantVector *V) {
+  VectorConstants->remove(V);
+}
+
 // *** RAUW helpers ***
 
 Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
@@ -659,4 +713,4 @@ Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantStruct *CS,
   assert(Replacement != CS && "I didn't contain From!");
   
   return Replacement;
-}
+}

lib/VMCore/LLVMContextImpl.h

@@ -122,6 +122,10 @@ class LLVMContextImpl {
                    ConstantStruct, true /*largekey*/> StructConstantsTy;
   StructConstantsTy *StructConstants;
   
+  typedef ValueMap<std::vector<Constant*>, VectorType,
+                   ConstantVector> VectorConstantsTy;
+  VectorConstantsTy *VectorConstants;
+  
   LLVMContext &Context;
   ConstantInt *TheTrueVal;
   ConstantInt *TheFalseVal;
@@ -150,6 +154,9 @@ public:
   Constant *getConstantStruct(const StructType *Ty, 
                               const std::vector<Constant*> &V);
   
+  Constant *getConstantVector(const VectorType *Ty,
+                              const std::vector<Constant*> &V);
+  
   ConstantInt *getTrue() {
     if (TheTrueVal)
       return TheTrueVal;
@@ -169,6 +176,7 @@ public:
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *C);
   void erase(ConstantStruct *S);
+  void erase(ConstantVector *V);
   
   // RAUW helpers