Move ConstantStruct back to 2.5 API.

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

16 files changed, 129 insertions, 179 deletions

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index f7b785aff3..af7187d95f 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -385,10 +385,15 @@ 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:
+  // ConstantStruct accessors
+  static Constant* get(const StructType* T, const std::vector<Constant*>& V);
+  static Constant* get(const std::vector<Constant*>& V, bool Packed = false);
+  static Constant* get(Constant* const *Vals, unsigned NumVals,
+                       bool Packed = false);
+  
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 
diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index 37f0cd1a44..8465e4d95a 100644
--- a/include/llvm/LLVMContext.h
+++ b/include/llvm/LLVMContext.h
@@ -57,6 +57,7 @@ class LLVMContext {
   
   friend class ConstantInt;
   friend class ConstantFP;
+  friend class ConstantStruct;
 public:
   LLVMContext();
   ~LLVMContext();
@@ -78,14 +79,6 @@ public:
   
   // ConstantPointerNull accessors
   ConstantPointerNull* getConstantPointerNull(const PointerType* T);
-  
-  // ConstantStruct accessors
-  Constant* getConstantStruct(const StructType* T,
-                              const std::vector<Constant*>& V);
-  Constant* getConstantStruct(const std::vector<Constant*>& V,
-                              bool Packed = false);
-  Constant* getConstantStruct(Constant* const *Vals, unsigned NumVals,
-                              bool Packed = false);
                               
   // ConstantAggregateZero accessors
   ConstantAggregateZero* getConstantAggregateZero(const Type* Ty);
@@ -233,14 +226,11 @@ public:
   void erase(MDNode *M);
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *Z);
-  void erase(ConstantStruct *S);
   void erase(ConstantVector *V);
   
   // 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.
diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp
index 61c9a4af3e..47a561bc29 100644
--- a/lib/Analysis/DebugInfo.cpp
+++ b/lib/Analysis/DebugInfo.cpp
@@ -545,8 +545,7 @@ DISubrange DIFactory::GetOrCreateSubrange(int64_t Lo, int64_t Hi) {
     ConstantInt::get(Type::Int64Ty, Hi)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts, 
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
 
   // If we already have this range, just return the uniqued version.
   DIDescriptor &Entry = SimpleConstantCache[Init];
@@ -587,8 +586,7 @@ DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
     ConstantInt::get(Type::Int32Ty, RunTimeVer)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.compile_unit.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -606,8 +604,7 @@ DIEnumerator DIFactory::CreateEnumerator(const std::string &Name, uint64_t Val){
     ConstantInt::get(Type::Int64Ty, Val)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.enumerator.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -640,8 +637,7 @@ DIBasicType DIFactory::CreateBasicType(DIDescriptor Context,
     ConstantInt::get(Type::Int32Ty, Encoding)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.basictype.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -676,8 +672,7 @@ DIDerivedType DIFactory::CreateDerivedType(unsigned Tag,
     getCastToEmpty(DerivedFrom)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.derivedtype.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -716,8 +711,7 @@ DICompositeType DIFactory::CreateCompositeType(unsigned Tag,
     ConstantInt::get(Type::Int32Ty, RuntimeLang)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.composite.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -754,8 +748,7 @@ DISubprogram DIFactory::CreateSubprogram(DIDescriptor Context,
     ConstantInt::get(Type::Int1Ty, isDefinition)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.subprogram.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -788,8 +781,7 @@ DIFactory::CreateGlobalVariable(DIDescriptor Context, const std::string &Name,
     VMContext.getConstantExprBitCast(Val, EmptyStructPtr)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.global_variable.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -814,8 +806,7 @@ DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
     getCastToEmpty(Type)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.variable.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
@@ -834,8 +825,7 @@ DIBlock DIFactory::CreateBlock(DIDescriptor Context) {
     getCastToEmpty(Context)
   };
   
-  Constant *Init = VMContext.getConstantStruct(Elts,
-                                             sizeof(Elts)/sizeof(Elts[0]));
+  Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
   
   M.addTypeName("llvm.dbg.block.type", Init->getType());
   GlobalVariable *GV = new GlobalVariable(M, Init->getType(), true,
diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index adcd79f40a..6a4e5c1950 100644
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -1737,7 +1737,7 @@ bool LLParser::ParseValID(ValID &ID) {
         ParseToken(lltok::rbrace, "expected end of struct constant"))
       return true;
     
-    ID.ConstantVal = Context.getConstantStruct(Elts.data(), Elts.size(), false);
+    ID.ConstantVal = ConstantStruct::get(Elts.data(), Elts.size(), false);
     ID.Kind = ValID::t_Constant;
     return false;
   }
@@ -1757,7 +1757,7 @@ bool LLParser::ParseValID(ValID &ID) {
     
     if (isPackedStruct) {
       ID.ConstantVal =
-        Context.getConstantStruct(Elts.data(), Elts.size(), true);
+        ConstantStruct::get(Elts.data(), Elts.size(), true);
       ID.Kind = ValID::t_Constant;
       return false;
     }
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index e1cc1a3afb..2c4aab1dfd 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -291,7 +291,7 @@ void BitcodeReaderValueList::ResolveConstantForwardRefs() {
         NewC = Context.getConstantArray(UserCA->getType(), &NewOps[0],
                                         NewOps.size());
       } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
-        NewC = Context.getConstantStruct(&NewOps[0], NewOps.size(),
+        NewC = ConstantStruct::get(&NewOps[0], NewOps.size(),
                                          UserCS->getType()->isPacked());
       } else if (isa<ConstantVector>(UserC)) {
         NewC = Context.getConstantVector(&NewOps[0], NewOps.size());
@@ -925,7 +925,7 @@ bool BitcodeReader::ParseConstants() {
         for (unsigned i = 0; i != Size; ++i)
           Elts.push_back(ValueList.getConstantFwdRef(Record[i],
                                                      STy->getElementType(i)));
-        V = Context.getConstantStruct(STy, Elts);
+        V = ConstantStruct::get(STy, Elts);
       } else if (const ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) {
         const Type *EltTy = ATy->getElementType();
         for (unsigned i = 0; i != Size; ++i)
diff --git a/lib/CodeGen/ShadowStackGC.cpp b/lib/CodeGen/ShadowStackGC.cpp
index e3281d2492..9d141e9c82 100644
--- a/lib/CodeGen/ShadowStackGC.cpp
+++ b/lib/CodeGen/ShadowStackGC.cpp
@@ -208,12 +208,12 @@ Constant *ShadowStackGC::GetFrameMap(Function &F) {
   };
 
   Constant *DescriptorElts[] = {
-    Context.getConstantStruct(BaseElts, 2),
+    ConstantStruct::get(BaseElts, 2),
     Context.getConstantArray(Context.getArrayType(VoidPtr, NumMeta),
                        Metadata.begin(), NumMeta)
   };
 
-  Constant *FrameMap = Context.getConstantStruct(DescriptorElts, 2);
+  Constant *FrameMap = ConstantStruct::get(DescriptorElts, 2);
 
   std::string TypeName("gc_map.");
   TypeName += utostr(NumMeta);
diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp
index 15fe2224e6..a2009ec466 100644
--- a/lib/Linker/LinkModules.cpp
+++ b/lib/Linker/LinkModules.cpp
@@ -376,7 +376,7 @@ static Value *RemapOperand(const Value *In,
         Operands[i] =cast<Constant>(RemapOperand(CPS->getOperand(i), ValueMap,
                                                  Context));
       Result =
-         Context.getConstantStruct(cast<StructType>(CPS->getType()), Operands);
+         ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
     } else if (isa<ConstantPointerNull>(CPV) || isa<UndefValue>(CPV)) {
       Result = const_cast<Constant*>(CPV);
     } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CPV)) {
diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index c7208bc892..2989e2827f 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1962,7 +1962,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL,
       CSVals[1] = Context.getNullValue(PFTy);
       CSVals[0] = ConstantInt::get(Type::Int32Ty, 2147483647);
     }
-    CAList.push_back(Context.getConstantStruct(CSVals));
+    CAList.push_back(ConstantStruct::get(CSVals));
   }
   
   // Create the array initializer.
@@ -2070,7 +2070,7 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
     Elts[Idx] = EvaluateStoreInto(Elts[Idx], Val, Addr, OpNo+1, Context);
     
     // Return the modified struct.
-    return Context.getConstantStruct(&Elts[0], Elts.size(), STy->isPacked());
+    return ConstantStruct::get(&Elts[0], Elts.size(), STy->isPacked());
   } else {
     ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo));
     const ArrayType *ATy = cast<ArrayType>(Init->getType());
diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp
index a8f0f86ddf..643805a2f9 100644
--- a/lib/Transforms/Utils/ValueMapper.cpp
+++ b/lib/Transforms/Utils/ValueMapper.cpp
@@ -76,7 +76,7 @@ Value *llvm::MapValue(const Value *V, ValueMapTy &VM, LLVMContext &Context) {
           Values.push_back(cast<Constant>(MV));
           for (++i; i != e; ++i)
             Values.push_back(cast<Constant>(MapValue(*i, VM, Context)));
-          return VM[V] = Context.getConstantStruct(CS->getType(), Values);
+          return VM[V] = ConstantStruct::get(CS->getType(), Values);
         }
       }
       return VM[V] = C;
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 6546dc70d8..61616f245a 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -519,7 +519,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
       Ops[i] = const_cast<Constant*>(Op);
     }
     if (isa<StructType>(AggTy))
-      return Context.getConstantStruct(Ops);
+      return ConstantStruct::get(Ops);
     else
       return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
   }
@@ -548,7 +548,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
       Ops[i] = const_cast<Constant*>(Op);
     }
     if (isa<StructType>(AggTy))
-      return Context.getConstantStruct(Ops);
+      return ConstantStruct::get(Ops);
     else
       return Context.getConstantArray(cast<ArrayType>(AggTy), Ops);
   }
