diff options
Diffstat (limited to 'lib/VMCore/Constants.cpp')
| -rw-r--r-- | lib/VMCore/Constants.cpp | 542 |
1 files changed, 226 insertions, 316 deletions
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 138a196..c164a3b 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -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 @@ bool Constant::ContainsRelocations(unsigned Kind) const { } // 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 @@ Constant *Constant::getAllOnesValue(const Type *Ty) { } // 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 @@ typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*, 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 @@ Constant *ConstantInt::get(const Type *Ty, uint64_t V, // 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 @@ typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*, 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 @@ ConstantFP *ConstantFP::get(const APFloat &V, bool locked) { "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 @@ ConstantFP *ConstantFP::get(const APFloat &V, bool locked) { /// 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 @@ Constant *ConstantExpr::getNot(Constant *C) { 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 @@ unsigned ConstantExpr::getPredicate() const { 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 @@ namespace llvm { /// 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 @@ public: /// 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 @@ public: 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 @@ public: } Map.erase(I); - - if (locked) ConstantsLock->writer_release(); } @@ -1387,7 +1334,7 @@ public: } 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 @@ public: 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 @@ namespace llvm { 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 ManagedStatic<ValueMap<char, Type, 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 @@ namespace llvm { 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 @@ typedef ValueMap<std::vector<Constant*>, ArrayType, 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 @@ void ConstantArray::destroyConstant(bool locked) { /// 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 @@ Constant *ConstantArray::get(const std::string &Str, } 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 @@ namespace llvm { 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 @@ static std::vector<Constant*> getValType(ConstantStruct *CS) { } 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 @@ namespace llvm { 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 @@ static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType, 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 @@ Constant *ConstantVector::get(const VectorType *Ty, } 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 @@ namespace llvm { 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 @@ static char getValType(ConstantPointerNull *) { } -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 @@ namespace llvm { 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 @@ static char getValType(UndefValue *) { } -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 @@ MDString::MDString(const char *begin, const char *end) 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 @@ void MDNode::Profile(FoldingSetNodeID &ID) const { 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 @@ MDNode *MDNode::get(Value*const* Vals, unsigned NumVals, bool locked) { 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 @@ namespace llvm { 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 @@ static ManagedStatic<ValueMap<ExprMapKeyType, Type, /// 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 @@ static inline Constant *getFoldedCast( 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 @@ Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty, 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 @@ Constant *ConstantExpr::getZExtOrBitCast(Constant *C, const Type *Ty) { 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 @@ Constant *ConstantExpr::getTruncOrBitCast(Constant *C, const Type *Ty) { 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 @@ Constant *ConstantExpr::getFPCast(Constant *C, const Type *Ty) { 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 @@ Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getFPTrunc(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getFPExtend(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty, bool locked) { 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 @@ Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy, // 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::getSizeOf(const Type *Ty) { } 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 @@ Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode, "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::getCompareTy(unsigned short predicate, } } -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 @@ Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, } #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::getCompare(unsigned short pred, } 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 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C, 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 @@ Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C, 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 @@ Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) { // 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 @@ void ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, Constant *Replacement = 0; if (isAllZeros) { - // We're Replacement = ConstantAggregateZero::get(getType()); } else { // Check to see if we have this array type already. |