From: Owen Anderson Date: Tue, 21 Jul 2009 20:55:28 +0000 (+0000) Subject: Privatize the ConstantArray table. X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=3d34492c1f293257b1e9842bc2d25122f87f82a1;p=platform%2Fupstream%2Fllvm.git Privatize the ConstantArray table. llvm-svn: 76639 --- diff --git a/llvm/include/llvm/Constants.h b/llvm/include/llvm/Constants.h index 4ef680c..3bf8b14 100644 --- a/llvm/include/llvm/Constants.h +++ b/llvm/include/llvm/Constants.h @@ -286,12 +286,10 @@ class ConstantArray : public Constant { friend struct ConstantCreator >; ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT + friend class LLVMContextImpl; protected: ConstantArray(const ArrayType *T, const std::vector &Val); public: - /// get() - Static factory methods - Return objects of the specified value - static Constant *get(const ArrayType *T, const std::vector &); - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); diff --git a/llvm/include/llvm/LLVMContext.h b/llvm/include/llvm/LLVMContext.h index 0d0b662..134311e 100644 --- a/llvm/include/llvm/LLVMContext.h +++ b/llvm/include/llvm/LLVMContext.h @@ -44,6 +44,7 @@ class Type; class APInt; class APFloat; class Value; +class Use; /// This is an important class for using LLVM in a threaded context. It /// (opaquely) owns and manages the core "global" data of LLVM's core @@ -273,6 +274,11 @@ public: void erase(MDString *M); void erase(MDNode *M); void erase(ConstantAggregateZero *Z); + void erase(ConstantArray *Z); + + // RAUW helpers + Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, + Value *From, Value *To, Use *U); }; /// FOR BACKWARDS COMPATIBILITY - Returns a global context. diff --git a/llvm/lib/VMCore/Constants.cpp b/llvm/lib/VMCore/Constants.cpp index 8bcf383..e64b0c4 100644 --- a/llvm/lib/VMCore/Constants.cpp +++ b/llvm/lib/VMCore/Constants.cpp @@ -1033,60 +1033,11 @@ void ConstantAggregateZero::destroyConstant() { destroyConstantImpl(); } -//---- ConstantArray::get() implementation... -// -namespace llvm { - template<> - struct ConvertConstantType { - static void convert(ConstantArray *OldC, const ArrayType *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 = ConstantArray::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(ConstantArray *CA) { - std::vector Elements; - Elements.reserve(CA->getNumOperands()); - for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) - Elements.push_back(cast(CA->getOperand(i))); - return Elements; -} - -typedef ValueMap, ArrayType, - ConstantArray, true /*largekey*/> ArrayConstantsTy; -static ManagedStatic ArrayConstants; - -Constant *ConstantArray::get(const ArrayType *Ty, - const std::vector &V) { - // If this is an all-zero array, return a ConstantAggregateZero object - if (!V.empty()) { - Constant *C = V[0]; - if (!C->isNullValue()) { - // Implicitly locked. - return ArrayConstants->getOrCreate(Ty, V); - } - for (unsigned i = 1, e = V.size(); i != e; ++i) - if (V[i] != C) { - // Implicitly locked. - return ArrayConstants->getOrCreate(Ty, V); - } - } - - return Ty->getContext().getConstantAggregateZero(Ty); -} - /// destroyConstant - Remove the constant from the constant table... /// void ConstantArray::destroyConstant() { // Implicitly locked. - ArrayConstants->remove(this); + getType()->getContext().erase(this); destroyConstantImpl(); } @@ -2160,77 +2111,10 @@ const char *ConstantExpr::getOpcodeName() const { /// array instance. void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { - assert(isa(To) && "Cannot make Constant refer to non-constant!"); - Constant *ToC = cast(To); - - std::pair Lookup; - Lookup.first.first = getType(); - Lookup.second = this; - - std::vector &Values = Lookup.first.second; - Values.reserve(getNumOperands()); // Build replacement array. - - // Fill values with the modified operands of the constant array. Also, - // compute whether this turns into an all-zeros array. - bool isAllZeros = false; - unsigned NumUpdated = 0; - if (!ToC->isNullValue()) { - for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { - Constant *Val = cast(O->get()); - if (Val == From) { - Val = ToC; - ++NumUpdated; - } - Values.push_back(Val); - } - } else { - isAllZeros = true; - for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { - Constant *Val = cast(O->get()); - if (Val == From) { - Val = ToC; - ++NumUpdated; - } - Values.push_back(Val); - if (isAllZeros) isAllZeros = Val->isNullValue(); - } - } - - Constant *Replacement = 0; - if (isAllZeros) { - Replacement = - From->getType()->getContext().getConstantAggregateZero(getType()); - } else { - // Check to see if we have this array type already. - sys::SmartScopedWriter Writer(*ConstantsLock); - bool Exists; - ArrayConstantsTy::MapTy::iterator I = - ArrayConstants->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 array, inserting it, replaceallusesof'ing the - // old with the new, then deleting the old... just update the current one - // in place! - ArrayConstants->MoveConstantToNewSlot(this, I); - - // Update to the new value. Optimize for the case when we have a single - // operand that we're changing, but handle bulk updates efficiently. - if (NumUpdated == 1) { - unsigned OperandToUpdate = U-OperandList; - assert(getOperand(OperandToUpdate) == From && - "ReplaceAllUsesWith broken!"); - setOperand(OperandToUpdate, ToC); - } else { - for (unsigned i = 0, e = getNumOperands(); i != e; ++i) - if (getOperand(i) == From) - setOperand(i, ToC); - } - return; - } - } + Constant *Replacement = + getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U); + + if (!Replacement) return; // Otherwise, I do need to replace this with an existing value. assert(Replacement != this && "I didn't contain From!"); diff --git a/llvm/lib/VMCore/LLVMContext.cpp b/llvm/lib/VMCore/LLVMContext.cpp index 782a87b..7194c2e 100644 --- a/llvm/lib/VMCore/LLVMContext.cpp +++ b/llvm/lib/VMCore/LLVMContext.cpp @@ -174,7 +174,7 @@ ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) { // ConstantArray accessors. Constant* LLVMContext::getConstantArray(const ArrayType* T, const std::vector& V) { - return ConstantArray::get(T, V); + return pImpl->getConstantArray(T, V); } Constant* LLVMContext::getConstantArray(const ArrayType* T, @@ -652,4 +652,13 @@ void LLVMContext::erase(MDNode *M) { void LLVMContext::erase(ConstantAggregateZero *Z) { pImpl->erase(Z); +} + +void LLVMContext::erase(ConstantArray *C) { + pImpl->erase(C); +} + +Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA, + Value *From, Value *To, Use *U) { + return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U); } \ No newline at end of file diff --git a/llvm/lib/VMCore/LLVMContextImpl.cpp b/llvm/lib/VMCore/LLVMContextImpl.cpp index c72e3cb..5441f1a 100644 --- a/llvm/lib/VMCore/LLVMContextImpl.cpp +++ b/llvm/lib/VMCore/LLVMContextImpl.cpp @@ -21,6 +21,14 @@ using namespace llvm; static char getValType(ConstantAggregateZero *CPZ) { return 0; } +static std::vector getValType(ConstantArray *CA) { + std::vector Elements; + Elements.reserve(CA->getNumOperands()); + for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) + Elements.push_back(cast(CA->getOperand(i))); + return Elements; +} + namespace llvm { template struct VISIBILITY_HIDDEN ConstantTraits< std::vector > { @@ -61,11 +69,25 @@ struct ConvertConstantType { OldC->destroyConstant(); // This constant is now dead, destroy it. } }; + +template<> +struct ConvertConstantType { + static void convert(ConstantArray *OldC, const ArrayType *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 = NewTy->getContext().getConstantArray(NewTy, C); + assert(New != OldC && "Didn't replace constant??"); + OldC->uncheckedReplaceAllUsesWith(New); + OldC->destroyConstant(); // This constant is now dead, destroy it. + } +}; } template -class VISIBILITY_HIDDEN ContextValueMap : public AbstractTypeUser { +class VISIBILITY_HIDDEN ValueMap : public AbstractTypeUser { public: typedef std::pair MapKey; typedef std::map MapTy; @@ -300,11 +322,13 @@ public: LLVMContextImpl::LLVMContextImpl(LLVMContext &C) : Context(C), TheTrueVal(0), TheFalseVal(0) { - AggZeroConstants = new ContextValueMap(); + AggZeroConstants = new ValueMap(); + ArrayConstants = new ArrayConstantsTy(); } LLVMContextImpl::~LLVMContextImpl() { delete AggZeroConstants; + delete ArrayConstants; } // Get a ConstantInt from an APInt. Note that the value stored in the DenseMap @@ -413,6 +437,25 @@ LLVMContextImpl::getConstantAggregateZero(const Type *Ty) { return AggZeroConstants->getOrCreate(Ty, 0); } +Constant *LLVMContextImpl::getConstantArray(const ArrayType *Ty, + const std::vector &V) { + // If this is an all-zero array, return a ConstantAggregateZero object + if (!V.empty()) { + Constant *C = V[0]; + if (!C->isNullValue()) { + // Implicitly locked. + return ArrayConstants->getOrCreate(Ty, V); + } + for (unsigned i = 1, e = V.size(); i != e; ++i) + if (V[i] != C) { + // Implicitly locked. + return ArrayConstants->getOrCreate(Ty, V); + } + } + + return Context.getConstantAggregateZero(Ty); +} + // *** erase methods *** void LLVMContextImpl::erase(MDString *M) { @@ -428,3 +471,87 @@ void LLVMContextImpl::erase(MDNode *M) { void LLVMContextImpl::erase(ConstantAggregateZero *Z) { AggZeroConstants->remove(Z); } + +void LLVMContextImpl::erase(ConstantArray *C) { + ArrayConstants->remove(C); +} + +// *** RAUW helpers *** +Constant *LLVMContextImpl::replaceUsesOfWithOnConstant(ConstantArray *CA, + Value *From, Value *To, Use *U) { + assert(isa(To) && "Cannot make Constant refer to non-constant!"); + Constant *ToC = cast(To); + + std::pair Lookup; + Lookup.first.first = CA->getType(); + Lookup.second = CA; + + std::vector &Values = Lookup.first.second; + Values.reserve(CA->getNumOperands()); // Build replacement array. + + // Fill values with the modified operands of the constant array. Also, + // compute whether this turns into an all-zeros array. + bool isAllZeros = false; + unsigned NumUpdated = 0; + if (!ToC->isNullValue()) { + for (Use *O = CA->OperandList, *E = CA->OperandList + CA->getNumOperands(); + O != E; ++O) { + Constant *Val = cast(O->get()); + if (Val == From) { + Val = ToC; + ++NumUpdated; + } + Values.push_back(Val); + } + } else { + isAllZeros = true; + for (Use *O = CA->OperandList, *E = CA->OperandList + CA->getNumOperands(); + O != E; ++O) { + Constant *Val = cast(O->get()); + if (Val == From) { + Val = ToC; + ++NumUpdated; + } + Values.push_back(Val); + if (isAllZeros) isAllZeros = Val->isNullValue(); + } + } + + Constant *Replacement = 0; + if (isAllZeros) { + Replacement = Context.getConstantAggregateZero(CA->getType()); + } else { + // Check to see if we have this array type already. + sys::SmartScopedWriter Writer(ConstantsLock); + bool Exists; + ArrayConstantsTy::MapTy::iterator I = + ArrayConstants->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 array, inserting it, replaceallusesof'ing the + // old with the new, then deleting the old... just update the current one + // in place! + ArrayConstants->MoveConstantToNewSlot(CA, I); + + // Update to the new value. Optimize for the case when we have a single + // operand that we're changing, but handle bulk updates efficiently. + if (NumUpdated == 1) { + unsigned OperandToUpdate = U - CA->OperandList; + assert(CA->getOperand(OperandToUpdate) == From && + "ReplaceAllUsesWith broken!"); + CA->setOperand(OperandToUpdate, ToC); + } else { + for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) + if (CA->getOperand(i) == From) + CA->setOperand(i, ToC); + } + return 0; + } + } + + return Replacement; +} + diff --git a/llvm/lib/VMCore/LLVMContextImpl.h b/llvm/lib/VMCore/LLVMContextImpl.h index e2c2537..03f0e7b 100644 --- a/llvm/lib/VMCore/LLVMContextImpl.h +++ b/llvm/lib/VMCore/LLVMContextImpl.h @@ -30,7 +30,7 @@ template -class ContextValueMap; +class ValueMap; namespace llvm { template @@ -111,7 +111,11 @@ class LLVMContextImpl { FoldingSet MDNodeSet; - ContextValueMap *AggZeroConstants; + ValueMap *AggZeroConstants; + + typedef ValueMap, ArrayType, + ConstantArray, true /*largekey*/> ArrayConstantsTy; + ArrayConstantsTy *ArrayConstants; LLVMContext &Context; ConstantInt *TheTrueVal; @@ -135,6 +139,9 @@ public: ConstantAggregateZero *getConstantAggregateZero(const Type *Ty); + Constant *getConstantArray(const ArrayType *Ty, + const std::vector &V); + ConstantInt *getTrue() { if (TheTrueVal) return TheTrueVal; @@ -152,6 +159,12 @@ public: void erase(MDString *M); void erase(MDNode *M); void erase(ConstantAggregateZero *Z); + void erase(ConstantArray *C); + + // RAUW helpers + + Constant *replaceUsesOfWithOnConstant(ConstantArray *CA, Value *From, + Value *To, Use *U); }; }