@@ -565,7 +565,7 @@ Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context,
     }
     Constant *C;
     if (isa<StructType>(Agg->getType()))
-      C = Context.getConstantStruct(Ops);
+      C = ConstantStruct::get(Ops);
     else
       C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops);
     return C;
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index b2abdf3edc..ecb62568a2 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -397,6 +397,33 @@ ConstantStruct::ConstantStruct(const StructType *T,
   }
 }
 
+// ConstantStruct accessors.
+Constant* ConstantStruct::get(const StructType* T,
+                              const std::vector<Constant*>& V) {
+  LLVMContextImpl* pImpl = T->getContext().pImpl;
+  
+  // 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 pImpl->StructConstants.getOrCreate(T, V);
+
+  return T->getContext().getConstantAggregateZero(T);
+}
+
+Constant* ConstantStruct::get(const std::vector<Constant*>& V, bool packed) {
+  std::vector<const Type*> StructEls;
+  StructEls.reserve(V.size());
+  for (unsigned i = 0, e = V.size(); i != e; ++i)
+    StructEls.push_back(V[i]->getType());
+  return get(StructType::get(StructEls, packed), V);
+}
+
+Constant* ConstantStruct::get(Constant* const *Vals, unsigned NumVals,
+                              bool Packed) {
+  // FIXME: make this the primary ctor method.
+  return get(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
+}
 
 ConstantVector::ConstantVector(const VectorType *T,
                                const std::vector<Constant*> &V)
@@ -981,7 +1008,7 @@ namespace llvm {
 //
 void ConstantStruct::destroyConstant() {
   // Implicitly locked.
-  getType()->getContext().erase(this);
+  getType()->getContext().pImpl->StructConstants.remove(this);
   destroyConstantImpl();
 }
 
@@ -1897,11 +1924,74 @@ void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
   destroyConstant();
 }
 
+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;
+}
+
 void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To,
                                                  Use *U) {
-  Constant* Replacement =
-    getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U);
-  if (!Replacement) return;
+  assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
+  Constant *ToC = cast<Constant>(To);
+
+  unsigned OperandToUpdate = U-OperandList;
+  assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
+
+  std::pair<LLVMContextImpl::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;
+  
+  LLVMContext &Context = getType()->getContext();
+  LLVMContextImpl *pImpl = Context.pImpl;
+  
+  Constant *Replacement = 0;
+  if (isAllZeros) {
+    Replacement = Context.getConstantAggregateZero(getType());
+  } else {
+    // Check to see if we have this array type already.
+    sys::SmartScopedWriter<true> Writer(pImpl->ConstantsLock);
+    bool Exists;
+    LLVMContextImpl::StructConstantsTy::MapTy::iterator I =
+      pImpl->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!
+      pImpl->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);
diff --git a/lib/VMCore/Core.cpp b/lib/VMCore/Core.cpp
index 90f08c8e48..12f7c3223b 100644
--- a/lib/VMCore/Core.cpp
+++ b/lib/VMCore/Core.cpp
@@ -416,8 +416,7 @@ LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
 
 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
                              int Packed) {
-  return wrap(getGlobalContext().getConstantStruct(
-                                  unwrap<Constant>(ConstantVals, Count),
+  return wrap(ConstantStruct::get(unwrap<Constant>(ConstantVals, Count),
                                   Count, Packed != 0));
 }
 
diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp
index 722e29ee5d..340ca9557a 100644
--- a/lib/VMCore/LLVMContext.cpp
+++ b/lib/VMCore/LLVMContext.cpp
@@ -98,29 +98,6 @@ ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
   return ConstantPointerNull::get(T);
 }
 
-
-// ConstantStruct accessors.
-Constant* LLVMContext::getConstantStruct(const StructType* T,
-                                         const std::vector<Constant*>& V) {
-  return pImpl->getConstantStruct(T, V);
-}
-
-Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
-                                         bool packed) {
-  std::vector<const Type*> StructEls;
-  StructEls.reserve(V.size());
-  for (unsigned i = 0, e = V.size(); i != e; ++i)
-    StructEls.push_back(V[i]->getType());
-  return getConstantStruct(getStructType(StructEls, packed), V);
-}
-
-Constant* LLVMContext::getConstantStruct(Constant* const *Vals,
-                                         unsigned NumVals, bool Packed) {
-  // FIXME: make this the primary ctor method.
-  return getConstantStruct(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
-}
-
-
 // ConstantAggregateZero accessors.
 ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
   return pImpl->getConstantAggregateZero(Ty);
@@ -552,10 +529,6 @@ void LLVMContext::erase(ConstantArray *C) {
   pImpl->erase(C);
 }
 
-void LLVMContext::erase(ConstantStruct *S) {
-  pImpl->erase(S);
-}
-
 void LLVMContext::erase(ConstantVector *V) {
   pImpl->erase(V);
 }
@@ -564,8 +537,3 @@ 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);
-}
diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp
index 5315e23f8e..858ed15d9b 100644
--- a/lib/VMCore/LLVMContextImpl.cpp
+++ b/lib/VMCore/LLVMContextImpl.cpp
@@ -29,14 +29,6 @@ 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;
-}
-
 static std::vector<Constant*> getValType(ConstantVector *CP) {
   std::vector<Constant*> Elements;
   Elements.reserve(CP->getNumOperands());
@@ -112,17 +104,6 @@ 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);
-}
-
 Constant *LLVMContextImpl::getConstantVector(const VectorType *Ty,
                               const std::vector<Constant*> &V) {
   assert(!V.empty() && "Vectors can't be empty");
@@ -169,10 +150,6 @@ void LLVMContextImpl::erase(ConstantArray *C) {
   ArrayConstants.remove(C);
 }
 
-void LLVMContextImpl::erase(ConstantStruct *S) {
-  StructConstants.remove(S);
-}
-
 void LLVMContextImpl::erase(ConstantVector *V) {
   VectorConstants.remove(V);
 }
@@ -255,68 +232,4 @@ 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;
-}
+}
\ No newline at end of file
diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h
index a5ff8d5c54..21fef39683 100644
--- a/lib/VMCore/LLVMContextImpl.h
+++ b/lib/VMCore/LLVMContextImpl.h
@@ -102,7 +102,7 @@ struct ConvertConstantType<ConstantStruct, StructType> {
     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);
