Privatize the ConstantStruct table.

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

include/llvm/Constants.h

@@ -344,13 +344,10 @@ class ConstantStruct : public Constant {
   friend struct ConstantCreator<ConstantStruct, StructType,
                                     std::vector<Constant*> >;
   ConstantStruct(const ConstantStruct &);      // DO NOT IMPLEMENT
+  friend class LLVMContextImpl;
 protected:
   ConstantStruct(const StructType *T, const std::vector<Constant*> &Val);
 public:
-  /// get() - Static factory methods - Return objects of the specified value
-  ///
-  static Constant *get(const StructType *T, const std::vector<Constant*> &V);
-  
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 

include/llvm/LLVMContext.h

@@ -275,10 +275,13 @@ public:
   void erase(MDNode *M);
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *Z);
+  void erase(ConstantStruct *S);
   
   // RAUW helpers
   Constant *replaceUsesOfWithOnConstant(ConstantArray *CA,
                                              Value *From, Value *To, Use *U);
+  Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
+                                        Value *To, Use *U);
 };
 
 /// FOR BACKWARDS COMPATIBILITY - Returns a global context.

lib/VMCore/Constants.cpp

@@ -1096,50 +1096,14 @@ std::string ConstantArray::getAsString() const {
 //
 
 namespace llvm {
-  template<>
-  struct ConvertConstantType<ConstantStruct, StructType> {
-    static void convert(ConstantStruct *OldC, const StructType *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 = ConstantStruct::get(NewTy, C);
-      assert(New != OldC && "Didn't replace constant??");
 
-      OldC->uncheckedReplaceAllUsesWith(New);
-      OldC->destroyConstant();    // This constant is now dead, destroy it.
-    }
-  };
-}
-
-typedef ValueMap<std::vector<Constant*>, StructType,
-                 ConstantStruct, true /*largekey*/> StructConstantsTy;
-static ManagedStatic<StructConstantsTy> StructConstants;
-
-static std::vector<Constant*> getValType(ConstantStruct *CS) {
-  std::vector<Constant*> Elements;
-  Elements.reserve(CS->getNumOperands());
-  for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
-    Elements.push_back(cast<Constant>(CS->getOperand(i)));
-  return Elements;
-}
-
-Constant *ConstantStruct::get(const StructType *Ty,
-                              const std::vector<Constant*> &V) {
-  // Create a ConstantAggregateZero value if all elements are zeros...
-  for (unsigned i = 0, e = V.size(); i != e; ++i)
-    if (!V[i]->isNullValue())
-      // Implicitly locked.
-      return StructConstants->getOrCreate(Ty, V);
-
-  return Ty->getContext().getConstantAggregateZero(Ty);
 }
 
 // destroyConstant - Remove the constant from the constant table...
 //
 void ConstantStruct::destroyConstant() {
   // Implicitly locked.
-  StructConstants->remove(this);
+  getType()->getContext().erase(this);
   destroyConstantImpl();
 }
 
@@ -2112,61 +2076,9 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
 
 void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
                                                  Use *U) {
-  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
+  Constant* Replacement =
-  Constant *ToC = cast<Constant>(To);
+    getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U);
-
+  if (!Replacement) return;
-  unsigned OperandToUpdate = U-OperandList;
-  assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
-
-  std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
-  Lookup.first.first = getType();
-  Lookup.second = this;
-  std::vector<Constant*> &Values = Lookup.first.second;
-  Values.reserve(getNumOperands());  // Build replacement struct.
-  
-  
-  // Fill values with the modified operands of the constant struct.  Also, 
-  // compute whether this turns into an all-zeros struct.
-  bool isAllZeros = false;
-  if (!ToC->isNullValue()) {
-    for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O)
-      Values.push_back(cast<Constant>(O->get()));
-  } else {
-    isAllZeros = true;
-    for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
-      Constant *Val = cast<Constant>(O->get());
-      Values.push_back(Val);
-      if (isAllZeros) isAllZeros = Val->isNullValue();
-    }
-  }
-  Values[OperandToUpdate] = ToC;
-  
-  Constant *Replacement = 0;
-  if (isAllZeros) {
-    Replacement = getType()->getContext().getConstantAggregateZero(getType());
-  } else {
-    // Check to see if we have this array type already.
-    sys::SmartScopedWriter<true> Writer(*ConstantsLock);
-    bool Exists;
-    StructConstantsTy::MapTy::iterator I =
-      StructConstants->InsertOrGetItem(Lookup, Exists);
-    
-    if (Exists) {
-      Replacement = I->second;
-    } else {
-      // Okay, the new shape doesn't exist in the system yet.  Instead of
-      // creating a new constant struct, inserting it, replaceallusesof'ing the
-      // old with the new, then deleting the old... just update the current one
-      // in place!
-      StructConstants->MoveConstantToNewSlot(this, I);
-      
-      // Update to the new value.
-      setOperand(OperandToUpdate, ToC);
-      return;
-    }
-  }
-  
-  assert(Replacement != this && "I didn't contain From!");
   
   // Everyone using this now uses the replacement.
   uncheckedReplaceAllUsesWith(Replacement);

