//===----------------------------------------------------------------------===//
#include "llvm/Constants.h"
-#include "ConstantFolding.h"
+#include "ConstantFold.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalValue.h"
#include "llvm/Instructions.h"
-#include "llvm/SymbolTable.h"
#include "llvm/Module.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
#include <algorithm>
+#include <map>
using namespace llvm;
//===----------------------------------------------------------------------===//
}
}
+/// ContaintsRelocations - Return true if the constant value contains
+/// relocations which cannot be resolved at compile time.
+bool Constant::ContainsRelocations() const {
+ if (isa<GlobalValue>(this))
+ return true;
+ for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
+ if (getOperand(i)->ContainsRelocations())
+ return true;
+ return false;
+}
// Static constructor to create a '0' constant of arbitrary type...
Constant *Constant::getNullValue(const Type *Ty) {
+ static uint64_t zero[2] = {0, 0};
switch (Ty->getTypeID()) {
- case Type::IntegerTyID: {
- const IntegerType *ITy = dyn_cast<IntegerType>(Ty);
- switch (ITy->getBitWidth()) {
- case 1: {
- static Constant *NullBool = ConstantInt::get(Ty, false);
- return NullBool;
- }
- case 8: {
- static Constant *NullInt8 = ConstantInt::get(Ty, 0);
- return NullInt8;
- }
- case 16: {
- static Constant *NullInt16 = ConstantInt::get(Ty, 0);
- return NullInt16;
- }
- case 32: {
- static Constant *NullInt32 = ConstantInt::get(Ty, 0);
- return NullInt32;
- }
- case 64: {
- static Constant *NullInt64 = ConstantInt::get(Ty, 0);
- return NullInt64;
- }
- default:
- return ConstantInt::get(Ty, 0);
- }
- }
- case Type::FloatTyID: {
- static Constant *NullFloat = ConstantFP::get(Type::FloatTy, 0);
- return NullFloat;
- }
- case Type::DoubleTyID: {
- static Constant *NullDouble = ConstantFP::get(Type::DoubleTy, 0);
- return NullDouble;
- }
+ case Type::IntegerTyID:
+ return ConstantInt::get(Ty, 0);
+ case Type::FloatTyID:
+ return ConstantFP::get(Ty, APFloat(APInt(32, 0)));
+ case Type::DoubleTyID:
+ return ConstantFP::get(Ty, APFloat(APInt(64, 0)));
+ case Type::X86_FP80TyID:
+ return ConstantFP::get(Ty, APFloat(APInt(80, 2, zero)));
+ case Type::FP128TyID:
+ case Type::PPC_FP128TyID:
+ return ConstantFP::get(Ty, APFloat(APInt(128, 2, zero)));
case Type::PointerTyID:
return ConstantPointerNull::get(cast<PointerType>(Ty));
case Type::StructTyID:
case Type::ArrayTyID:
- case Type::PackedTyID:
+ case Type::VectorTyID:
return ConstantAggregateZero::get(Ty);
default:
// Function, Label, or Opaque type?
}
}
+Constant *Constant::getAllOnesValue(const Type *Ty) {
+ if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
+ return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
+ return ConstantVector::getAllOnesValue(cast<VectorType>(Ty));
+}
// Static constructor to create an integral constant with all bits set
ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
- if (ITy->getBitWidth() == 1)
- return ConstantInt::getTrue();
- else
- return ConstantInt::get(Ty, int64_t(-1));
+ return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth()));
return 0;
}
-/// @returns the value for an packed integer constant of the given type that
+/// @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
-ConstantPacked *ConstantPacked::getAllOnesValue(const PackedType *Ty) {
+ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) {
std::vector<Constant*> Elts;
Elts.resize(Ty->getNumElements(),
ConstantInt::getAllOnesValue(Ty->getElementType()));
- assert(Elts[0] && "Not a packed integer type!");
- return cast<ConstantPacked>(ConstantPacked::get(Elts));
+ assert(Elts[0] && "Not a vector integer type!");
+ return cast<ConstantVector>(ConstantVector::get(Elts));
}
//===----------------------------------------------------------------------===//
-// ConstantXXX Classes
+// ConstantInt
//===----------------------------------------------------------------------===//
+ConstantInt::ConstantInt(const IntegerType *Ty, const APInt& V)
+ : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
+ assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
+}
+
+ConstantInt *ConstantInt::TheTrueVal = 0;
+ConstantInt *ConstantInt::TheFalseVal = 0;
+
+namespace llvm {
+ void CleanupTrueFalse(void *) {
+ ConstantInt::ResetTrueFalse();
+ }
+}
+
+static ManagedCleanup<llvm::CleanupTrueFalse> TrueFalseCleanup;
+
+ConstantInt *ConstantInt::CreateTrueFalseVals(bool WhichOne) {
+ assert(TheTrueVal == 0 && TheFalseVal == 0);
+ TheTrueVal = get(Type::Int1Ty, 1);
+ TheFalseVal = get(Type::Int1Ty, 0);
+
+ // Ensure that llvm_shutdown nulls out TheTrueVal/TheFalseVal.
+ TrueFalseCleanup.Register();
+
+ return WhichOne ? TheTrueVal : TheFalseVal;
+}
+
+
+namespace {
+ struct DenseMapAPIntKeyInfo {
+ struct KeyTy {
+ APInt val;
+ const Type* type;
+ KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {}
+ KeyTy(const KeyTy& that) : val(that.val), type(that.type) {}
+ bool operator==(const KeyTy& that) const {
+ return type == that.type && this->val == that.val;
+ }
+ bool operator!=(const KeyTy& that) const {
+ return !this->operator==(that);
+ }
+ };
+ static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapInfo<void*>::getHashValue(Key.type) ^
+ Key.val.getHashValue();
+ }
+ static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
+ return LHS == RHS;
+ }
+ static bool isPod() { return false; }
+ };
+}
+
+
+typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*,
+ DenseMapAPIntKeyInfo> IntMapTy;
+static ManagedStatic<IntMapTy> IntConstants;
+
+ConstantInt *ConstantInt::get(const Type *Ty, uint64_t V, bool isSigned) {
+ const IntegerType *ITy = cast<IntegerType>(Ty);
+ return get(APInt(ITy->getBitWidth(), V, isSigned));
+}
+
+// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
+// as the key, is a DensMapAPIntKeyInfo::KeyTy which has provided the
+// 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) {
+ // 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);
+ ConstantInt *&Slot = (*IntConstants)[Key];
+ // if it exists, return it.
+ if (Slot)
+ return Slot;
+ // otherwise create a new one, insert it, and return it.
+ return Slot = new ConstantInt(ITy, V);
+}
+
+//===----------------------------------------------------------------------===//
+// ConstantFP
//===----------------------------------------------------------------------===//
-// Normal Constructors
-ConstantInt::ConstantInt(bool V)
- : Constant(Type::Int1Ty, ConstantIntVal, 0, 0), Val(uint64_t(V)) {
+ConstantFP::ConstantFP(const Type *Ty, const APFloat& V)
+ : Constant(Ty, ConstantFPVal, 0, 0), Val(V) {
+ // temporary
+ if (Ty==Type::FloatTy)
+ assert(&V.getSemantics()==&APFloat::IEEEsingle);
+ else if (Ty==Type::DoubleTy)
+ assert(&V.getSemantics()==&APFloat::IEEEdouble);
+ else if (Ty==Type::X86_FP80Ty)
+ assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
+ else if (Ty==Type::FP128Ty)
+ assert(&V.getSemantics()==&APFloat::IEEEquad);
+ else
+ assert(0);
+}
+
+bool ConstantFP::isNullValue() const {
+ return Val.isZero() && !Val.isNegative();
}
-ConstantInt::ConstantInt(const Type *Ty, uint64_t V)
- : Constant(Ty, ConstantIntVal, 0, 0), Val(Ty == Type::Int1Ty ? bool(V) : V) {
+ConstantFP *ConstantFP::getNegativeZero(const Type *Ty) {
+ APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF();
+ apf.changeSign();
+ return ConstantFP::get(Ty, apf);
}
-ConstantFP::ConstantFP(const Type *Ty, double V)
- : Constant(Ty, ConstantFPVal, 0, 0) {
- assert(isValueValidForType(Ty, V) && "Value too large for type!");
- Val = V;
+bool ConstantFP::isExactlyValue(const APFloat& V) const {
+ return Val.bitwiseIsEqual(V);
}
+namespace {
+ struct DenseMapAPFloatKeyInfo {
+ struct KeyTy {
+ APFloat val;
+ KeyTy(const APFloat& V) : val(V){}
+ KeyTy(const KeyTy& that) : val(that.val) {}
+ bool operator==(const KeyTy& that) const {
+ return this->val.bitwiseIsEqual(that.val);
+ }
+ bool operator!=(const KeyTy& that) const {
+ return !this->operator==(that);
+ }
+ };
+ static inline KeyTy getEmptyKey() {
+ return KeyTy(APFloat(APFloat::Bogus,1));
+ }
+ static inline KeyTy getTombstoneKey() {
+ return KeyTy(APFloat(APFloat::Bogus,2));
+ }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return Key.val.getHashValue();
+ }
+ static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) {
+ return LHS == RHS;
+ }
+ static bool isPod() { return false; }
+ };
+}
+
+//---- ConstantFP::get() implementation...
+//
+typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
+ DenseMapAPFloatKeyInfo> FPMapTy;
+
+static ManagedStatic<FPMapTy> FPConstants;
+
+ConstantFP *ConstantFP::get(const Type *Ty, const APFloat& V) {
+ // temporary
+ if (Ty==Type::FloatTy)
+ assert(&V.getSemantics()==&APFloat::IEEEsingle);
+ else if (Ty==Type::DoubleTy)
+ assert(&V.getSemantics()==&APFloat::IEEEdouble);
+ else if (Ty==Type::X86_FP80Ty)
+ assert(&V.getSemantics()==&APFloat::x87DoubleExtended);
+ else if (Ty==Type::FP128Ty)
+ assert(&V.getSemantics()==&APFloat::IEEEquad);
+ else
+ assert(0);
+
+ DenseMapAPFloatKeyInfo::KeyTy Key(V);
+ ConstantFP *&Slot = (*FPConstants)[Key];
+ if (Slot) return Slot;
+ return Slot = new ConstantFP(Ty, V);
+}
+
+//===----------------------------------------------------------------------===//
+// ConstantXXX Classes
+//===----------------------------------------------------------------------===//
+
+
ConstantArray::ConstantArray(const ArrayType *T,
const std::vector<Constant*> &V)
: Constant(T, ConstantArrayVal, new Use[V.size()], V.size()) {
}
-ConstantPacked::ConstantPacked(const PackedType *T,
+ConstantVector::ConstantVector(const VectorType *T,
const std::vector<Constant*> &V)
- : Constant(T, ConstantPackedVal, new Use[V.size()], V.size()) {
+ : Constant(T, ConstantVectorVal, new Use[V.size()], V.size()) {
Use *OL = OperandList;
for (std::vector<Constant*>::const_iterator I = V.begin(), E = V.end();
I != E; ++I, ++OL) {
assert((C->getType() == T->getElementType() ||
(T->isAbstract() &&
C->getType()->getTypeID() == T->getElementType()->getTypeID())) &&
- "Initializer for packed element doesn't match packed element type!");
+ "Initializer for vector element doesn't match vector element type!");
OL->init(C, this);
}
}
-ConstantPacked::~ConstantPacked() {
+ConstantVector::~ConstantVector() {
delete [] OperandList;
}
Use Ops[2];
public:
ExtractElementConstantExpr(Constant *C1, Constant *C2)
- : ConstantExpr(cast<PackedType>(C1->getType())->getElementType(),
+ : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(),
Instruction::ExtractElement, Ops, 2) {
Ops[0].init(C1, this);
Ops[1].init(C2, this);
/// specify the full Instruction::OPCODE identifier.
///
Constant *ConstantExpr::getNeg(Constant *C) {
- if (!C->getType()->isFloatingPoint())
- return get(Instruction::Sub, getNullValue(C->getType()), C);
- else
- return get(Instruction::Sub, ConstantFP::get(C->getType(), -0.0), C);
+ return get(Instruction::Sub,
+ ConstantExpr::getZeroValueForNegationExpr(C->getType()),
+ C);
}
Constant *ConstantExpr::getNot(Constant *C) {
assert(isa<ConstantInt>(C) && "Cannot NOT a nonintegral type!");
Op2 = (OpNo == 2) ? Op : getOperand(2);
return ConstantExpr::getShuffleVector(Op0, Op1, Op2);
case Instruction::GetElementPtr: {
- std::vector<Constant*> Ops;
+ SmallVector<Constant*, 8> Ops;
+ Ops.resize(getNumOperands());
for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
- Ops.push_back(getOperand(i));
+ Ops[i] = getOperand(i);
if (OpNo == 0)
- return ConstantExpr::getGetElementPtr(Op, Ops);
+ return ConstantExpr::getGetElementPtr(Op, &Ops[0], Ops.size());
Ops[OpNo-1] = Op;
- return ConstantExpr::getGetElementPtr(getOperand(0), Ops);
+ return ConstantExpr::getGetElementPtr(getOperand(0), &Ops[0], Ops.size());
}
default:
assert(getNumOperands() == 2 && "Must be binary operator?");
return ConstantExpr::getExtractElement(Ops[0], Ops[1]);
case Instruction::ShuffleVector:
return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
- case Instruction::GetElementPtr: {
- std::vector<Constant*> ActualOps(Ops.begin()+1, Ops.end());
- return ConstantExpr::getGetElementPtr(Ops[0], ActualOps);
- }
+ case Instruction::GetElementPtr:
+ return ConstantExpr::getGetElementPtr(Ops[0], &Ops[1], Ops.size()-1);
case Instruction::ICmp:
case Instruction::FCmp:
return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]);
bool ConstantInt::isValueValidForType(const Type *Ty, uint64_t Val) {
unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
- assert(NumBits <= 64 && "Not implemented: integers > 64-bits");
if (Ty == Type::Int1Ty)
return Val == 0 || Val == 1;
- if (NumBits == 64)
+ if (NumBits >= 64)
return true; // always true, has to fit in largest type
uint64_t Max = (1ll << NumBits) - 1;
return Val <= Max;
bool ConstantInt::isValueValidForType(const Type *Ty, int64_t Val) {
unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
- assert(NumBits <= 64 && "Not implemented: integers > 64-bits");
if (Ty == Type::Int1Ty)
return Val == 0 || Val == 1 || Val == -1;
- if (NumBits == 64)
+ if (NumBits >= 64)
return true; // always true, has to fit in largest type
int64_t Min = -(1ll << (NumBits-1));
int64_t Max = (1ll << (NumBits-1)) - 1;
return (Val >= Min && Val <= Max);
}
-bool ConstantFP::isValueValidForType(const Type *Ty, double Val) {
+bool ConstantFP::isValueValidForType(const Type *Ty, const APFloat& Val) {
+ // convert modifies in place, so make a copy.
+ APFloat Val2 = APFloat(Val);
switch (Ty->getTypeID()) {
default:
return false; // These can't be represented as floating point!
- // TODO: Figure out how to test if a double can be cast to a float!
+ // FIXME rounding mode needs to be more flexible
case Type::FloatTyID:
+ return &Val2.getSemantics() == &APFloat::IEEEsingle ||
+ Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven) ==
+ APFloat::opOK;
case Type::DoubleTyID:
- return true; // This is the largest type...
+ return &Val2.getSemantics() == &APFloat::IEEEsingle ||
+ &Val2.getSemantics() == &APFloat::IEEEdouble ||
+ Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven) ==
+ APFloat::opOK;
+ case Type::X86_FP80TyID:
+ return &Val2.getSemantics() == &APFloat::IEEEsingle ||
+ &Val2.getSemantics() == &APFloat::IEEEdouble ||
+ &Val2.getSemantics() == &APFloat::x87DoubleExtended;
+ case Type::FP128TyID:
+ return &Val2.getSemantics() == &APFloat::IEEEsingle ||
+ &Val2.getSemantics() == &APFloat::IEEEdouble ||
+ &Val2.getSemantics() == &APFloat::IEEEquad;
}
}
///
AbstractTypeMapTy AbstractTypeMap;
- private:
- void clear(std::vector<Constant *> &Constants) {
- for(typename MapTy::iterator I = Map.begin(); I != Map.end(); ++I)
- Constants.push_back(I->second);
- Map.clear();
- AbstractTypeMap.clear();
- InverseMap.clear();
- }
-
public:
typename MapTy::iterator map_end() { return Map.end(); }
}
-//---- ConstantInt::get() implementations...
-//
-static ManagedStatic<ValueMap<uint64_t, Type, ConstantInt> > IntConstants;
-
-// Get a ConstantInt from an int64_t. Note here that we canoncialize the value
-// to a uint64_t value that has been zero extended down to the size of the
-// integer type of the ConstantInt. This allows the getZExtValue method to
-// just return the stored value while getSExtValue has to convert back to sign
-// extended. getZExtValue is more common in LLVM than getSExtValue().
-ConstantInt *ConstantInt::get(const Type *Ty, int64_t V) {
- if (Ty == Type::Int1Ty)
- if (V & 1)
- return getTrue();
- else
- return getFalse();
- return IntConstants->getOrCreate(Ty, V & cast<IntegerType>(Ty)->getBitMask());
-}
-
-//---- ConstantFP::get() implementation...
-//
-namespace llvm {
- template<>
- struct ConstantCreator<ConstantFP, Type, uint64_t> {
- static ConstantFP *create(const Type *Ty, uint64_t V) {
- assert(Ty == Type::DoubleTy);
- return new ConstantFP(Ty, BitsToDouble(V));
- }
- };
- template<>
- struct ConstantCreator<ConstantFP, Type, uint32_t> {
- static ConstantFP *create(const Type *Ty, uint32_t V) {
- assert(Ty == Type::FloatTy);
- return new ConstantFP(Ty, BitsToFloat(V));
- }
- };
-}
-
-static ManagedStatic<ValueMap<uint64_t, Type, ConstantFP> > DoubleConstants;
-static ManagedStatic<ValueMap<uint32_t, Type, ConstantFP> > FloatConstants;
-
-bool ConstantFP::isNullValue() const {
- return DoubleToBits(Val) == 0;
-}
-
-bool ConstantFP::isExactlyValue(double V) const {
- return DoubleToBits(V) == DoubleToBits(Val);
-}
-
-
-ConstantFP *ConstantFP::get(const Type *Ty, double V) {
- if (Ty == Type::FloatTy) {
- // Force the value through memory to normalize it.
- return FloatConstants->getOrCreate(Ty, FloatToBits(V));
- } else {
- assert(Ty == Type::DoubleTy);
- return DoubleConstants->getOrCreate(Ty, DoubleToBits(V));
- }
-}
//---- ConstantAggregateZero::get() implementation...
//
static char getValType(ConstantAggregateZero *CPZ) { return 0; }
Constant *ConstantAggregateZero::get(const Type *Ty) {
- assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<PackedType>(Ty)) &&
+ assert((isa<StructType>(Ty) || isa<ArrayType>(Ty) || isa<VectorType>(Ty)) &&
"Cannot create an aggregate zero of non-aggregate type!");
return AggZeroConstants->getOrCreate(Ty, 0);
}
return ConstantArray::get(ATy, ElementVals);
}
-/// isString - This method returns true if the array is an array of sbyte or
-/// ubyte, and if the elements of the array are all ConstantInt's.
+/// isString - This method returns true if the array is an array of i8, and
+/// if the elements of the array are all ConstantInt's.
bool ConstantArray::isString() const {
- // Check the element type for sbyte or ubyte...
+ // Check the element type for i8...
if (getType()->getElementType() != Type::Int8Ty)
return false;
// Check the elements to make sure they are all integers, not constant
/// isString) and it ends in a null byte \0 and does not contains any other
/// null bytes except its terminator.
bool ConstantArray::isCString() const {
- // Check the element type for sbyte or ubyte...
+ // Check the element type for i8...
if (getType()->getElementType() != Type::Int8Ty)
return false;
Constant *Zero = Constant::getNullValue(getOperand(0)->getType());
}
-// getAsString - If the sub-element type of this array is either sbyte or ubyte,
+// getAsString - If the sub-element type of this array is i8
// then this method converts the array to an std::string and returns it.
// Otherwise, it asserts out.
//
destroyConstantImpl();
}
-//---- ConstantPacked::get() implementation...
+//---- ConstantVector::get() implementation...
//
namespace llvm {
template<>
- struct ConvertConstantType<ConstantPacked, PackedType> {
- static void convert(ConstantPacked *OldC, const PackedType *NewTy) {
+ struct ConvertConstantType<ConstantVector, VectorType> {
+ static void convert(ConstantVector *OldC, const VectorType *NewTy) {
// Make everyone now use a constant of the new type...
std::vector<Constant*> C;
for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i)
C.push_back(cast<Constant>(OldC->getOperand(i)));
- Constant *New = ConstantPacked::get(NewTy, C);
+ Constant *New = ConstantVector::get(NewTy, C);
assert(New != OldC && "Didn't replace constant??");
OldC->uncheckedReplaceAllUsesWith(New);
OldC->destroyConstant(); // This constant is now dead, destroy it.
};
}
-static std::vector<Constant*> getValType(ConstantPacked *CP) {
+static std::vector<Constant*> getValType(ConstantVector *CP) {
std::vector<Constant*> Elements;
Elements.reserve(CP->getNumOperands());
for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i)
return Elements;
}
-static ManagedStatic<ValueMap<std::vector<Constant*>, PackedType,
- ConstantPacked> > PackedConstants;
+static ManagedStatic<ValueMap<std::vector<Constant*>, VectorType,
+ ConstantVector> > VectorConstants;
-Constant *ConstantPacked::get(const PackedType *Ty,
+Constant *ConstantVector::get(const VectorType *Ty,
const std::vector<Constant*> &V) {
- // If this is an all-zero packed, return a ConstantAggregateZero object
+ // If this is an all-zero vector, return a ConstantAggregateZero object
if (!V.empty()) {
Constant *C = V[0];
if (!C->isNullValue())
- return PackedConstants->getOrCreate(Ty, V);
+ return VectorConstants->getOrCreate(Ty, V);
for (unsigned i = 1, e = V.size(); i != e; ++i)
if (V[i] != C)
- return PackedConstants->getOrCreate(Ty, V);
+ return VectorConstants->getOrCreate(Ty, V);
}
return ConstantAggregateZero::get(Ty);
}
-Constant *ConstantPacked::get(const std::vector<Constant*> &V) {
+Constant *ConstantVector::get(const std::vector<Constant*> &V) {
assert(!V.empty() && "Cannot infer type if V is empty");
- return get(PackedType::get(V.front()->getType(),V.size()), V);
+ return get(VectorType::get(V.front()->getType(),V.size()), V);
}
// destroyConstant - Remove the constant from the constant table...
//
-void ConstantPacked::destroyConstant() {
- PackedConstants->remove(this);
+void ConstantVector::destroyConstant() {
+ VectorConstants->remove(this);
destroyConstantImpl();
}
-/// This function will return true iff every element in this packed constant
+/// This function will return true iff every element in this vector constant
/// is set to all ones.
/// @returns true iff this constant's emements are all set to all ones.
/// @brief Determine if the value is all ones.
-bool ConstantPacked::isAllOnesValue() const {
+bool ConstantVector::isAllOnesValue() const {
// Check out first element.
const Constant *Elt = getOperand(0);
const ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
if (Instruction::isCast(V.opcode))
return new UnaryConstantExpr(V.opcode, V.operands[0], Ty);
if ((V.opcode >= Instruction::BinaryOpsBegin &&
- V.opcode < Instruction::BinaryOpsEnd) ||
- V.opcode == Instruction::Shl ||
- V.opcode == Instruction::LShr ||
- V.opcode == Instruction::AShr)
+ V.opcode < Instruction::BinaryOpsEnd))
return new BinaryConstantExpr(V.opcode, V.operands[0], V.operands[1]);
if (V.opcode == Instruction::Select)
return new SelectConstantExpr(V.operands[0], V.operands[1],
OldC->getOperand(1),
OldC->getOperand(2));
break;
- case Instruction::Shl:
- case Instruction::LShr:
- case Instruction::AShr:
- New = ConstantExpr::getShiftTy(NewTy, OldC->getOpcode(),
- OldC->getOperand(0), OldC->getOperand(1));
- break;
default:
assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin &&
OldC->getOpcode() < Instruction::BinaryOpsEnd);
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);
+ New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0),
+ &Idx[0], Idx.size());
break;
}
Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
- "This is an illegal uint to floating point cast!");
+ "This is an illegal i32 to floating point cast!");
return getFoldedCast(Instruction::UIToFP, C, Ty);
}
Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
- "This is an illegal floating point to uint cast!");
+ "This is an illegal floating point to i32 cast!");
return getFoldedCast(Instruction::FPToUI, C, Ty);
}
Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
- "This is an illegal floating point to sint cast!");
+ "This is an illegal floating point to i32 cast!");
return getFoldedCast(Instruction::FPToSI, C, Ty);
}
Constant *ConstantExpr::getSizeOf(const Type *Ty) {
// sizeof is implemented as: (ulong) gep (Ty*)null, 1
- return getCast(Instruction::PtrToInt, getGetElementPtr(getNullValue(
- PointerType::get(Ty)), std::vector<Constant*>(1,
- ConstantInt::get(Type::Int32Ty, 1))), Type::Int64Ty);
-}
-
-Constant *ConstantExpr::getPtrPtrFromArrayPtr(Constant *C) {
- // pointer from array is implemented as: getelementptr arr ptr, 0, 0
- static std::vector<Constant*> Indices(2, ConstantInt::get(Type::Int32Ty, 0));
-
- return ConstantExpr::getGetElementPtr(C, Indices);
+ Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
+ Constant *GEP =
+ getGetElementPtr(getNullValue(PointerType::get(Ty)), &GEPIdx, 1);
+ return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
}
Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
Constant *C1, Constant *C2) {
- if (Opcode == Instruction::Shl || Opcode == Instruction::LShr ||
- Opcode == Instruction::AShr)
- return getShiftTy(ReqTy, Opcode, C1, C2);
-
// Check the operands for consistency first
assert(Opcode >= Instruction::BinaryOpsBegin &&
Opcode < Instruction::BinaryOpsEnd &&
case Instruction::Mul:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
assert((C1->getType()->isInteger() || C1->getType()->isFloatingPoint() ||
- isa<PackedType>(C1->getType())) &&
+ isa<VectorType>(C1->getType())) &&
"Tried to create an arithmetic operation on a non-arithmetic type!");
break;
case Instruction::UDiv:
case Instruction::SDiv:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- assert((C1->getType()->isInteger() || (isa<PackedType>(C1->getType()) &&
- cast<PackedType>(C1->getType())->getElementType()->isInteger())) &&
+ assert((C1->getType()->isInteger() || (isa<VectorType>(C1->getType()) &&
+ cast<VectorType>(C1->getType())->getElementType()->isInteger())) &&
"Tried to create an arithmetic operation on a non-arithmetic type!");
break;
case Instruction::FDiv:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- assert((C1->getType()->isFloatingPoint() || (isa<PackedType>(C1->getType())
- && cast<PackedType>(C1->getType())->getElementType()->isFloatingPoint()))
+ assert((C1->getType()->isFloatingPoint() || (isa<VectorType>(C1->getType())
+ && cast<VectorType>(C1->getType())->getElementType()->isFloatingPoint()))
&& "Tried to create an arithmetic operation on a non-arithmetic type!");
break;
case Instruction::URem:
case Instruction::SRem:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- assert((C1->getType()->isInteger() || (isa<PackedType>(C1->getType()) &&
- cast<PackedType>(C1->getType())->getElementType()->isInteger())) &&
+ assert((C1->getType()->isInteger() || (isa<VectorType>(C1->getType()) &&
+ cast<VectorType>(C1->getType())->getElementType()->isInteger())) &&
"Tried to create an arithmetic operation on a non-arithmetic type!");
break;
case Instruction::FRem:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- assert((C1->getType()->isFloatingPoint() || (isa<PackedType>(C1->getType())
- && cast<PackedType>(C1->getType())->getElementType()->isFloatingPoint()))
+ assert((C1->getType()->isFloatingPoint() || (isa<VectorType>(C1->getType())
+ && cast<VectorType>(C1->getType())->getElementType()->isFloatingPoint()))
&& "Tried to create an arithmetic operation on a non-arithmetic type!");
break;
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- assert((C1->getType()->isInteger() || isa<PackedType>(C1->getType())) &&
+ assert((C1->getType()->isInteger() || isa<VectorType>(C1->getType())) &&
"Tried to create a logical operation on a non-integral type!");
break;
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:
- assert(C2->getType() == Type::Int8Ty && "Shift should be by ubyte!");
+ assert(C1->getType() == C2->getType() && "Op types should be identical!");
assert(C1->getType()->isInteger() &&
"Tried to create a shift operation on a non-integer type!");
break;
Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
Constant *V1, Constant *V2) {
- assert(C->getType() == Type::Int1Ty && "Select condition must be bool!");
+ assert(C->getType() == Type::Int1Ty && "Select condition must be i1!");
assert(V1->getType() == V2->getType() && "Select value types must match!");
assert(V1->getType()->isFirstClassType() && "Cannot select aggregate type!");
return ExprConstants->getOrCreate(ReqTy, Key);
}
-/// getShiftTy - Return a shift left or shift right constant expr
-Constant *ConstantExpr::getShiftTy(const Type *ReqTy, unsigned Opcode,
- Constant *C1, Constant *C2) {
- // Check the operands for consistency first
- assert((Opcode == Instruction::Shl ||
- Opcode == Instruction::LShr ||
- Opcode == Instruction::AShr) &&
- "Invalid opcode in binary constant expression");
- assert(C1->getType()->isInteger() && C2->getType() == Type::Int8Ty &&
- "Invalid operand types for Shift constant expr!");
-
- if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
- return FC; // Fold a few common cases...
-
- // Look up the constant in the table first to ensure uniqueness
- std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
- ExprMapKeyType Key(Opcode, argVec);
- return ExprConstants->getOrCreate(ReqTy, Key);
-}
-
Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
- const std::vector<Value*> &IdxList) {
- assert(GetElementPtrInst::getIndexedType(C->getType(), IdxList, true) &&
+ Value* const *Idxs,
+ unsigned NumIdx) {
+ assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true) &&
"GEP indices invalid!");
- if (Constant *FC = ConstantFoldGetElementPtr(C, IdxList))
+ if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx))
return FC; // Fold a few common cases...
assert(isa<PointerType>(C->getType()) &&
"Non-pointer type for constant GetElementPtr expression");
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec;
- ArgVec.reserve(IdxList.size()+1);
+ ArgVec.reserve(NumIdx+1);
ArgVec.push_back(C);
- for (unsigned i = 0, e = IdxList.size(); i != e; ++i)
- ArgVec.push_back(cast<Constant>(IdxList[i]));
- const ExprMapKeyType Key(Instruction::GetElementPtr,ArgVec);
+ for (unsigned i = 0; i != NumIdx; ++i)
+ ArgVec.push_back(cast<Constant>(Idxs[i]));
+ const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec);
return ExprConstants->getOrCreate(ReqTy, Key);
}
-Constant *ConstantExpr::getGetElementPtr(Constant *C,
- const std::vector<Constant*> &IdxList){
+Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
+ unsigned NumIdx) {
// Get the result type of the getelementptr!
- std::vector<Value*> VIdxList(IdxList.begin(), IdxList.end());
-
- const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), VIdxList,
- true);
+ const Type *Ty =
+ GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true);
assert(Ty && "GEP indices invalid!");
- return getGetElementPtrTy(PointerType::get(Ty), C, VIdxList);
+ return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx);
}
-Constant *ConstantExpr::getGetElementPtr(Constant *C,
- const std::vector<Value*> &IdxList) {
- // Get the result type of the getelementptr!
- const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), IdxList,
- true);
- assert(Ty && "GEP indices invalid!");
- return getGetElementPtrTy(PointerType::get(Ty), C, IdxList);
+Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs,
+ unsigned NumIdx) {
+ return getGetElementPtr(C, (Value* const *)Idxs, NumIdx);
}
+
Constant *
ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) {
assert(LHS->getType() == RHS->getType());
}
Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
- assert(isa<PackedType>(Val->getType()) &&
- "Tried to create extractelement operation on non-packed type!");
+ assert(isa<VectorType>(Val->getType()) &&
+ "Tried to create extractelement operation on non-vector type!");
assert(Idx->getType() == Type::Int32Ty &&
- "Extractelement index must be uint type!");
- return getExtractElementTy(cast<PackedType>(Val->getType())->getElementType(),
+ "Extractelement index must be i32 type!");
+ return getExtractElementTy(cast<VectorType>(Val->getType())->getElementType(),
Val, Idx);
}
Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
Constant *Idx) {
- assert(isa<PackedType>(Val->getType()) &&
- "Tried to create insertelement operation on non-packed type!");
- assert(Elt->getType() == cast<PackedType>(Val->getType())->getElementType()
+ assert(isa<VectorType>(Val->getType()) &&
+ "Tried to create insertelement operation on non-vector type!");
+ assert(Elt->getType() == cast<VectorType>(Val->getType())->getElementType()
&& "Insertelement types must match!");
assert(Idx->getType() == Type::Int32Ty &&
- "Insertelement index must be uint type!");
- return getInsertElementTy(cast<PackedType>(Val->getType())->getElementType(),
+ "Insertelement index must be i32 type!");
+ return getInsertElementTy(cast<VectorType>(Val->getType())->getElementType(),
Val, Elt, Idx);
}
return getShuffleVectorTy(V1->getType(), V1, V2, Mask);
}
+Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) {
+ if (const VectorType *PTy = dyn_cast<VectorType>(Ty))
+ if (PTy->getElementType()->isFloatingPoint()) {
+ std::vector<Constant*> zeros(PTy->getNumElements(),
+ ConstantFP::getNegativeZero(PTy->getElementType()));
+ return ConstantVector::get(PTy, zeros);
+ }
+
+ if (Ty->isFloatingPoint())
+ return ConstantFP::getNegativeZero(Ty);
+
+ return Constant::getNullValue(Ty);
+}
+
// destroyConstant - Remove the constant from the constant table...
//
void ConstantExpr::destroyConstant() {
//===----------------------------------------------------------------------===//
// replaceUsesOfWithOnConstant implementations
+/// replaceUsesOfWithOnConstant - Update this constant array to change uses of
+/// 'From' to be uses of 'To'. This must update the uniquing data structures
+/// etc.
+///
+/// Note that we intentionally replace all uses of From with To here. Consider
+/// a large array that uses 'From' 1000 times. By handling this case all here,
+/// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that
+/// single invocation handles all 1000 uses. Handling them one at a time would
+/// work, but would be really slow because it would have to unique each updated
+/// array instance.
void ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To,
Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Constant *ToC = cast<Constant>(To);
- unsigned OperandToUpdate = U-OperandList;
- assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!");
-
std::pair<ArrayConstantsTy::MapKey, Constant*> Lookup;
Lookup.first.first = getType();
Lookup.second = this;
// Fill values with the modified operands of the constant array. Also,
// compute whether this turns into an all-zeros array.
bool isAllZeros = false;
+ unsigned NumUpdated = 0;
if (!ToC->isNullValue()) {
- for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O)
- Values.push_back(cast<Constant>(O->get()));
+ for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
+ Constant *Val = cast<Constant>(O->get());
+ if (Val == From) {
+ Val = ToC;
+ ++NumUpdated;
+ }
+ Values.push_back(Val);
+ }
} else {
isAllZeros = true;
for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) {
Constant *Val = cast<Constant>(O->get());
+ if (Val == From) {
+ Val = ToC;
+ ++NumUpdated;
+ }
Values.push_back(Val);
if (isAllZeros) isAllZeros = Val->isNullValue();
}
}
- Values[OperandToUpdate] = ToC;
Constant *Replacement = 0;
if (isAllZeros) {
// in place!
ArrayConstants->MoveConstantToNewSlot(this, I);
- // Update to the new value.
- setOperand(OperandToUpdate, ToC);
+ // Update to the new value. Optimize for the case when we have a single
+ // operand that we're changing, but handle bulk updates efficiently.
+ if (NumUpdated == 1) {
+ unsigned OperandToUpdate = U-OperandList;
+ assert(getOperand(OperandToUpdate) == From &&
+ "ReplaceAllUsesWith broken!");
+ setOperand(OperandToUpdate, ToC);
+ } else {
+ for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
+ if (getOperand(i) == From)
+ setOperand(i, ToC);
+ }
return;
}
}
destroyConstant();
}
-void ConstantPacked::replaceUsesOfWithOnConstant(Value *From, Value *To,
+void ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To,
Use *U) {
assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
Values.push_back(Val);
}
- Constant *Replacement = ConstantPacked::get(getType(), Values);
+ Constant *Replacement = ConstantVector::get(getType(), Values);
assert(Replacement != this && "I didn't contain From!");
// Everyone using this now uses the replacement.
Constant *Replacement = 0;
if (getOpcode() == Instruction::GetElementPtr) {
- std::vector<Constant*> Indices;
+ SmallVector<Constant*, 8> Indices;
Constant *Pointer = getOperand(0);
Indices.reserve(getNumOperands()-1);
if (Pointer == From) Pointer = To;
if (Val == From) Val = To;
Indices.push_back(Val);
}
- Replacement = ConstantExpr::getGetElementPtr(Pointer, Indices);
+ Replacement = ConstantExpr::getGetElementPtr(Pointer,
+ &Indices[0], Indices.size());
} else if (isCast()) {
assert(getOperand(0) == From && "Cast only has one use!");
Replacement = ConstantExpr::getCast(getOpcode(), To, getType());
projects / oota-llvm.git / blobdiff