+    Constant *New = ConstantStruct::get(NewTy, C);
     assert(New != OldC && "Didn't replace constant??");
 
     OldC->uncheckedReplaceAllUsesWith(New);
@@ -458,6 +458,7 @@ class LLVMContextImpl {
   
   friend class ConstantInt;
   friend class ConstantFP;
+  friend class ConstantStruct;
 public:
   LLVMContextImpl(LLVMContext &C);
   
@@ -470,9 +471,6 @@ public:
   Constant *getConstantArray(const ArrayType *Ty,
                              const std::vector<Constant*> &V);
   
-  Constant *getConstantStruct(const StructType *Ty, 
-                              const std::vector<Constant*> &V);
-  
   Constant *getConstantVector(const VectorType *Ty,
                               const std::vector<Constant*> &V);
   
@@ -494,15 +492,12 @@ public:
   void erase(MDNode *M);
   void erase(ConstantAggregateZero *Z);
   void erase(ConstantArray *C);
-  void erase(ConstantStruct *S);
   void erase(ConstantVector *V);
   
   // RAUW helpers
   
   Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From,
                                              Value *To, Use *U);
-  Constant *replaceUsesOfWithOnConstant(ConstantStruct *CS, Value *From,
-                                        Value *To, Use *U);
 };
 
 }
diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp
index 41704f9dca..145942c886 100644
--- a/tools/bugpoint/ExtractFunction.cpp
+++ b/tools/bugpoint/ExtractFunction.cpp
@@ -187,7 +187,7 @@ static Constant *GetTorInit(std::vector<std::pair<Function*, int> > &TorList) {
     std::vector<Constant*> Elts;
     Elts.push_back(ConstantInt::get(Type::Int32Ty, TorList[i].second));
     Elts.push_back(TorList[i].first);
-    ArrayElts.push_back(Context.getConstantStruct(Elts));
+    ArrayElts.push_back(ConstantStruct::get(Elts));
   }
   return Context.getConstantArray(Context.getArrayType(ArrayElts[0]->getType(), 
                                            ArrayElts.size()),