diff options
author | Owen Anderson <resistor@mac.com> | 2009-07-23 23:25:33 +0000 |
---|---|---|
committer | Owen Anderson <resistor@mac.com> | 2009-07-23 23:25:33 +0000 |
commit | 006c77df8cc7f6a9dac575600b797b8ba32b29eb (patch) | |
tree | 6e1d4a07734c199f8a3245fab69bf516ff93fce5 /lib | |
parent | ed0e2adc7076365596ee3d26d5ba5240ce13f23d (diff) | |
download | external_llvm-006c77df8cc7f6a9dac575600b797b8ba32b29eb.zip external_llvm-006c77df8cc7f6a9dac575600b797b8ba32b29eb.tar.gz external_llvm-006c77df8cc7f6a9dac575600b797b8ba32b29eb.tar.bz2 |
Privatize the ConstantStruct table.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76912 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib')
-rw-r--r-- | lib/VMCore/Constants.cpp | 96 | ||||
-rw-r--r-- | lib/VMCore/LLVMContext.cpp | 11 | ||||
-rw-r--r-- | lib/VMCore/LLVMContextImpl.cpp | 104 | ||||
-rw-r--r-- | lib/VMCore/LLVMContextImpl.h | 11 |
4 files changed, 129 insertions, 93 deletions
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 065ebcd..40034df 100644 --- a/lib/VMCore/Constants.cpp +++ b/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 *ToC = cast<Constant>(To); - - 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!"); + Constant* Replacement = + getType()->getContext().replaceUsesOfWithOnConstant(this, From, To, U); + if (!Replacement) return; // Everyone using this now uses the replacement. uncheckedReplaceAllUsesWith(Replacement); diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index d0abb2d..5a4cf20 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/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); +} diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp index 1c5af77..156d4ca 100644 --- a/lib/VMCore/LLVMContextImpl.cpp +++ b/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; +}
\ No newline at end of file diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index 392e500..f313ed6 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/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); }; } |