lib/VMCore/LLVMContext.cpp

@@ -146,7 +146,7 @@ ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
 // ConstantStruct accessors.
 Constant* LLVMContext::getConstantStruct(const StructType* T,
                                          const std::vector<Constant*>& V) {
-  return ConstantStruct::get(T, V);
+  return pImpl->getConstantStruct(T, V);
 }
 
 Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
@@ -658,7 +658,16 @@ void LLVMContext::erase(ConstantArray *C) {
   pImpl->erase(C);
 }
 
+void LLVMContext::erase(ConstantStruct *S) {
+  pImpl->erase(S);
+}
+
 Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA,
                                                Value *From, Value *To, Use *U) {
   return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);
 }
+
+Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantStruct *CS,
+                                               Value *From, Value *To, Use *U) {
+  return pImpl->replaceUsesOfWithOnConstant(CS, From, To, U);
+}

lib/VMCore/LLVMContextImpl.cpp

@@ -29,6 +29,14 @@ static std::vector<Constant*> getValType(ConstantArray *CA) {
   return Elements;
 }
 
+static std::vector<Constant*> getValType(ConstantStruct *CS) {
+  std::vector<Constant*> Elements;
+  Elements.reserve(CS->getNumOperands());
+  for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i)
+    Elements.push_back(cast<Constant>(CS->getOperand(i)));
+  return Elements;
+}
+
 namespace llvm {
 template<typename T, typename Alloc>
 struct VISIBILITY_HIDDEN ConstantTraits< std::vector<T, Alloc> > {
@@ -83,6 +91,21 @@ struct ConvertConstantType<ConstantArray, ArrayType> {
     OldC->destroyConstant();    // This constant is now dead, destroy it.
   }
 };
+
+template<>
+struct ConvertConstantType<ConstantStruct, StructType> {
+  static void convert(ConstantStruct *OldC, const StructType *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 = NewTy->getContext().getConstantStruct(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,
@@ -324,11 +347,13 @@ LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
     Context(C), TheTrueVal(0), TheFalseVal(0) {
   AggZeroConstants = new ValueMap<char, Type, ConstantAggregateZero>();
   ArrayConstants = new ArrayConstantsTy();
+  StructConstants = new StructConstantsTy();
 }
 
 LLVMContextImpl::~LLVMContextImpl() {
   delete AggZeroConstants;
   delete ArrayConstants;
+  delete StructConstants;
 }
 
 // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap 
@@ -456,6 +481,17 @@ Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty,
   return Context.getConstantAggregateZero(Ty);
 }
 
+Constant *LLVMContextImpl::getConstantStruct(const StructType *Ty,
+                              const std::vector<Constant*> &V) {
+  // Create a ConstantAggregateZero value if all elements are zeros...
+  for (unsigned i = 0, e = V.size(); i != e; ++i)
+    if (!V[i]->isNullValue())
+      // Implicitly locked.
+      return StructConstants->getOrCreate(Ty, V);
+
+  return Context.getConstantAggregateZero(Ty);
+}
+
 // *** erase methods ***
 
 void LLVMContextImpl::erase(MDString *M) {
@@ -477,7 +513,12 @@ void LLVMContextImpl::erase(ConstantArray *C) {
   ArrayConstants->remove(C);
 }
 
+void LLVMContextImpl::erase(ConstantStruct *S) {
+  StructConstants->remove(S);
+}
+
 // *** RAUW helpers ***
+
 Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
                                                Value *From, Value *To, Use *U) {
   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
@@ -556,3 +597,66 @@ Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA,
   return Replacement;
 }
 
+Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantStruct *CS,
+                                               Value *From, Value *To, Use *U) {
+  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
+  Constant *ToC = cast<Constant>(To);
+
+  unsigned OperandToUpdate = U - CS->OperandList;
+  assert(CS->getOperand(OperandToUpdate) == From &&
+         "ReplaceAllUsesWith broken!");
+
+  std::pair<StructConstantsTy::MapKey, Constant*> Lookup;
+  Lookup.first.first = CS->getType();
+  Lookup.second = CS;
+  std::vector<Constant*> &Values = Lookup.first.second;
+  Values.reserve(CS->getNumOperands());  // Build replacement struct.
+  
+  
+  // Fill values with the modified operands of the constant struct.  Also, 
+  // compute whether this turns into an all-zeros struct.
+  bool isAllZeros = false;
+  if (!ToC->isNullValue()) {
+    for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands(); 
+         O != E; ++O)
+      Values.push_back(cast<Constant>(O->get()));
+  } else {
+    isAllZeros = true;
+    for (Use *O = CS->OperandList, *E = CS->OperandList + CS->getNumOperands(); 
+         O != E; ++O) {
+      Constant *Val = cast<Constant>(O->get());
+      Values.push_back(Val);
+      if (isAllZeros) isAllZeros = Val->isNullValue();
+    }
+  }
+  Values[OperandToUpdate] = ToC;
+  
+  Constant *Replacement = 0;
+  if (isAllZeros) {
+    Replacement = Context.getConstantAggregateZero(CS->getType());
+  } else {
+    // Check to see if we have this array type already.
+    sys::SmartScopedWriter<true> Writer(ConstantsLock);
+    bool Exists;
+    StructConstantsTy::MapTy::iterator I =
+      StructConstants->InsertOrGetItem(Lookup, Exists);
+    
+    if (Exists) {
+      Replacement = I->second;
+    } else {
+      // Okay, the new shape doesn't exist in the system yet.  Instead of
+      // creating a new constant struct, inserting it, replaceallusesof'ing the
+      // old with the new, then deleting the old... just update the current one
+      // in place!
+      StructConstants->MoveConstantToNewSlot(CS, I);
+      
+      // Update to the new value.
+      CS->setOperand(OperandToUpdate, ToC);
+      return 0;
+    }
+  }
+  
+  assert(Replacement != CS && "I didn't contain From!");
+  
+  return Replacement;
+}

lib/VMCore/LLVMContextImpl.h

@@ -27,6 +27,7 @@
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/StringMap.h"
 #include <map>
+#include <vector>
 
 template<class ValType, class TypeClass, class ConstantClass,
          bool HasLargeKey = false  /*true for arrays and structs*/ >
@@ -117,6 +118,10 @@ class LLVMContextImpl {
     ConstantArray, true /*largekey*/> ArrayConstantsTy;
   ArrayConstantsTy *ArrayConstants;
   
+  typedef ValueMap<std::vector<Constant*>, StructType,
+                   ConstantStruct, true /*largekey*/> StructConstantsTy;
+  StructConstantsTy *StructConstants;
+  
   LLVMContext &Context;
   ConstantInt *TheTrueVal;
   ConstantInt *TheFalseVal;
@@ -142,6 +147,9 @@ public:
   Constant *getConstantArray(const ArrayType *Ty,
                              const std::vector<Constant*> &V);
   
+  Constant *getConstantStruct(const StructType *Ty, 
+                              const std::vector<Constant*> &V);
+  
   ConstantInt *getTrue() {
     if (TheTrueVal)
       return TheTrueVal;
@@ -160,11 +168,14 @@ public:
   void erase(MDNode *M);
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *C);
+  void erase(ConstantStruct *S);
   
   // RAUW helpers
   
   Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From,
                                              Value *To, Use *U);
+  Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
+                                        Value *To, Use *U);
 };
 
 }