aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/llvm/Constants.h4
-rw-r--r--include/llvm/LLVMContext.h6
-rw-r--r--lib/VMCore/Constants.cpp126
-rw-r--r--lib/VMCore/LLVMContext.cpp11
-rw-r--r--lib/VMCore/LLVMContextImpl.cpp131
-rw-r--r--lib/VMCore/LLVMContextImpl.h17
6 files changed, 166 insertions, 129 deletions
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 4ef680c..3bf8b14 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -286,12 +286,10 @@ class ConstantArray : public Constant {
friend struct ConstantCreator<ConstantArray, ArrayType,
std::vector<Constant*> >;
ConstantArray(const ConstantArray &); // DO NOT IMPLEMENT
+ friend class LLVMContextImpl;
protected:
ConstantArray(const ArrayType *T, const std::vector<Constant*> &Val);
public:
- /// get() - Static factory methods - Return objects of the specified value
- static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
-
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index 0d0b662..134311e 100644
--- a/include/llvm/LLVMContext.h
+++ b/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/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 8bcf383..e64b0c4 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -1033,60 +1033,11 @@ void ConstantAggregateZero::destroyConstant() {
destroyConstantImpl();
}
-//---- ConstantArray::get() implementation...
-//
-namespace llvm {
- template<>
- struct ConvertConstantType<ConstantArray, ArrayType> {
- static void convert(ConstantArray *OldC, const ArrayType *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 = 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<Constant*> getValType(ConstantArray *CA) {
- std::vector<Constant*> Elements;
- Elements.reserve(CA->getNumOperands());
- for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
- Elements.push_back(cast<Constant>(CA->getOperand(i)));
- return Elements;
-}
-
-typedef ValueMap<std::vector<Constant*>, ArrayType,
- ConstantArray, true /*largekey*/> ArrayConstantsTy;
-static ManagedStatic<ArrayConstantsTy> ArrayConstants;
-
-Constant *ConstantArray::get(const ArrayType *Ty,
- const std::vector<Constant*> &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<Constant>(To) && "Cannot make Constant refer to non-constant!");
- Constant *ToC = cast<Constant>(To);
-
- std::pair<ArrayConstantsTy::MapKey, Constant*> Lookup;
- Lookup.first.first = getType();
- Lookup.second = this;
-
- std::vector<Constant*> &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<Constant>(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<Constant>(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<true> 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/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp
index 782a87b..7194c2e 100644
--- a/lib/VMCore/LLVMContext.cpp
+++ b/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<Constant*>& 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/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp
index c72e3cb..5441f1a 100644
--- a/lib/VMCore/LLVMContextImpl.cpp
+++ b/lib/VMCore/LLVMContextImpl.cpp
@@ -21,6 +21,14 @@ using namespace llvm;
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
+static std::vector<Constant*> getValType(ConstantArray *CA) {
+ std::vector<Constant*> Elements;
+ Elements.reserve(CA->getNumOperands());
+ for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
+ Elements.push_back(cast<Constant>(CA->getOperand(i)));
+ return Elements;
+}
+
namespace llvm {
template<typename T, typename Alloc>
struct VISIBILITY_HIDDEN ConstantTraits< std::vector<T, Alloc> > {
@@ -61,11 +69,25 @@ struct ConvertConstantType<ConstantAggregateZero, Type> {
OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
+
+template<>
+struct ConvertConstantType<ConstantArray, ArrayType> {
+ static void convert(ConstantArray *OldC, const ArrayType *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().getConstantArray(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,
bool HasLargeKey /*true for arrays and structs*/ >
-class VISIBILITY_HIDDEN ContextValueMap : public AbstractTypeUser {
+class VISIBILITY_HIDDEN ValueMap : public AbstractTypeUser {
public:
typedef std::pair<const Type*, ValType> MapKey;
typedef std::map<MapKey, Constant *> MapTy;
@@ -300,11 +322,13 @@ public:
LLVMContextImpl::LLVMContextImpl(LLVMContext &C) :
Context(C), TheTrueVal(0), TheFalseVal(0) {
- AggZeroConstants = new ContextValueMap<char, Type, ConstantAggregateZero>();
+ AggZeroConstants = new ValueMap<char, Type, ConstantAggregateZero>();
+ 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<Constant*> &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<Constant>(To) && "Cannot make Constant refer to non-constant!");
+ Constant *ToC = cast<Constant>(To);
+
+ std::pair<ArrayConstantsTy::MapKey, Constant*> Lookup;
+ Lookup.first.first = CA->getType();
+ Lookup.second = CA;
+
+ std::vector<Constant*> &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<Constant>(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<Constant>(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<true> 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/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h
index e2c2537..03f0e7b 100644
--- a/lib/VMCore/LLVMContextImpl.h
+++ b/lib/VMCore/LLVMContextImpl.h
@@ -30,7 +30,7 @@
template<class ValType, class TypeClass, class ConstantClass,
bool HasLargeKey = false /*true for arrays and structs*/ >
-class ContextValueMap;
+class ValueMap;
namespace llvm {
template<class ValType>
@@ -111,7 +111,11 @@ class LLVMContextImpl {
FoldingSet<MDNode> MDNodeSet;
- ContextValueMap<char, Type, ConstantAggregateZero> *AggZeroConstants;
+ ValueMap<char, Type, ConstantAggregateZero> *AggZeroConstants;
+
+ typedef ValueMap<std::vector<Constant*>, 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<Constant*> &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);
};
}
generated by cgit v1.1 at 2024-09-01 06:39:54 +0000