From 5bd68393ed87bcedc53f5998f1af9c906f5a1b4e Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Fri, 24 Jul 2009 00:36:24 +0000 Subject: [PATCH] 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 | 3 -- include/llvm/LLVMContext.h | 1 + lib/VMCore/Constants.cpp | 60 ++-------------------------------- lib/VMCore/LLVMContext.cpp | 6 +++- lib/VMCore/LLVMContextImpl.cpp | 56 ++++++++++++++++++++++++++++++- lib/VMCore/LLVMContextImpl.h | 8 +++++ 6 files changed, 72 insertions(+), 62 deletions(-) diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index 12f97857421..f9fd636e3aa 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -390,9 +390,6 @@ class ConstantVector : public Constant { protected: ConstantVector(const VectorType *T, const std::vector &Val); public: - /// get() - Static factory methods - Return objects of the specified value - static Constant *get(const VectorType *T, const std::vector &); - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h index 53b0868ec26..a2fa569ce5b 100644 --- a/include/llvm/LLVMContext.h +++ b/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, diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 40034df81bd..74c31151ac2 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -1107,66 +1107,11 @@ void ConstantStruct::destroyConstant() { destroyConstantImpl(); } -//---- ConstantVector::get() implementation... -// -namespace llvm { - template<> - struct ConvertConstantType { - static void convert(ConstantVector *OldC, const VectorType *NewTy) { - // Make everyone now use a constant of the new type... - std::vector C; - for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i) - C.push_back(cast(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 getValType(ConstantVector *CP) { - std::vector 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, VectorType, - ConstantVector> > VectorConstants; - -Constant *ConstantVector::get(const VectorType *Ty, - const std::vector &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(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. diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index 5a4cf2027da..d0f05eb414d 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/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& V) { - return ConstantVector::get(T, V); + return pImpl->getConstantVector(T, V); } Constant* LLVMContext::getConstantVector(const std::vector& 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); diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp index 156d4cacd15..34fc6e52f84 100644 --- a/lib/VMCore/LLVMContextImpl.cpp +++ b/lib/VMCore/LLVMContextImpl.cpp @@ -37,6 +37,14 @@ static std::vector getValType(ConstantStruct *CS) { return Elements; } +static std::vector getValType(ConstantVector *CP) { + std::vector 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 struct VISIBILITY_HIDDEN ConstantTraits< std::vector > { @@ -106,6 +114,20 @@ struct ConvertConstantType { OldC->destroyConstant(); // This constant is now dead, destroy it. } }; + +template<> +struct ConvertConstantType { + static void convert(ConstantVector *OldC, const VectorType *NewTy) { + // Make everyone now use a constant of the new type... + std::vector C; + for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i) + C.push_back(cast(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(); 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 &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(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; -} \ No newline at end of file +} diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index f313ed62078..73516245f57 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -122,6 +122,10 @@ class LLVMContextImpl { ConstantStruct, true /*largekey*/> StructConstantsTy; StructConstantsTy *StructConstants; + typedef ValueMap, VectorType, + ConstantVector> VectorConstantsTy; + VectorConstantsTy *VectorConstants; + LLVMContext &Context; ConstantInt *TheTrueVal; ConstantInt *TheFalseVal; @@ -150,6 +154,9 @@ public: Constant *getConstantStruct(const StructType *Ty, const std::vector &V); + Constant *getConstantVector(const VectorType *Ty, + const std::vector &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