[llvm-commits] [llvm] r73801 - in /llvm/trunk: include/llvm/Constant.h include/llvm/Constants.h include/llvm/GlobalValue.h include/llvm/MDNode.h lib/VMCore/ConstantFold.cpp lib/VMCore/Constants.cpp lib/VMCore/Globals.cpp
Owen Anderson
resistor at mac.com
Fri Jun 19 17:24:58 PDT 2009
Author: resistor
Date: Fri Jun 19 19:24:58 2009
New Revision: 73801
URL: http://llvm.org/viewvc/llvm-project?rev=73801&view=rev
Log:
Revert r73790, and replace it with a significantly less ugly solution. Rather than trying to make the global reader-writer lock work,
create separate recursive mutexes for each value map. The recursive-ness fixes the double-acquiring issue, which having one per ValueMap
lets us continue to maintain some concurrency.
Modified:
llvm/trunk/include/llvm/Constant.h
llvm/trunk/include/llvm/Constants.h
llvm/trunk/include/llvm/GlobalValue.h
llvm/trunk/include/llvm/MDNode.h
llvm/trunk/lib/VMCore/ConstantFold.cpp
llvm/trunk/lib/VMCore/Constants.cpp
llvm/trunk/lib/VMCore/Globals.cpp
Modified: llvm/trunk/include/llvm/Constant.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Constant.h?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Constant.h (original)
+++ llvm/trunk/include/llvm/Constant.h Fri Jun 19 19:24:58 2009
@@ -61,7 +61,7 @@
public:
/// Static constructor to get a '0' constant of arbitrary type...
///
- static Constant *getNullValue(const Type *Ty, bool locked = true);
+ static Constant *getNullValue(const Type *Ty);
/// Static constructor to get a '-1' constant. This supports integers and
/// vectors.
@@ -107,9 +107,7 @@
/// available cached constants. Implementations should call
/// destroyConstantImpl as the last thing they do, to destroy all users and
/// delete this.
- virtual void destroyConstant(bool locked = true) {
- assert(0 && "Not reached!");
- }
+ virtual void destroyConstant() { assert(0 && "Not reached!"); }
//// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Constant *) { return true; }
Modified: llvm/trunk/include/llvm/Constants.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Constants.h?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Constants.h (original)
+++ llvm/trunk/include/llvm/Constants.h Fri Jun 19 19:24:58 2009
@@ -109,13 +109,11 @@
/// the type.
/// @brief Get a ConstantInt for a specific value.
static ConstantInt *get(const IntegerType *Ty,
- uint64_t V, bool isSigned = false,
- bool locked = true);
+ uint64_t V, bool isSigned = false);
/// If Ty is a vector type, return a Constant with a splat of the given
/// value. Otherwise return a ConstantInt for the given value.
- static Constant *get(const Type *Ty, uint64_t V,
- bool isSigned = false, bool locked = true);
+ static Constant *get(const Type *Ty, uint64_t V, bool isSigned = false);
/// Return a ConstantInt with the specified value for the specified type. The
/// value V will be canonicalized to a an unsigned APInt. Accessing it with
@@ -131,11 +129,11 @@
/// Return a ConstantInt with the specified value and an implied Type. The
/// type is the integer type that corresponds to the bit width of the value.
- static ConstantInt *get(const APInt &V, bool locked = true);
+ static ConstantInt *get(const APInt &V);
/// If Ty is a vector type, return a Constant with a splat of the given
/// value. Otherwise return a ConstantInt for the given value.
- static Constant *get(const Type *Ty, const APInt &V, bool locked = true);
+ static Constant *get(const Type *Ty, const APInt &V);
/// getType - Specialize the getType() method to always return an IntegerType,
/// which reduces the amount of casting needed in parts of the compiler.
@@ -232,7 +230,7 @@
/// @returns the value for an integer constant of the given type that has all
/// its bits set to true.
/// @brief Get the all ones value
- static ConstantInt *getAllOnesValue(const Type *Ty, bool locked = true);
+ static ConstantInt *getAllOnesValue(const Type *Ty);
/// @brief Methods to support type inquiry through isa, cast, and dyn_cast.
static inline bool classof(const ConstantInt *) { return true; }
@@ -261,13 +259,13 @@
}
public:
/// get() - Static factory methods - Return objects of the specified value
- static ConstantFP *get(const APFloat &V, bool locked = true);
+ static ConstantFP *get(const APFloat &V);
/// get() - This returns a ConstantFP, or a vector containing a splat of a
/// ConstantFP, for the specified value in the specified type. This should
/// only be used for simple constant values like 2.0/1.0 etc, that are
/// known-valid both as host double and as the target format.
- static Constant *get(const Type *Ty, double V, bool locked = true);
+ static Constant *get(const Type *Ty, double V);
/// isValueValidForType - return true if Ty is big enough to represent V.
static bool isValueValidForType(const Type *Ty, const APFloat& V);
@@ -323,13 +321,13 @@
public:
/// get() - static factory method for creating a null aggregate. It is
/// illegal to call this method with a non-aggregate type.
- static ConstantAggregateZero *get(const Type *Ty, bool locked = true);
+ static ConstantAggregateZero *get(const Type *Ty);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return true; }
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
/// Methods for support type inquiry through isa, cast, and dyn_cast:
///
@@ -351,11 +349,9 @@
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*> &,
- bool locked = true);
+ static Constant *get(const ArrayType *T, const std::vector<Constant*> &);
static Constant *get(const ArrayType *T,
- Constant*const*Vals, unsigned NumVals,
- bool locked = true) {
+ Constant*const*Vals, unsigned NumVals) {
// FIXME: make this the primary ctor method.
return get(T, std::vector<Constant*>(Vals, Vals+NumVals));
}
@@ -366,8 +362,7 @@
/// of the array by one (you've been warned). However, in some situations
/// this is not desired so if AddNull==false then the string is copied without
/// null termination.
- static Constant *get(const std::string &Initializer,
- bool AddNull = true, bool locked = true);
+ static Constant *get(const std::string &Initializer, bool AddNull = true);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
@@ -400,7 +395,7 @@
/// created as ConstantAggregateZero objects.
virtual bool isNullValue() const { return false; }
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -428,14 +423,12 @@
public:
/// get() - Static factory methods - Return objects of the specified value
///
- static Constant *get(const StructType *T, const std::vector<Constant*> &V,
- bool locked = true);
- static Constant *get(const std::vector<Constant*> &V, bool Packed = false,
- bool locked = true);
+ 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, bool locked = true) {
+ bool Packed = false) {
// FIXME: make this the primary ctor method.
- return get(std::vector<Constant*>(Vals, Vals+NumVals), Packed, locked);
+ return get(std::vector<Constant*>(Vals, Vals+NumVals), Packed);
}
/// Transparently provide more efficient getOperand methods.
@@ -454,7 +447,7 @@
return false;
}
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -481,13 +474,11 @@
ConstantVector(const VectorType *T, const std::vector<Constant*> &Val);
public:
/// get() - Static factory methods - Return objects of the specified value
- static Constant *get(const VectorType *T, const std::vector<Constant*> &,
- bool locked = true);
- static Constant *get(const std::vector<Constant*> &V, bool locked = true);
- static Constant *get(Constant*const* Vals, unsigned NumVals,
- bool locked = true) {
+ static Constant *get(const VectorType *T, const std::vector<Constant*> &);
+ static Constant *get(const std::vector<Constant*> &V);
+ static Constant *get(Constant*const* Vals, unsigned NumVals) {
// FIXME: make this the primary ctor method.
- return get(std::vector<Constant*>(Vals, Vals+NumVals), locked);
+ return get(std::vector<Constant*>(Vals, Vals+NumVals));
}
/// Transparently provide more efficient getOperand methods.
@@ -503,8 +494,7 @@
/// @returns the value for a vector integer constant of the given type that
/// has all its bits set to true.
/// @brief Get the all ones value
- static ConstantVector *getAllOnesValue(const VectorType *Ty,
- bool locked = true);
+ static ConstantVector *getAllOnesValue(const VectorType *Ty);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue. This always returns false because zero vectors are always
@@ -521,7 +511,7 @@
/// elements have the same value, return that value. Otherwise return NULL.
Constant *getSplatValue();
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -556,13 +546,13 @@
}
public:
/// get() - Static factory methods - Return objects of the specified value
- static ConstantPointerNull *get(const PointerType *T, bool locked = true);
+ static ConstantPointerNull *get(const PointerType *T);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return true; }
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
/// getType - Specialize the getType() method to always return an PointerType,
/// which reduces the amount of casting needed in parts of the compiler.
@@ -600,14 +590,13 @@
// These private methods are used by the type resolution code to create
// ConstantExprs in intermediate forms.
static Constant *getTy(const Type *Ty, unsigned Opcode,
- Constant *C1, Constant *C2, bool locked = true);
+ Constant *C1, Constant *C2);
static Constant *getCompareTy(unsigned short pred, Constant *C1,
Constant *C2);
- static Constant *getSelectTy(const Type *Ty, Constant *C1, Constant *C2,
- Constant *C3, bool locked = true);
+ static Constant *getSelectTy(const Type *Ty,
+ Constant *C1, Constant *C2, Constant *C3);
static Constant *getGetElementPtrTy(const Type *Ty, Constant *C,
- Value* const *Idxs, unsigned NumIdxs,
- bool locked = true);
+ Value* const *Idxs, unsigned NumIdxs);
static Constant *getExtractElementTy(const Type *Ty, Constant *Val,
Constant *Idx);
static Constant *getInsertElementTy(const Type *Ty, Constant *Val,
@@ -628,18 +617,18 @@
/// Cast constant expr
///
- static Constant *getTrunc (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getSExt (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getZExt (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getFPTrunc (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getFPExtend(Constant *C, const Type *Ty, bool locked = true);
- static Constant *getUIToFP (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getSIToFP (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getFPToUI (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getFPToSI (Constant *C, const Type *Ty, bool locked = true);
- static Constant *getPtrToInt(Constant *C, const Type *Ty, bool locked = true);
- static Constant *getIntToPtr(Constant *C, const Type *Ty, bool locked = true);
- static Constant *getBitCast (Constant *C, const Type *Ty, bool locked = true);
+ static Constant *getTrunc (Constant *C, const Type *Ty);
+ static Constant *getSExt (Constant *C, const Type *Ty);
+ static Constant *getZExt (Constant *C, const Type *Ty);
+ static Constant *getFPTrunc (Constant *C, const Type *Ty);
+ static Constant *getFPExtend(Constant *C, const Type *Ty);
+ static Constant *getUIToFP (Constant *C, const Type *Ty);
+ static Constant *getSIToFP (Constant *C, const Type *Ty);
+ static Constant *getFPToUI (Constant *C, const Type *Ty);
+ static Constant *getFPToSI (Constant *C, const Type *Ty);
+ static Constant *getPtrToInt(Constant *C, const Type *Ty);
+ static Constant *getIntToPtr(Constant *C, const Type *Ty);
+ static Constant *getBitCast (Constant *C, const Type *Ty);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
@@ -649,8 +638,7 @@
static Constant *getCast(
unsigned ops, ///< The opcode for the conversion
Constant *C, ///< The constant to be converted
- const Type *Ty, ///< The type to which the constant is converted
- bool locked = true
+ const Type *Ty ///< The type to which the constant is converted
);
// @brief Create a ZExt or BitCast cast constant expression
@@ -662,8 +650,7 @@
// @brief Create a SExt or BitCast cast constant expression
static Constant *getSExtOrBitCast(
Constant *C, ///< The constant to sext or bitcast
- const Type *Ty, ///< The type to sext or bitcast C to
- bool locked = true
+ const Type *Ty ///< The type to sext or bitcast C to
);
// @brief Create a Trunc or BitCast cast constant expression
@@ -675,8 +662,7 @@
/// @brief Create a BitCast or a PtrToInt cast constant expression
static Constant *getPointerCast(
Constant *C, ///< The pointer value to be casted (operand 0)
- const Type *Ty, ///< The type to which cast should be made
- bool locked = true
+ const Type *Ty ///< The type to which cast should be made
);
/// @brief Create a ZExt, Bitcast or Trunc for integer -> integer casts
@@ -722,8 +708,7 @@
/// ConstantExpr::get - Return a binary or shift operator constant expression,
/// folding if possible.
///
- static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
- bool locked = true);
+ static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
/// @brief Return an ICmp, FCmp, VICmp, or VFCmp comparison operator constant
/// expression.
@@ -735,38 +720,36 @@
static Constant *getNeg(Constant *C);
static Constant *getFNeg(Constant *C);
static Constant *getNot(Constant *C);
- static Constant *getAdd(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getFAdd(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getSub(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getFSub(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getMul(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getFMul(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getUDiv(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getSDiv(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getFDiv(Constant *C1, Constant *C2, bool locked = true);
- // unsigned rem
- static Constant *getURem(Constant *C1, Constant *C2, bool locked = true);
- // signed rem
- static Constant *getSRem(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getFRem(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getAnd(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getOr(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getXor(Constant *C1, Constant *C2, bool locked = true);
+ static Constant *getAdd(Constant *C1, Constant *C2);
+ static Constant *getFAdd(Constant *C1, Constant *C2);
+ static Constant *getSub(Constant *C1, Constant *C2);
+ static Constant *getFSub(Constant *C1, Constant *C2);
+ static Constant *getMul(Constant *C1, Constant *C2);
+ static Constant *getFMul(Constant *C1, Constant *C2);
+ static Constant *getUDiv(Constant *C1, Constant *C2);
+ static Constant *getSDiv(Constant *C1, Constant *C2);
+ static Constant *getFDiv(Constant *C1, Constant *C2);
+ static Constant *getURem(Constant *C1, Constant *C2); // unsigned rem
+ static Constant *getSRem(Constant *C1, Constant *C2); // signed rem
+ static Constant *getFRem(Constant *C1, Constant *C2);
+ static Constant *getAnd(Constant *C1, Constant *C2);
+ static Constant *getOr(Constant *C1, Constant *C2);
+ static Constant *getXor(Constant *C1, Constant *C2);
static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS);
static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
static Constant *getVICmp(unsigned short pred, Constant *LHS, Constant *RHS);
static Constant *getVFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
- static Constant *getShl(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getLShr(Constant *C1, Constant *C2, bool locked = true);
- static Constant *getAShr(Constant *C1, Constant *C2, bool locked = true);
+ static Constant *getShl(Constant *C1, Constant *C2);
+ static Constant *getLShr(Constant *C1, Constant *C2);
+ static Constant *getAShr(Constant *C1, Constant *C2);
/// Getelementptr form. std::vector<Value*> is only accepted for convenience:
/// all elements must be Constant's.
///
- static Constant *getGetElementPtr(Constant *C, Constant* const *IdxList,
- unsigned NumIdx, bool locked = true);
- static Constant *getGetElementPtr(Constant *C, Value* const *IdxList,
- unsigned NumIdx, bool locked = true);
+ static Constant *getGetElementPtr(Constant *C,
+ Constant* const *IdxList, unsigned NumIdx);
+ static Constant *getGetElementPtr(Constant *C,
+ Value* const *IdxList, unsigned NumIdx);
static Constant *getExtractElement(Constant *Vec, Constant *Idx);
static Constant *getInsertElement(Constant *Vec, Constant *Elt,Constant *Idx);
@@ -811,7 +794,7 @@
}
Constant *getWithOperands(Constant* const *Ops, unsigned NumOps) const;
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
/// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -848,13 +831,13 @@
/// get() - Static factory methods - Return an 'undef' object of the specified
/// type.
///
- static UndefValue *get(const Type *T, bool locked = true);
+ static UndefValue *get(const Type *T);
/// isNullValue - Return true if this is the value that would be returned by
/// getNullValue.
virtual bool isNullValue() const { return false; }
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const UndefValue *) { return true; }
@@ -881,8 +864,7 @@
public:
/// get() - Static factory methods - Return objects of the specified value.
///
- static MDString *get(const char *StrBegin, const char *StrEnd,
- bool locked = true);
+ static MDString *get(const char *StrBegin, const char *StrEnd);
/// size() - The length of this string.
///
@@ -909,7 +891,7 @@
return false;
}
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const MDString *) { return true; }
Modified: llvm/trunk/include/llvm/GlobalValue.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/GlobalValue.h?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/include/llvm/GlobalValue.h (original)
+++ llvm/trunk/include/llvm/GlobalValue.h Fri Jun 19 19:24:58 2009
@@ -172,7 +172,7 @@
virtual bool isNullValue() const { return false; }
/// Override from Constant class.
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
/// isDeclaration - Return true if the primary definition of this global
/// value is outside of the current translation unit...
Modified: llvm/trunk/include/llvm/MDNode.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MDNode.h?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/include/llvm/MDNode.h (original)
+++ llvm/trunk/include/llvm/MDNode.h Fri Jun 19 19:24:58 2009
@@ -78,7 +78,7 @@
/// get() - Static factory methods - Return objects of the specified value.
///
- static MDNode *get(Value*const* Vals, unsigned NumVals, bool locked = true);
+ static MDNode *get(Value*const* Vals, unsigned NumVals);
Value *getElement(unsigned i) const {
return Node[i];
@@ -117,7 +117,7 @@
/// duplicates
void Profile(FoldingSetNodeID &ID) const;
- virtual void destroyConstant(bool locked = true);
+ virtual void destroyConstant();
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
assert(0 && "This should never be called because MDNodes have no ops");
abort();
Modified: llvm/trunk/lib/VMCore/ConstantFold.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/ConstantFold.cpp?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/ConstantFold.cpp (original)
+++ llvm/trunk/lib/VMCore/ConstantFold.cpp Fri Jun 19 19:24:58 2009
@@ -40,8 +40,7 @@
/// specified vector type. At this point, we know that the elements of the
/// input vector constant are all simple integer or FP values.
static Constant *BitCastConstantVector(ConstantVector *CV,
- const VectorType *DstTy,
- bool locked) {
+ const VectorType *DstTy) {
// If this cast changes element count then we can't handle it here:
// doing so requires endianness information. This should be handled by
// Analysis/ConstantFolding.cpp
@@ -61,7 +60,7 @@
const Type *DstEltTy = DstTy->getElementType();
for (unsigned i = 0; i != NumElts; ++i)
Result.push_back(ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy));
- return ConstantVector::get(Result, locked);
+ return ConstantVector::get(Result);
}
/// This function determines which opcode to use to fold two constant cast
@@ -89,8 +88,7 @@
Type::Int64Ty);
}
-static Constant *FoldBitCast(Constant *V, const Type *DestTy,
- bool locked = true) {
+static Constant *FoldBitCast(Constant *V, const Type *DestTy) {
const Type *SrcTy = V->getType();
if (SrcTy == DestTy)
return V; // no-op cast
@@ -101,7 +99,7 @@
if (const PointerType *DPTy = dyn_cast<PointerType>(DestTy))
if (PTy->getAddressSpace() == DPTy->getAddressSpace()) {
SmallVector<Value*, 8> IdxList;
- IdxList.push_back(Constant::getNullValue(Type::Int32Ty, locked));
+ IdxList.push_back(Constant::getNullValue(Type::Int32Ty));
const Type *ElTy = PTy->getElementType();
while (ElTy != DPTy->getElementType()) {
if (const StructType *STy = dyn_cast<StructType>(ElTy)) {
@@ -119,8 +117,7 @@
}
if (ElTy == DPTy->getElementType())
- return ConstantExpr::getGetElementPtr(V, &IdxList[0],
- IdxList.size(), locked);
+ return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size());
}
// Handle casts from one vector constant to another. We know that the src
@@ -132,24 +129,23 @@
SrcTy = NULL;
// First, check for null. Undef is already handled.
if (isa<ConstantAggregateZero>(V))
- return Constant::getNullValue(DestTy, locked);
+ return Constant::getNullValue(DestTy);
if (ConstantVector *CV = dyn_cast<ConstantVector>(V))
- return BitCastConstantVector(CV, DestPTy, locked);
+ return BitCastConstantVector(CV, DestPTy);
}
// Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
// This allows for other simplifications (although some of them
// can only be handled by Analysis/ConstantFolding.cpp).
if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
- return ConstantExpr::getBitCast(ConstantVector::get(&V, 1, locked),
- DestPTy, locked);
+ return ConstantExpr::getBitCast(ConstantVector::get(&V, 1), DestPTy);
}
// Finally, implement bitcast folding now. The code below doesn't handle
// bitcast right.
if (isa<ConstantPointerNull>(V)) // ptr->ptr cast.
- return ConstantPointerNull::get(cast<PointerType>(DestTy), locked);
+ return ConstantPointerNull::get(cast<PointerType>(DestTy));
// Handle integral constant input.
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
@@ -160,7 +156,7 @@
if (DestTy->isFloatingPoint())
return ConstantFP::get(APFloat(CI->getValue(),
- DestTy != Type::PPC_FP128Ty), locked);
+ DestTy != Type::PPC_FP128Ty));
// Otherwise, can't fold this (vector?)
return 0;
@@ -169,22 +165,22 @@
// Handle ConstantFP input.
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V))
// FP -> Integral.
- return ConstantInt::get(FP->getValueAPF().bitcastToAPInt(), locked);
+ return ConstantInt::get(FP->getValueAPF().bitcastToAPInt());
return 0;
}
Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
- const Type *DestTy, bool locked) {
+ const Type *DestTy) {
if (isa<UndefValue>(V)) {
// zext(undef) = 0, because the top bits will be zero.
// sext(undef) = 0, because the top bits will all be the same.
// [us]itofp(undef) = 0, because the result value is bounded.
if (opc == Instruction::ZExt || opc == Instruction::SExt ||
opc == Instruction::UIToFP || opc == Instruction::SIToFP)
- return Constant::getNullValue(DestTy, locked);
- return UndefValue::get(DestTy, locked);
+ return Constant::getNullValue(DestTy);
+ return UndefValue::get(DestTy);
}
// No compile-time operations on this type yet.
if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty)
@@ -196,7 +192,7 @@
if (CE->isCast()) {
// Try hard to fold cast of cast because they are often eliminable.
if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
- return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy, locked);
+ return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy);
} else if (CE->getOpcode() == Instruction::GetElementPtr) {
// If all of the indexes in the GEP are null values, there is no pointer
// adjustment going on. We might as well cast the source pointer.
@@ -208,7 +204,7 @@
}
if (isAllNull)
// This is casting one pointer type to another, always BitCast
- return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy, locked);
+ return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy);
}
}
@@ -224,8 +220,8 @@
const Type *DstEltTy = DestVecTy->getElementType();
for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
res.push_back(ConstantExpr::getCast(opc,
- CV->getOperand(i), DstEltTy, locked));
- return ConstantVector::get(DestVecTy, res, locked);
+ CV->getOperand(i), DstEltTy));
+ return ConstantVector::get(DestVecTy, res);
}
// We actually have to do a cast now. Perform the cast according to the
@@ -242,7 +238,7 @@
DestTy == Type::FP128Ty ? APFloat::IEEEquad :
APFloat::Bogus,
APFloat::rmNearestTiesToEven, &ignored);
- return ConstantFP::get(Val, locked);
+ return ConstantFP::get(Val);
}
return 0; // Can't fold.
case Instruction::FPToUI:
@@ -255,16 +251,16 @@
(void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
APFloat::rmTowardZero, &ignored);
APInt Val(DestBitWidth, 2, x);
- return ConstantInt::get(Val, locked);
+ return ConstantInt::get(Val);
}
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
- return ConstantPointerNull::get(cast<PointerType>(DestTy), locked);
+ return ConstantPointerNull::get(cast<PointerType>(DestTy));
return 0; // Other pointer types cannot be casted
case Instruction::PtrToInt: // always treated as unsigned
if (V->isNullValue()) // is it a null pointer value?
- return ConstantInt::get(DestTy, 0, locked);
+ return ConstantInt::get(DestTy, 0);
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
case Instruction::SIToFP:
@@ -276,7 +272,7 @@
(void)apf.convertFromAPInt(api,
opc==Instruction::SIToFP,
APFloat::rmNearestTiesToEven);
- return ConstantFP::get(apf, locked);
+ return ConstantFP::get(apf);
}
return 0;
case Instruction::ZExt:
@@ -284,7 +280,7 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.zext(BitWidth);
- return ConstantInt::get(Result, locked);
+ return ConstantInt::get(Result);
}
return 0;
case Instruction::SExt:
@@ -292,7 +288,7 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.sext(BitWidth);
- return ConstantInt::get(Result, locked);
+ return ConstantInt::get(Result);
}
return 0;
case Instruction::Trunc:
@@ -300,11 +296,11 @@
uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
APInt Result(CI->getValue());
Result.trunc(BitWidth);
- return ConstantInt::get(Result, locked);
+ return ConstantInt::get(Result);
}
return 0;
case Instruction::BitCast:
- return FoldBitCast(const_cast<Constant*>(V), DestTy, locked);
+ return FoldBitCast(const_cast<Constant*>(V), DestTy);
default:
assert(!"Invalid CE CastInst opcode");
break;
@@ -316,7 +312,7 @@
Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond,
const Constant *V1,
- const Constant *V2, bool locked) {
+ const Constant *V2) {
if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
return const_cast<Constant*>(CB->getZExtValue() ? V1 : V2);
@@ -570,22 +566,21 @@
static Constant *EvalVectorOp(const ConstantVector *V1,
const ConstantVector *V2,
const VectorType *VTy,
- Constant *(*FP)(Constant*, Constant*, bool)) {
+ Constant *(*FP)(Constant*, Constant*)) {
std::vector<Constant*> Res;
const Type *EltTy = VTy->getElementType();
for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
const Constant *C1 = V1 ? V1->getOperand(i) : Constant::getNullValue(EltTy);
const Constant *C2 = V2 ? V2->getOperand(i) : Constant::getNullValue(EltTy);
Res.push_back(FP(const_cast<Constant*>(C1),
- const_cast<Constant*>(C2), true));
+ const_cast<Constant*>(C2)));
}
return ConstantVector::get(Res);
}
Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
const Constant *C1,
- const Constant *C2,
- bool locked) {
+ const Constant *C2) {
// No compile-time operations on this type yet.
if (C1->getType() == Type::PPC_FP128Ty)
return 0;
@@ -597,29 +592,29 @@
if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
// Handle undef ^ undef -> 0 special case. This is a common
// idiom (misuse).
- return Constant::getNullValue(C1->getType(), locked);
+ return Constant::getNullValue(C1->getType());
// Fallthrough
case Instruction::Add:
case Instruction::Sub:
- return UndefValue::get(C1->getType(), locked);
+ return UndefValue::get(C1->getType());
case Instruction::Mul:
case Instruction::And:
- return Constant::getNullValue(C1->getType(), locked);
+ return Constant::getNullValue(C1->getType());
case Instruction::UDiv:
case Instruction::SDiv:
case Instruction::URem:
case Instruction::SRem:
if (!isa<UndefValue>(C2)) // undef / X -> 0
- return Constant::getNullValue(C1->getType(), locked);
+ return Constant::getNullValue(C1->getType());
return const_cast<Constant*>(C2); // X / undef -> undef
case Instruction::Or: // X | undef -> -1
if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType()))
- return ConstantVector::getAllOnesValue(PTy, locked);
- return ConstantInt::getAllOnesValue(C1->getType(), locked);
+ return ConstantVector::getAllOnesValue(PTy);
+ return ConstantInt::getAllOnesValue(C1->getType());
case Instruction::LShr:
if (isa<UndefValue>(C2) && isa<UndefValue>(C1))
return const_cast<Constant*>(C1); // undef lshr undef -> undef
- return Constant::getNullValue(C1->getType(), locked); // X lshr undef -> 0
+ return Constant::getNullValue(C1->getType()); // X lshr undef -> 0
// undef lshr X -> 0
case Instruction::AShr:
if (!isa<UndefValue>(C2))
@@ -630,7 +625,7 @@
return const_cast<Constant*>(C1); // X ashr undef --> X
case Instruction::Shl:
// undef << X -> 0 or X << undef -> 0
- return Constant::getNullValue(C1->getType(), locked);
+ return Constant::getNullValue(C1->getType());
}
}
@@ -1577,7 +1572,7 @@
Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
Constant* const *Idxs,
- unsigned NumIdx, bool locked) {
+ unsigned NumIdx) {
if (NumIdx == 0 ||
(NumIdx == 1 && Idxs[0]->isNullValue()))
return const_cast<Constant*>(C);
@@ -1588,8 +1583,7 @@
(Value **)Idxs,
(Value **)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
- return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace()),
- locked);
+ return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace()));
}
Constant *Idx0 = Idxs[0];
@@ -1607,8 +1601,7 @@
(Value**)Idxs+NumIdx);
assert(Ty != 0 && "Invalid indices for GEP!");
return
- ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace()),
- locked);
+ ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace()));
}
}
@@ -1636,22 +1629,20 @@
if (!Idx0->isNullValue()) {
const Type *IdxTy = Combined->getType();
if (IdxTy != Idx0->getType()) {
- Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, Type::Int64Ty,
- locked);
+ Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, Type::Int64Ty);
Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined,
- Type::Int64Ty,
- locked);
- Combined = ConstantExpr::get(Instruction::Add, C1, C2, locked);
+ Type::Int64Ty);
+ Combined = ConstantExpr::get(Instruction::Add, C1, C2);
} else {
Combined =
- ConstantExpr::get(Instruction::Add, Idx0, Combined, locked);
+ ConstantExpr::get(Instruction::Add, Idx0, Combined);
}
}
NewIndices.push_back(Combined);
NewIndices.insert(NewIndices.end(), Idxs+1, Idxs+NumIdx);
return ConstantExpr::getGetElementPtr(CE->getOperand(0), &NewIndices[0],
- NewIndices.size(), locked);
+ NewIndices.size());
}
}
@@ -1668,7 +1659,7 @@
dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType()))
if (CAT->getElementType() == SAT->getElementType())
return ConstantExpr::getGetElementPtr(
- (Constant*)CE->getOperand(0), Idxs, NumIdx, locked);
+ (Constant*)CE->getOperand(0), Idxs, NumIdx);
}
// Fold: getelementptr (i8* inttoptr (i64 1 to i8*), i32 -1)
@@ -1686,10 +1677,10 @@
Offset = ConstantExpr::getSExt(Offset, Base->getType());
else if (Base->getType()->getPrimitiveSizeInBits() <
Offset->getType()->getPrimitiveSizeInBits())
- Base = ConstantExpr::getZExt(Base, Offset->getType(), locked);
+ Base = ConstantExpr::getZExt(Base, Offset->getType());
- Base = ConstantExpr::getAdd(Base, Offset, locked);
- return ConstantExpr::getIntToPtr(Base, CE->getType(), locked);
+ Base = ConstantExpr::getAdd(Base, Offset);
+ return ConstantExpr::getIntToPtr(Base, CE->getType());
}
}
return 0;
Modified: llvm/trunk/lib/VMCore/Constants.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Constants.cpp?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/Constants.cpp (original)
+++ llvm/trunk/lib/VMCore/Constants.cpp Fri Jun 19 19:24:58 2009
@@ -25,6 +25,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/System/Mutex.h"
#include "llvm/System/RWMutex.h"
#include "llvm/System/Threading.h"
#include "llvm/ADT/DenseMap.h"
@@ -127,27 +128,27 @@
}
// Static constructor to create a '0' constant of arbitrary type...
-Constant *Constant::getNullValue(const Type *Ty, bool locked) {
+Constant *Constant::getNullValue(const Type *Ty) {
static uint64_t zero[2] = {0, 0};
switch (Ty->getTypeID()) {
case Type::IntegerTyID:
- return ConstantInt::get(Ty, 0, locked);
+ return ConstantInt::get(Ty, 0);
case Type::FloatTyID:
- return ConstantFP::get(APFloat(APInt(32, 0)), locked);
+ return ConstantFP::get(APFloat(APInt(32, 0)));
case Type::DoubleTyID:
- return ConstantFP::get(APFloat(APInt(64, 0)), locked);
+ return ConstantFP::get(APFloat(APInt(64, 0)));
case Type::X86_FP80TyID:
- return ConstantFP::get(APFloat(APInt(80, 2, zero)), locked);
+ return ConstantFP::get(APFloat(APInt(80, 2, zero)));
case Type::FP128TyID:
- return ConstantFP::get(APFloat(APInt(128, 2, zero), true), locked);
+ return ConstantFP::get(APFloat(APInt(128, 2, zero), true));
case Type::PPC_FP128TyID:
- return ConstantFP::get(APFloat(APInt(128, 2, zero)), locked);
+ return ConstantFP::get(APFloat(APInt(128, 2, zero)));
case Type::PointerTyID:
- return ConstantPointerNull::get(cast<PointerType>(Ty), locked);
+ return ConstantPointerNull::get(cast<PointerType>(Ty));
case Type::StructTyID:
case Type::ArrayTyID:
case Type::VectorTyID:
- return ConstantAggregateZero::get(Ty, locked);
+ return ConstantAggregateZero::get(Ty);
default:
// Function, Label, or Opaque type?
assert(!"Cannot create a null constant of that type!");
@@ -162,22 +163,21 @@
}
// Static constructor to create an integral constant with all bits set
-ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty, bool locked) {
+ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
- return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()), locked);
+ return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
return 0;
}
/// @returns the value for a vector integer constant of the given type that
/// has all its bits set to true.
/// @brief Get the all ones value
-ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty,
- bool locked) {
+ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) {
std::vector<Constant*> Elts;
Elts.resize(Ty->getNumElements(),
- ConstantInt::getAllOnesValue(Ty->getElementType(), locked));
+ ConstantInt::getAllOnesValue(Ty->getElementType()));
assert(Elts[0] && "Not a vector integer type!");
- return cast<ConstantVector>(ConstantVector::get(Elts, locked));
+ return cast<ConstantVector>(ConstantVector::get(Elts));
}
@@ -276,19 +276,17 @@
static ManagedStatic<IntMapTy> IntConstants;
ConstantInt *ConstantInt::get(const IntegerType *Ty,
- uint64_t V, bool isSigned, bool locked) {
- return get(APInt(Ty->getBitWidth(), V, isSigned), locked);
+ uint64_t V, bool isSigned) {
+ return get(APInt(Ty->getBitWidth(), V, isSigned));
}
-Constant *ConstantInt::get(const Type *Ty, uint64_t V,
- bool isSigned, bool locked) {
+Constant *ConstantInt::get(const Type *Ty, uint64_t V, bool isSigned) {
Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
// For vectors, broadcast the value.
if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
return
- ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C),
- locked);
+ ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C));
return C;
}
@@ -298,42 +296,38 @@
// operator== and operator!= to ensure that the DenseMap doesn't attempt to
// compare APInt's of different widths, which would violate an APInt class
// invariant which generates an assertion.
-ConstantInt *ConstantInt::get(const APInt& V, bool locked) {
+ConstantInt *ConstantInt::get(const APInt& V) {
// Get the corresponding integer type for the bit width of the value.
const IntegerType *ITy = IntegerType::get(V.getBitWidth());
// get an existing value or the insertion position
DenseMapAPIntKeyInfo::KeyTy Key(V, ITy);
- if (locked) ConstantsLock->reader_acquire();
+ ConstantsLock->reader_acquire();
ConstantInt *&Slot = (*IntConstants)[Key];
- if (locked) ConstantsLock->reader_release();
+ ConstantsLock->reader_release();
if (!Slot) {
- if (locked) {
- sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
- ConstantInt *&NewSlot = (*IntConstants)[Key];
- if (!Slot) {
- NewSlot = new ConstantInt(ITy, V);
- }
- return NewSlot;
- } else {
- Slot = new ConstantInt(ITy, V);
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
+ ConstantInt *&NewSlot = (*IntConstants)[Key];
+ if (!Slot) {
+ NewSlot = new ConstantInt(ITy, V);
}
+
+ return NewSlot;
+ } else {
+ return Slot;
}
-
- return Slot;
}
-Constant *ConstantInt::get(const Type *Ty, const APInt &V, bool locked) {
- ConstantInt *C = ConstantInt::get(V, locked);
+Constant *ConstantInt::get(const Type *Ty, const APInt &V) {
+ ConstantInt *C = ConstantInt::get(V);
assert(C->getType() == Ty->getScalarType() &&
"ConstantInt type doesn't match the type implied by its value!");
// For vectors, broadcast the value.
if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
return
- ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C),
- locked);
+ ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C));
return C;
}
@@ -412,37 +406,17 @@
static ManagedStatic<FPMapTy> FPConstants;
-ConstantFP *ConstantFP::get(const APFloat &V, bool locked) {
+ConstantFP *ConstantFP::get(const APFloat &V) {
DenseMapAPFloatKeyInfo::KeyTy Key(V);
- if (locked) ConstantsLock->reader_acquire();
+ ConstantsLock->reader_acquire();
ConstantFP *&Slot = (*FPConstants)[Key];
- if (locked) ConstantsLock->reader_release();
+ ConstantsLock->reader_release();
if (!Slot) {
- if (locked) {
- sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
- ConstantFP *&NewSlot = (*FPConstants)[Key];
- if (!NewSlot) {
- const Type *Ty;
- if (&V.getSemantics() == &APFloat::IEEEsingle)
- Ty = Type::FloatTy;
- else if (&V.getSemantics() == &APFloat::IEEEdouble)
- Ty = Type::DoubleTy;
- else if (&V.getSemantics() == &APFloat::x87DoubleExtended)
- Ty = Type::X86_FP80Ty;
- else if (&V.getSemantics() == &APFloat::IEEEquad)
- Ty = Type::FP128Ty;
- else {
- assert(&V.getSemantics() == &APFloat::PPCDoubleDouble &&
- "Unknown FP format");
- Ty = Type::PPC_FP128Ty;
- }
- NewSlot = new ConstantFP(Ty, V);
- }
-
- return NewSlot;
- } else {
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
+ ConstantFP *&NewSlot = (*FPConstants)[Key];
+ if (!NewSlot) {
const Type *Ty;
if (&V.getSemantics() == &APFloat::IEEEsingle)
Ty = Type::FloatTy;
@@ -457,8 +431,10 @@
"Unknown FP format");
Ty = Type::PPC_FP128Ty;
}
- Slot = new ConstantFP(Ty, V);
+ NewSlot = new ConstantFP(Ty, V);
}
+
+ return NewSlot;
}
return Slot;
@@ -467,18 +443,17 @@
/// get() - This returns a constant fp for the specified value in the
/// specified type. This should only be used for simple constant values like
/// 2.0/1.0 etc, that are known-valid both as double and as the target format.
-Constant *ConstantFP::get(const Type *Ty, double V, bool locked) {
+Constant *ConstantFP::get(const Type *Ty, double V) {
APFloat FV(V);
bool ignored;
FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
APFloat::rmNearestTiesToEven, &ignored);
- Constant *C = get(FV, locked);
+ Constant *C = get(FV);
// For vectors, broadcast the value.
if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
return
- ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C),
- locked);
+ ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C));
return C;
}
@@ -882,50 +857,50 @@
return get(Instruction::Xor, C,
Constant::getAllOnesValue(C->getType()));
}
-Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Add, C1, C2, locked);
+Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2) {
+ return get(Instruction::Add, C1, C2);
}
-Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::FAdd, C1, C2, locked);
+Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
+ return get(Instruction::FAdd, C1, C2);
}
-Constant *ConstantExpr::getSub(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Sub, C1, C2, locked);
+Constant *ConstantExpr::getSub(Constant *C1, Constant *C2) {
+ return get(Instruction::Sub, C1, C2);
}
-Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::FSub, C1, C2, locked);
+Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
+ return get(Instruction::FSub, C1, C2);
}
-Constant *ConstantExpr::getMul(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Mul, C1, C2, locked);
+Constant *ConstantExpr::getMul(Constant *C1, Constant *C2) {
+ return get(Instruction::Mul, C1, C2);
}
-Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::FMul, C1, C2, locked);
+Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
+ return get(Instruction::FMul, C1, C2);
}
-Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::UDiv, C1, C2, locked);
+Constant *ConstantExpr::getUDiv(Constant *C1, Constant *C2) {
+ return get(Instruction::UDiv, C1, C2);
}
-Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::SDiv, C1, C2, locked);
+Constant *ConstantExpr::getSDiv(Constant *C1, Constant *C2) {
+ return get(Instruction::SDiv, C1, C2);
}
-Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::FDiv, C1, C2, locked);
+Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
+ return get(Instruction::FDiv, C1, C2);
}
-Constant *ConstantExpr::getURem(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::URem, C1, C2, locked);
+Constant *ConstantExpr::getURem(Constant *C1, Constant *C2) {
+ return get(Instruction::URem, C1, C2);
}
-Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::SRem, C1, C2, locked);
+Constant *ConstantExpr::getSRem(Constant *C1, Constant *C2) {
+ return get(Instruction::SRem, C1, C2);
}
-Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::FRem, C1, C2, locked);
+Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
+ return get(Instruction::FRem, C1, C2);
}
-Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::And, C1, C2, locked);
+Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
+ return get(Instruction::And, C1, C2);
}
-Constant *ConstantExpr::getOr(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Or, C1, C2, locked);
+Constant *ConstantExpr::getOr(Constant *C1, Constant *C2) {
+ return get(Instruction::Or, C1, C2);
}
-Constant *ConstantExpr::getXor(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Xor, C1, C2, locked);
+Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
+ return get(Instruction::Xor, C1, C2);
}
unsigned ConstantExpr::getPredicate() const {
assert(getOpcode() == Instruction::FCmp ||
@@ -934,14 +909,14 @@
getOpcode() == Instruction::VICmp);
return ((const CompareConstantExpr*)this)->predicate;
}
-Constant *ConstantExpr::getShl(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::Shl, C1, C2, locked);
+Constant *ConstantExpr::getShl(Constant *C1, Constant *C2) {
+ return get(Instruction::Shl, C1, C2);
}
-Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::LShr, C1, C2, locked);
+Constant *ConstantExpr::getLShr(Constant *C1, Constant *C2) {
+ return get(Instruction::LShr, C1, C2);
}
-Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool locked) {
- return get(Instruction::AShr, C1, C2, locked);
+Constant *ConstantExpr::getAShr(Constant *C1, Constant *C2) {
+ return get(Instruction::AShr, C1, C2);
}
/// getWithOperandReplaced - Return a constant expression identical to this
@@ -1178,6 +1153,9 @@
/// AbstractTypeMap - Map for abstract type constants.
///
AbstractTypeMapTy AbstractTypeMap;
+
+ /// ValueMapLock - Mutex for this map.
+ sys::SmartMutex<true> ValueMapLock;
public:
// NOTE: This function is not locked. It is the caller's responsibility
@@ -1253,36 +1231,7 @@
/// getOrCreate - Return the specified constant from the map, creating it if
/// necessary.
ConstantClass *getOrCreate(const TypeClass *Ty, const ValType &V) {
- MapKey Lookup(Ty, V);
- ConstantClass* Result = 0;
-
- ConstantsLock->reader_acquire();
- typename MapTy::iterator I = Map.find(Lookup);
- // Is it in the map?
- if (I != Map.end())
- Result = static_cast<ConstantClass *>(I->second);
- ConstantsLock->reader_release();
-
- if (!Result) {
- sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
- I = Map.find(Lookup);
- // Is it in the map?
- if (I != Map.end())
- Result = static_cast<ConstantClass *>(I->second);
- if (!Result) {
- // If no preexisting value, create one now...
- Result = Create(Ty, V, I);
- }
- }
-
- return Result;
- }
-
- /// unlockedGetOrCreate - Return the specified constant from the map,
- /// creating it if necessary. This version performs no locking, and should
- /// only be used during recursive type refinement, when the locks are
- /// already held.
- ConstantClass *unlockedGetOrCreate(const TypeClass *Ty, const ValType &V) {
+ sys::SmartScopedLock<true> Lock(&ValueMapLock);
MapKey Lookup(Ty, V);
ConstantClass* Result = 0;
@@ -1299,8 +1248,8 @@
return Result;
}
- void remove(ConstantClass *CP, bool locked = true) {
- if (locked) ConstantsLock->writer_acquire();
+ void remove(ConstantClass *CP) {
+ sys::SmartScopedLock<true> Lock(&ValueMapLock);
typename MapTy::iterator I = FindExistingElement(CP);
assert(I != Map.end() && "Constant not found in constant table!");
assert(I->second == CP && "Didn't find correct element?");
@@ -1348,8 +1297,6 @@
}
Map.erase(I);
-
- if (locked) ConstantsLock->writer_release();
}
@@ -1387,7 +1334,7 @@
}
void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
- ConstantsLock->writer_acquire();
+ sys::SmartScopedLock<true> Lock(&ValueMapLock);
typename AbstractTypeMapTy::iterator I =
AbstractTypeMap.find(cast<Type>(OldTy));
@@ -1405,14 +1352,11 @@
I = AbstractTypeMap.find(cast<Type>(OldTy));
} while (I != AbstractTypeMap.end());
-
- ConstantsLock->writer_release();
}
// If the type became concrete without being refined to any other existing
// type, we just remove ourselves from the ATU list.
void typeBecameConcrete(const DerivedType *AbsTy) {
- sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
AbsTy->removeAbstractTypeUser(this);
}
@@ -1439,10 +1383,10 @@
struct ConvertConstantType<ConstantAggregateZero, Type> {
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type...
- Constant *New = ConstantAggregateZero::get(NewTy, false);
+ Constant *New = ConstantAggregateZero::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1452,19 +1396,19 @@
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
-ConstantAggregateZero *ConstantAggregateZero::get(const Type *Ty, bool locked) {
+ConstantAggregateZero *ConstantAggregateZero::get(const Type *Ty) {
assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&
"Cannot create an aggregate zero of non-aggregate type!");
-
- return locked ? AggZeroConstants->getOrCreate(Ty, 0) :
- AggZeroConstants->unlockedGetOrCreate(Ty, 0);
+
+ // Implicitly locked.
+ return AggZeroConstants->getOrCreate(Ty, 0);
}
/// destroyConstant - Remove the constant from the constant table...
///
-void ConstantAggregateZero::destroyConstant(bool locked) {
+void ConstantAggregateZero::destroyConstant() {
// Implicitly locked.
- AggZeroConstants->remove(this, locked);
+ AggZeroConstants->remove(this);
destroyConstantImpl();
}
@@ -1478,10 +1422,10 @@
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, false);
+ Constant *New = ConstantArray::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1499,36 +1443,29 @@
static ManagedStatic<ArrayConstantsTy> ArrayConstants;
Constant *ConstantArray::get(const ArrayType *Ty,
- const std::vector<Constant*> &V,
- bool locked) {
+ 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()) {
- if (locked)
- // Implicitly locked.
- return ArrayConstants->getOrCreate(Ty, V);
- else
- return ArrayConstants->unlockedGetOrCreate(Ty, V);
+ // Implicitly locked.
+ return ArrayConstants->getOrCreate(Ty, V);
}
for (unsigned i = 1, e = V.size(); i != e; ++i)
if (V[i] != C) {
- if (locked)
- // Implicitly locked.
- return ArrayConstants->getOrCreate(Ty, V);
- else
- return ArrayConstants->unlockedGetOrCreate(Ty, V);
+ // Implicitly locked.
+ return ArrayConstants->getOrCreate(Ty, V);
}
}
- return ConstantAggregateZero::get(Ty, locked);
+ return ConstantAggregateZero::get(Ty);
}
/// destroyConstant - Remove the constant from the constant table...
///
-void ConstantArray::destroyConstant(bool locked) {
+void ConstantArray::destroyConstant() {
// Implicitly locked.
- ArrayConstants->remove(this, locked);
+ ArrayConstants->remove(this);
destroyConstantImpl();
}
@@ -1538,8 +1475,7 @@
/// Otherwise, the length parameter specifies how much of the string to use
/// and it won't be null terminated.
///
-Constant *ConstantArray::get(const std::string &Str,
- bool AddNull, bool locked) {
+Constant *ConstantArray::get(const std::string &Str, bool AddNull) {
std::vector<Constant*> ElementVals;
for (unsigned i = 0; i < Str.length(); ++i)
ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
@@ -1550,7 +1486,7 @@
}
ArrayType *ATy = ArrayType::get(Type::Int8Ty, ElementVals.size());
- return ConstantArray::get(ATy, ElementVals, locked);
+ return ConstantArray::get(ATy, ElementVals);
}
/// isString - This method returns true if the array is an array of i8, and
@@ -1614,11 +1550,11 @@
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, false);
+ Constant *New = ConstantStruct::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1636,31 +1572,29 @@
}
Constant *ConstantStruct::get(const StructType *Ty,
- const std::vector<Constant*> &V,
- bool locked) {
+ 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())
- return locked ? StructConstants->getOrCreate(Ty, V) :
- StructConstants->unlockedGetOrCreate(Ty, V);
+ // Implicitly locked.
+ return StructConstants->getOrCreate(Ty, V);
- return ConstantAggregateZero::get(Ty, locked);
+ return ConstantAggregateZero::get(Ty);
}
-Constant *ConstantStruct::get(const std::vector<Constant*> &V, bool packed,
- bool locked) {
+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, locked);
+ return get(StructType::get(StructEls, packed), V);
}
// destroyConstant - Remove the constant from the constant table...
//
-void ConstantStruct::destroyConstant(bool locked) {
+void ConstantStruct::destroyConstant() {
// Implicitly locked.
- StructConstants->remove(this, locked);
+ StructConstants->remove(this);
destroyConstantImpl();
}
@@ -1674,10 +1608,10 @@
std::vector<Constant*> C;
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
C.push_back(cast<Constant>(OldC->getOperand(i)));
- Constant *New = ConstantVector::get(NewTy, C, false);
+ Constant *New = ConstantVector::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1694,8 +1628,7 @@
ConstantVector> > VectorConstants;
Constant *ConstantVector::get(const VectorType *Ty,
- const std::vector<Constant*> &V,
- bool locked) {
+ const std::vector<Constant*> &V) {
assert(!V.empty() && "Vectors can't be empty");
// If this is an all-undef or alll-zero vector, return a
// ConstantAggregateZero or UndefValue.
@@ -1712,24 +1645,24 @@
}
if (isZero)
- return ConstantAggregateZero::get(Ty, locked);
+ return ConstantAggregateZero::get(Ty);
if (isUndef)
- return UndefValue::get(Ty, locked);
+ return UndefValue::get(Ty);
- return locked ? VectorConstants->getOrCreate(Ty, V) :
- VectorConstants->unlockedGetOrCreate(Ty, V);
+ // Implicitly locked.
+ return VectorConstants->getOrCreate(Ty, V);
}
-Constant *ConstantVector::get(const std::vector<Constant*> &V, bool locked) {
+Constant *ConstantVector::get(const std::vector<Constant*> &V) {
assert(!V.empty() && "Cannot infer type if V is empty");
- return get(VectorType::get(V.front()->getType(),V.size()), V, locked);
+ return get(VectorType::get(V.front()->getType(),V.size()), V);
}
// destroyConstant - Remove the constant from the constant table...
//
-void ConstantVector::destroyConstant(bool locked) {
+void ConstantVector::destroyConstant() {
// Implicitly locked.
- VectorConstants->remove(this, locked);
+ VectorConstants->remove(this);
destroyConstantImpl();
}
@@ -1776,10 +1709,10 @@
struct ConvertConstantType<ConstantPointerNull, PointerType> {
static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
// Make everyone now use a constant of the new type...
- Constant *New = ConstantPointerNull::get(NewTy, false);
+ Constant *New = ConstantPointerNull::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1792,18 +1725,16 @@
}
-ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty,
- bool locked) {
+ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
// Implicitly locked.
- return locked ? NullPtrConstants->getOrCreate(Ty, 0) :
- NullPtrConstants->unlockedGetOrCreate(Ty, 0);
+ return NullPtrConstants->getOrCreate(Ty, 0);
}
// destroyConstant - Remove the constant from the constant table...
//
-void ConstantPointerNull::destroyConstant(bool locked) {
+void ConstantPointerNull::destroyConstant() {
// Implicitly locked.
- NullPtrConstants->remove(this, locked);
+ NullPtrConstants->remove(this);
destroyConstantImpl();
}
@@ -1824,10 +1755,10 @@
struct ConvertConstantType<UndefValue, Type> {
static void convert(UndefValue *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type.
- Constant *New = UndefValue::get(NewTy, false);
+ Constant *New = UndefValue::get(NewTy);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
}
@@ -1839,16 +1770,16 @@
}
-UndefValue *UndefValue::get(const Type *Ty, bool locked) {
- return locked ? UndefValueConstants->getOrCreate(Ty, 0) :
- UndefValueConstants->unlockedGetOrCreate(Ty, 0);
+UndefValue *UndefValue::get(const Type *Ty) {
+ // Implicitly locked.
+ return UndefValueConstants->getOrCreate(Ty, 0);
}
// destroyConstant - Remove the constant from the constant table.
//
-void UndefValue::destroyConstant(bool locked) {
+void UndefValue::destroyConstant() {
// Implicitly locked.
- UndefValueConstants->remove(this, locked);
+ UndefValueConstants->remove(this);
destroyConstantImpl();
}
@@ -1861,25 +1792,21 @@
static ManagedStatic<StringMap<MDString*> > MDStringCache;
-MDString *MDString::get(const char *StrBegin, const char *StrEnd, bool locked) {
- if (locked) ConstantsLock->writer_acquire();
-
+MDString *MDString::get(const char *StrBegin, const char *StrEnd) {
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
StringMapEntry<MDString *> &Entry = MDStringCache->GetOrCreateValue(
StrBegin, StrEnd);
MDString *&S = Entry.getValue();
if (!S) S = new MDString(Entry.getKeyData(),
Entry.getKeyData() + Entry.getKeyLength());
- if (locked) ConstantsLock->writer_release();
-
return S;
}
-void MDString::destroyConstant(bool locked) {
- if (locked) ConstantsLock->writer_acquire();
+void MDString::destroyConstant() {
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
MDStringCache->erase(MDStringCache->find(StrBegin, StrEnd));
destroyConstantImpl();
- if (locked) ConstantsLock->writer_release();
}
//---- MDNode::get() implementation
@@ -1898,26 +1825,20 @@
ID.AddPointer(*I);
}
-MDNode *MDNode::get(Value*const* Vals, unsigned NumVals, bool locked) {
+MDNode *MDNode::get(Value*const* Vals, unsigned NumVals) {
FoldingSetNodeID ID;
for (unsigned i = 0; i != NumVals; ++i)
ID.AddPointer(Vals[i]);
- if (locked) ConstantsLock->reader_acquire();
+ ConstantsLock->reader_acquire();
void *InsertPoint;
MDNode *N = MDNodeSet->FindNodeOrInsertPos(ID, InsertPoint);
- if (locked) ConstantsLock->reader_release();
+ ConstantsLock->reader_release();
if (!N) {
- if (locked) {
- sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
- N = MDNodeSet->FindNodeOrInsertPos(ID, InsertPoint);
- if (!N) {
- // InsertPoint will have been set by the FindNodeOrInsertPos call.
- N = new(0) MDNode(Vals, NumVals);
- MDNodeSet->InsertNode(N, InsertPoint);
- }
- } else {
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
+ N = MDNodeSet->FindNodeOrInsertPos(ID, InsertPoint);
+ if (!N) {
// InsertPoint will have been set by the FindNodeOrInsertPos call.
N = new(0) MDNode(Vals, NumVals);
MDNodeSet->InsertNode(N, InsertPoint);
@@ -1926,11 +1847,11 @@
return N;
}
-void MDNode::destroyConstant(bool locked) {
- if (locked) ConstantsLock->writer_acquire();
+void MDNode::destroyConstant() {
+ sys::SmartScopedWriter<true> Writer(&*ConstantsLock);
MDNodeSet->RemoveNode(this);
+
destroyConstantImpl();
- if (locked) ConstantsLock->writer_release();
}
//---- ConstantExpr::get() implementations...
@@ -2041,30 +1962,30 @@
case Instruction::IntToPtr:
case Instruction::BitCast:
New = ConstantExpr::getCast(OldC->getOpcode(), OldC->getOperand(0),
- NewTy, false);
+ NewTy);
break;
case Instruction::Select:
New = ConstantExpr::getSelectTy(NewTy, OldC->getOperand(0),
OldC->getOperand(1),
- OldC->getOperand(2), false);
+ OldC->getOperand(2));
break;
default:
assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin &&
OldC->getOpcode() < Instruction::BinaryOpsEnd);
New = ConstantExpr::getTy(NewTy, OldC->getOpcode(), OldC->getOperand(0),
- OldC->getOperand(1), false);
+ OldC->getOperand(1));
break;
case Instruction::GetElementPtr:
// Make everyone now use a constant of the new type...
std::vector<Value*> Idx(OldC->op_begin()+1, OldC->op_end());
New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0),
- &Idx[0], Idx.size(), false);
+ &Idx[0], Idx.size());
break;
}
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
- OldC->destroyConstant(false); // This constant is now dead, destroy it.
+ OldC->destroyConstant(); // This constant is now dead, destroy it.
}
};
} // end namespace llvm
@@ -2087,10 +2008,10 @@
/// This is a utility function to handle folding of casts and lookup of the
/// cast in the ExprConstants map. It is used by the various get* methods below.
static inline Constant *getFoldedCast(
- Instruction::CastOps opc, Constant *C, const Type *Ty, bool locked) {
+ Instruction::CastOps opc, Constant *C, const Type *Ty) {
assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
// Fold a few common cases
- if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty, locked))
+ if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty))
return FC;
// Look up the constant in the table first to ensure uniqueness
@@ -2098,12 +2019,10 @@
ExprMapKeyType Key(opc, argVec);
// Implicitly locked.
- return locked ? ExprConstants->getOrCreate(Ty, Key) :
- ExprConstants->unlockedGetOrCreate(Ty, Key);
+ return ExprConstants->getOrCreate(Ty, Key);
}
-Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty,
- bool locked) {
+Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty) {
Instruction::CastOps opc = Instruction::CastOps(oc);
assert(Instruction::isCast(opc) && "opcode out of range");
assert(C && Ty && "Null arguments to getCast");
@@ -2113,18 +2032,18 @@
default:
assert(0 && "Invalid cast opcode");
break;
- case Instruction::Trunc: return getTrunc(C, Ty, locked);
- case Instruction::ZExt: return getZExt(C, Ty, locked);
- case Instruction::SExt: return getSExt(C, Ty, locked);
- case Instruction::FPTrunc: return getFPTrunc(C, Ty, locked);
- case Instruction::FPExt: return getFPExtend(C, Ty, locked);
- case Instruction::UIToFP: return getUIToFP(C, Ty, locked);
- case Instruction::SIToFP: return getSIToFP(C, Ty, locked);
- case Instruction::FPToUI: return getFPToUI(C, Ty, locked);
- case Instruction::FPToSI: return getFPToSI(C, Ty, locked);
- case Instruction::PtrToInt: return getPtrToInt(C, Ty, locked);
- case Instruction::IntToPtr: return getIntToPtr(C, Ty, locked);
- case Instruction::BitCast: return getBitCast(C, Ty, locked);
+ case Instruction::Trunc: return getTrunc(C, Ty);
+ case Instruction::ZExt: return getZExt(C, Ty);
+ case Instruction::SExt: return getSExt(C, Ty);
+ case Instruction::FPTrunc: return getFPTrunc(C, Ty);
+ case Instruction::FPExt: return getFPExtend(C, Ty);
+ case Instruction::UIToFP: return getUIToFP(C, Ty);
+ case Instruction::SIToFP: return getSIToFP(C, Ty);
+ case Instruction::FPToUI: return getFPToUI(C, Ty);
+ case Instruction::FPToSI: return getFPToSI(C, Ty);
+ case Instruction::PtrToInt: return getPtrToInt(C, Ty);
+ case Instruction::IntToPtr: return getIntToPtr(C, Ty);
+ case Instruction::BitCast: return getBitCast(C, Ty);
}
return 0;
}
@@ -2135,11 +2054,10 @@
return getCast(Instruction::ZExt, C, Ty);
}
-Constant *ConstantExpr::getSExtOrBitCast(Constant *C, const Type *Ty,
- bool locked) {
+Constant *ConstantExpr::getSExtOrBitCast(Constant *C, const Type *Ty) {
if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
- return getCast(Instruction::BitCast, C, Ty, locked);
- return getCast(Instruction::SExt, C, Ty, locked);
+ return getCast(Instruction::BitCast, C, Ty);
+ return getCast(Instruction::SExt, C, Ty);
}
Constant *ConstantExpr::getTruncOrBitCast(Constant *C, const Type *Ty) {
@@ -2148,14 +2066,13 @@
return getCast(Instruction::Trunc, C, Ty);
}
-Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty,
- bool locked) {
+Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty) {
assert(isa<PointerType>(S->getType()) && "Invalid cast");
assert((Ty->isInteger() || isa<PointerType>(Ty)) && "Invalid cast");
if (Ty->isInteger())
- return getCast(Instruction::PtrToInt, S, Ty, locked);
- return getCast(Instruction::BitCast, S, Ty, locked);
+ return getCast(Instruction::PtrToInt, S, Ty);
+ return getCast(Instruction::BitCast, S, Ty);
}
Constant *ConstantExpr::getIntegerCast(Constant *C, const Type *Ty,
@@ -2183,7 +2100,7 @@
return getCast(opcode, C, Ty);
}
-Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2194,10 +2111,10 @@
assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
"SrcTy must be larger than DestTy for Trunc!");
- return getFoldedCast(Instruction::Trunc, C, Ty, locked);
+ return getFoldedCast(Instruction::Trunc, C, Ty);
}
-Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2208,10 +2125,10 @@
assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
"SrcTy must be smaller than DestTy for SExt!");
- return getFoldedCast(Instruction::SExt, C, Ty, locked);
+ return getFoldedCast(Instruction::SExt, C, Ty);
}
-Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2222,10 +2139,10 @@
assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
"SrcTy must be smaller than DestTy for ZExt!");
- return getFoldedCast(Instruction::ZExt, C, Ty, locked);
+ return getFoldedCast(Instruction::ZExt, C, Ty);
}
-Constant *ConstantExpr::getFPTrunc(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getFPTrunc(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2234,10 +2151,10 @@
assert(C->getType()->isFPOrFPVector() && Ty->isFPOrFPVector() &&
C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&&
"This is an illegal floating point truncation!");
- return getFoldedCast(Instruction::FPTrunc, C, Ty, locked);
+ return getFoldedCast(Instruction::FPTrunc, C, Ty);
}
-Constant *ConstantExpr::getFPExtend(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getFPExtend(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2246,10 +2163,10 @@
assert(C->getType()->isFPOrFPVector() && Ty->isFPOrFPVector() &&
C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&&
"This is an illegal floating point extension!");
- return getFoldedCast(Instruction::FPExt, C, Ty, locked);
+ return getFoldedCast(Instruction::FPExt, C, Ty);
}
-Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2257,10 +2174,10 @@
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
assert(C->getType()->isIntOrIntVector() && Ty->isFPOrFPVector() &&
"This is an illegal uint to floating point cast!");
- return getFoldedCast(Instruction::UIToFP, C, Ty, locked);
+ return getFoldedCast(Instruction::UIToFP, C, Ty);
}
-Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2268,10 +2185,10 @@
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
assert(C->getType()->isIntOrIntVector() && Ty->isFPOrFPVector() &&
"This is an illegal sint to floating point cast!");
- return getFoldedCast(Instruction::SIToFP, C, Ty, locked);
+ return getFoldedCast(Instruction::SIToFP, C, Ty);
}
-Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2279,10 +2196,10 @@
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
assert(C->getType()->isFPOrFPVector() && Ty->isIntOrIntVector() &&
"This is an illegal floating point to uint cast!");
- return getFoldedCast(Instruction::FPToUI, C, Ty, locked);
+ return getFoldedCast(Instruction::FPToUI, C, Ty);
}
-Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty, bool locked) {
+Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
#ifndef NDEBUG
bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
bool toVec = Ty->getTypeID() == Type::VectorTyID;
@@ -2290,25 +2207,22 @@
assert((fromVec == toVec) && "Cannot convert from scalar to/from vector");
assert(C->getType()->isFPOrFPVector() && Ty->isIntOrIntVector() &&
"This is an illegal floating point to sint cast!");
- return getFoldedCast(Instruction::FPToSI, C, Ty, locked);
+ return getFoldedCast(Instruction::FPToSI, C, Ty);
}
-Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy,
- bool locked) {
+Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy) {
assert(isa<PointerType>(C->getType()) && "PtrToInt source must be pointer");
assert(DstTy->isInteger() && "PtrToInt destination must be integral");
- return getFoldedCast(Instruction::PtrToInt, C, DstTy, locked);
+ return getFoldedCast(Instruction::PtrToInt, C, DstTy);
}
-Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy,
- bool locked) {
+Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy) {
assert(C->getType()->isInteger() && "IntToPtr source must be integral");
assert(isa<PointerType>(DstTy) && "IntToPtr destination must be a pointer");
- return getFoldedCast(Instruction::IntToPtr, C, DstTy, locked);
+ return getFoldedCast(Instruction::IntToPtr, C, DstTy);
}
-Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy,
- bool locked) {
+Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy) {
// BitCast implies a no-op cast of type only. No bits change. However, you
// can't cast pointers to anything but pointers.
#ifndef NDEBUG
@@ -2328,7 +2242,7 @@
// speedily.
if (C->getType() == DstTy) return C;
- return getFoldedCast(Instruction::BitCast, C, DstTy, locked);
+ return getFoldedCast(Instruction::BitCast, C, DstTy);
}
Constant *ConstantExpr::getAlignOf(const Type *Ty) {
@@ -2351,7 +2265,7 @@
}
Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
- Constant *C1, Constant *C2, bool locked) {
+ Constant *C1, Constant *C2) {
// Check the operands for consistency first
assert(Opcode >= Instruction::BinaryOpsBegin &&
Opcode < Instruction::BinaryOpsEnd &&
@@ -2360,14 +2274,14 @@
"Operand types in binary constant expression should match");
if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty)
- if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2, locked))
+ if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
return FC; // Fold a few common cases...
std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
ExprMapKeyType Key(Opcode, argVec);
- return locked ? ExprConstants->getOrCreate(ReqTy, Key) :
- ExprConstants->unlockedGetOrCreate(ReqTy, Key);
+ // Implicitly locked.
+ return ExprConstants->getOrCreate(ReqTy, Key);
}
Constant *ConstantExpr::getCompareTy(unsigned short predicate,
@@ -2392,8 +2306,7 @@
}
}
-Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
- bool locked) {
+Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
// API compatibility: Adjust integer opcodes to floating-point opcodes.
if (C1->getType()->isFPOrFPVector()) {
if (Opcode == Instruction::Add) Opcode = Instruction::FAdd;
@@ -2458,7 +2371,7 @@
}
#endif
- return getTy(C1->getType(), Opcode, C1, C2, locked);
+ return getTy(C1->getType(), Opcode, C1, C2);
}
Constant *ConstantExpr::getCompare(unsigned short pred,
@@ -2468,11 +2381,11 @@
}
Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
- Constant *V1, Constant *V2, bool locked) {
+ Constant *V1, Constant *V2) {
assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands");
if (ReqTy == V1->getType())
- if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2, locked))
+ if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2))
return SC; // Fold common cases
std::vector<Constant*> argVec(3, C);
@@ -2480,20 +2393,19 @@
argVec[2] = V2;
ExprMapKeyType Key(Instruction::Select, argVec);
- return locked ? ExprConstants->getOrCreate(ReqTy, Key) :
- ExprConstants->unlockedGetOrCreate(ReqTy, Key);
+ // Implicitly locked.
+ return ExprConstants->getOrCreate(ReqTy, Key);
}
Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
Value* const *Idxs,
- unsigned NumIdx, bool locked) {
+ unsigned NumIdx) {
assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs,
Idxs+NumIdx) ==
cast<PointerType>(ReqTy)->getElementType() &&
"GEP indices invalid!");
- if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs,
- NumIdx, locked))
+ if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx))
return FC; // Fold a few common cases...
assert(isa<PointerType>(C->getType()) &&
@@ -2507,24 +2419,22 @@
const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec);
// Implicitly locked.
- return locked ? ExprConstants->getOrCreate(ReqTy, Key) :
- ExprConstants->unlockedGetOrCreate(ReqTy, Key);
+ return ExprConstants->getOrCreate(ReqTy, Key);
}
Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
- unsigned NumIdx, bool locked) {
+ unsigned NumIdx) {
// Get the result type of the getelementptr!
const Type *Ty =
GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx);
assert(Ty && "GEP indices invalid!");
unsigned As = cast<PointerType>(C->getType())->getAddressSpace();
- return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs,
- NumIdx, locked);
+ return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx);
}
Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs,
- unsigned NumIdx, bool locked) {
- return getGetElementPtr(C, (Value* const *)Idxs, NumIdx, locked);
+ unsigned NumIdx) {
+ return getGetElementPtr(C, (Value* const *)Idxs, NumIdx);
}
@@ -2803,8 +2713,9 @@
// destroyConstant - Remove the constant from the constant table...
//
-void ConstantExpr::destroyConstant(bool locked) {
- ExprConstants->remove(this, locked);
+void ConstantExpr::destroyConstant() {
+ // Implicitly locked.
+ ExprConstants->remove(this);
destroyConstantImpl();
}
@@ -2941,7 +2852,6 @@
Constant *Replacement = 0;
if (isAllZeros) {
- // We're
Replacement = ConstantAggregateZero::get(getType());
} else {
// Check to see if we have this array type already.
Modified: llvm/trunk/lib/VMCore/Globals.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Globals.cpp?rev=73801&r1=73800&r2=73801&view=diff
==============================================================================
--- llvm/trunk/lib/VMCore/Globals.cpp (original)
+++ llvm/trunk/lib/VMCore/Globals.cpp Fri Jun 19 19:24:58 2009
@@ -75,7 +75,7 @@
/// Override destroyConstant to make sure it doesn't get called on
/// GlobalValue's because they shouldn't be treated like other constants.
-void GlobalValue::destroyConstant(bool locked) {
+void GlobalValue::destroyConstant() {
assert(0 && "You can't GV->destroyConstant()!");
abort();
}
More information about the llvm-commits
mailing list