#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;
//===----------------------------------------------------------------------===//
}
}
-
// Static constructor to create a '0' constant of arbitrary type...
Constant *Constant::getNullValue(const Type *Ty) {
switch (Ty->getTypeID()) {
- case Type::BoolTyID: {
- static Constant *NullBool = ConstantBool::get(false);
- return NullBool;
- }
- case Type::SByteTyID: {
- static Constant *NullSByte = ConstantInt::get(Type::SByteTy, 0);
- return NullSByte;
- }
- case Type::UByteTyID: {
- static Constant *NullUByte = ConstantInt::get(Type::UByteTy, 0);
- return NullUByte;
- }
- case Type::ShortTyID: {
- static Constant *NullShort = ConstantInt::get(Type::ShortTy, 0);
- return NullShort;
- }
- case Type::UShortTyID: {
- static Constant *NullUShort = ConstantInt::get(Type::UShortTy, 0);
- return NullUShort;
- }
- case Type::IntTyID: {
- static Constant *NullInt = ConstantInt::get(Type::IntTy, 0);
- return NullInt;
- }
- case Type::UIntTyID: {
- static Constant *NullUInt = ConstantInt::get(Type::UIntTy, 0);
- return NullUInt;
- }
- case Type::LongTyID: {
- static Constant *NullLong = ConstantInt::get(Type::LongTy, 0);
- return NullLong;
- }
- case Type::ULongTyID: {
- static Constant *NullULong = ConstantInt::get(Type::ULongTy, 0);
- return NullULong;
- }
-
- 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:
+ case Type::DoubleTyID:
+ return ConstantFP::get(Ty, 0.0);
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?
// Static constructor to create an integral constant with all bits set
-ConstantIntegral *ConstantIntegral::getAllOnesValue(const Type *Ty) {
- switch (Ty->getTypeID()) {
- case Type::BoolTyID: return ConstantBool::getTrue();
- case Type::SByteTyID:
- case Type::ShortTyID:
- case Type::IntTyID:
- case Type::LongTyID: return ConstantInt::get(Ty, -1);
-
- case Type::UByteTyID:
- case Type::UShortTyID:
- case Type::UIntTyID:
- case Type::ULongTyID: {
- // Calculate ~0 of the right type...
- unsigned TypeBits = Ty->getPrimitiveSize()*8;
- uint64_t Val = ~0ULL; // All ones
- Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
- return ConstantInt::get(Ty, Val);
- }
- default: return 0;
- }
+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 0;
+}
+
+/// @returns the value for an packed 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) {
+ std::vector<Constant*> Elts;
+ Elts.resize(Ty->getNumElements(),
+ ConstantInt::getAllOnesValue(Ty->getElementType()));
+ assert(Elts[0] && "Not a packed integer type!");
+ return cast<ConstantVector>(ConstantVector::get(Elts));
}
+
//===----------------------------------------------------------------------===//
-// ConstantXXX Classes
+// ConstantInt
//===----------------------------------------------------------------------===//
-//===----------------------------------------------------------------------===//
-// Normal Constructors
+ConstantInt::ConstantInt(const IntegerType *Ty, uint64_t V)
+ : Constant(Ty, ConstantIntVal, 0, 0), Val(V) {
+}
+
+ConstantInt *ConstantInt::TheTrueVal = 0;
+ConstantInt *ConstantInt::TheFalseVal = 0;
+
+namespace llvm {
+ void CleanupTrueFalse(void *) {
+ ConstantInt::ResetTrueFalse();
+ }
+}
-ConstantIntegral::ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V)
- : Constant(Ty, VT, 0, 0), Val(V) {
+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;
}
-ConstantBool::ConstantBool(bool V)
- : ConstantIntegral(Type::BoolTy, ConstantBoolVal, uint64_t(V)) {
+
+namespace {
+ struct DenseMapInt64KeyInfo {
+ typedef std::pair<uint64_t, const Type*> KeyTy;
+ static inline KeyTy getEmptyKey() { return KeyTy(0, 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(1, 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapKeyInfo<void*>::getHashValue(Key.second) ^ Key.first;
+ }
+ static bool isPod() { return true; }
+ };
}
-ConstantInt::ConstantInt(const Type *Ty, uint64_t V)
- : ConstantIntegral(Ty, ConstantIntVal, V) {
+
+typedef DenseMap<DenseMapInt64KeyInfo::KeyTy, ConstantInt*,
+ DenseMapInt64KeyInfo> IntMapTy;
+static ManagedStatic<IntMapTy> 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) {
+ const IntegerType *ITy = cast<IntegerType>(Ty);
+ V &= ITy->getBitMask();
+ ConstantInt *&Slot = (*IntConstants)[std::make_pair(uint64_t(V), Ty)];
+ if (Slot) return Slot;
+ return Slot = new ConstantInt(ITy, V);
}
+//===----------------------------------------------------------------------===//
+// ConstantFP
+//===----------------------------------------------------------------------===//
+
+
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::isNullValue() const {
+ return DoubleToBits(Val) == 0;
+}
+
+bool ConstantFP::isExactlyValue(double V) const {
+ return DoubleToBits(V) == DoubleToBits(Val);
+}
+
+
+namespace {
+ struct DenseMapInt32KeyInfo {
+ typedef std::pair<uint32_t, const Type*> KeyTy;
+ static inline KeyTy getEmptyKey() { return KeyTy(0, 0); }
+ static inline KeyTy getTombstoneKey() { return KeyTy(1, 0); }
+ static unsigned getHashValue(const KeyTy &Key) {
+ return DenseMapKeyInfo<void*>::getHashValue(Key.second) ^ Key.first;
+ }
+ static bool isPod() { return true; }
+ };
+}
+
+//---- ConstantFP::get() implementation...
+//
+typedef DenseMap<DenseMapInt32KeyInfo::KeyTy, ConstantFP*,
+ DenseMapInt32KeyInfo> FloatMapTy;
+typedef DenseMap<DenseMapInt64KeyInfo::KeyTy, ConstantFP*,
+ DenseMapInt64KeyInfo> DoubleMapTy;
+
+static ManagedStatic<FloatMapTy> FloatConstants;
+static ManagedStatic<DoubleMapTy> DoubleConstants;
+
+ConstantFP *ConstantFP::get(const Type *Ty, double V) {
+ if (Ty == Type::FloatTy) {
+ uint32_t IntVal = FloatToBits((float)V);
+
+ ConstantFP *&Slot = (*FloatConstants)[std::make_pair(IntVal, Ty)];
+ if (Slot) return Slot;
+ return Slot = new ConstantFP(Ty, (float)V);
+ } else {
+ assert(Ty == Type::DoubleTy);
+ uint64_t IntVal = DoubleToBits(V);
+ ConstantFP *&Slot = (*DoubleConstants)[std::make_pair(IntVal, Ty)];
+ 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) {
}
}
-ConstantPacked::~ConstantPacked() {
+ConstantVector::~ConstantVector() {
delete [] OperandList;
}
-static bool isSetCC(unsigned Opcode) {
- return Opcode == Instruction::SetEQ || Opcode == Instruction::SetNE ||
- Opcode == Instruction::SetLT || Opcode == Instruction::SetGT ||
- Opcode == Instruction::SetLE || Opcode == Instruction::SetGE;
-}
-
// We declare several classes private to this file, so use an anonymous
// namespace
namespace {
Use Ops[2];
public:
BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2)
- : ConstantExpr(isSetCC(Opcode) ? Type::BoolTy : C1->getType(),
- Opcode, Ops, 2) {
+ : ConstantExpr(C1->getType(), Opcode, Ops, 2) {
Ops[0].init(C1, this);
Ops[1].init(C2, this);
}
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);
Use Ops[2];
CompareConstantExpr(Instruction::OtherOps opc, unsigned short pred,
Constant* LHS, Constant* RHS)
- : ConstantExpr(Type::BoolTy, opc, Ops, 2), predicate(pred) {
+ : ConstantExpr(Type::Int1Ty, opc, Ops, 2), predicate(pred) {
OperandList[0].init(LHS, this);
OperandList[1].init(RHS, 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<ConstantIntegral>(C) && "Cannot NOT a nonintegral type!");
+ assert(isa<ConstantInt>(C) && "Cannot NOT a nonintegral type!");
return get(Instruction::Xor, C,
- ConstantIntegral::getAllOnesValue(C->getType()));
+ ConstantInt::getAllOnesValue(C->getType()));
}
Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2) {
return get(Instruction::Add, C1, C2);
Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
return get(Instruction::Xor, C1, C2);
}
-Constant *ConstantExpr::getSetEQ(Constant *C1, Constant *C2) {
- return get(Instruction::SetEQ, C1, C2);
-}
-Constant *ConstantExpr::getSetNE(Constant *C1, Constant *C2) {
- return get(Instruction::SetNE, C1, C2);
-}
-Constant *ConstantExpr::getSetLT(Constant *C1, Constant *C2) {
- return get(Instruction::SetLT, C1, C2);
-}
-Constant *ConstantExpr::getSetGT(Constant *C1, Constant *C2) {
- return get(Instruction::SetGT, C1, C2);
-}
-Constant *ConstantExpr::getSetLE(Constant *C1, Constant *C2) {
- return get(Instruction::SetLE, C1, C2);
-}
-Constant *ConstantExpr::getSetGE(Constant *C1, Constant *C2) {
- return get(Instruction::SetGE, C1, C2);
-}
unsigned ConstantExpr::getPredicate() const {
assert(getOpcode() == Instruction::FCmp || getOpcode() == Instruction::ICmp);
return dynamic_cast<const CompareConstantExpr*>(this)->predicate;
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]);
default:
assert(getNumOperands() == 2 && "Must be binary operator?");
return ConstantExpr::get(getOpcode(), Ops[0], Ops[1]);
//===----------------------------------------------------------------------===//
// isValueValidForType implementations
+bool ConstantInt::isValueValidForType(const Type *Ty, uint64_t Val) {
+ unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
+ if (Ty == Type::Int1Ty)
+ return Val == 0 || Val == 1;
+ 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) {
- switch (Ty->getTypeID()) {
- default:
- return false; // These can't be represented as integers!!!
- // Signed types...
- case Type::SByteTyID:
- return (Val <= INT8_MAX && Val >= INT8_MIN);
- case Type::UByteTyID:
- return (Val >= 0) && (Val <= UINT8_MAX);
- case Type::ShortTyID:
- return (Val <= INT16_MAX && Val >= INT16_MIN);
- case Type::UShortTyID:
- return (Val >= 0) && (Val <= UINT16_MAX);
- case Type::IntTyID:
- return (Val <= int(INT32_MAX) && Val >= int(INT32_MIN));
- case Type::UIntTyID:
- return (Val >= 0) && (Val <= UINT32_MAX);
- case Type::LongTyID:
- case Type::ULongTyID:
+ unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth(); // assert okay
+ if (Ty == Type::Int1Ty)
+ return Val == 0 || Val == 1 || Val == -1;
+ 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) {
///
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(); }
}
-//---- ConstantBool::get*() implementation.
-
-ConstantBool *ConstantBool::getTrue() {
- static ConstantBool *T = 0;
- if (T) return T;
- return T = new ConstantBool(true);
-}
-ConstantBool *ConstantBool::getFalse() {
- static ConstantBool *F = 0;
- if (F) return F;
- return F = new ConstantBool(false);
-}
-
-//---- 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) {
- return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
-}
-
-ConstantIntegral *ConstantIntegral::get(const Type *Ty, int64_t V) {
- if (Ty == Type::BoolTy) return ConstantBool::get(V&1);
- return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
-}
-
-//---- 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);
}
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::SByteTy, Str[i]));
+ ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
// Add a null terminator to the string...
if (AddNull) {
- ElementVals.push_back(ConstantInt::get(Type::SByteTy, 0));
+ ElementVals.push_back(ConstantInt::get(Type::Int8Ty, 0));
}
- ArrayType *ATy = ArrayType::get(Type::SByteTy, ElementVals.size());
+ ArrayType *ATy = ArrayType::get(Type::Int8Ty, ElementVals.size());
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...
- if (getType()->getElementType() != Type::UByteTy &&
- getType()->getElementType() != Type::SByteTy)
+ // 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
// expressions.
/// 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...
- if (getType()->getElementType() != Type::UByteTy &&
- getType()->getElementType() != Type::SByteTy)
+ // Check the element type for i8...
+ if (getType()->getElementType() != Type::Int8Ty)
return false;
Constant *Zero = Constant::getNullValue(getOperand(0)->getType());
// Last element must be a null.
}
-// 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 (!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
+/// 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 ConstantVector::isAllOnesValue() const {
+ // Check out first element.
+ const Constant *Elt = getOperand(0);
+ const ConstantInt *CI = dyn_cast<ConstantInt>(Elt);
+ if (!CI || !CI->isAllOnesValue()) return false;
+ // Then make sure all remaining elements point to the same value.
+ for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {
+ if (getOperand(I) != Elt) return false;
+ }
+ return true;
+}
+
//---- ConstantPointerNull::get() implementation...
//
//---- ConstantExpr::get() implementations...
//
+
struct ExprMapKeyType {
explicit ExprMapKeyType(unsigned opc, std::vector<Constant*> ops,
unsigned short pred = 0) : opcode(opc), predicate(pred), operands(ops) { }
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],
return new CompareConstantExpr(Instruction::FCmp, V.predicate,
V.operands[0], V.operands[1]);
assert(0 && "Invalid ConstantExpr!");
+ return 0;
}
};
case Instruction::PtrToInt:
case Instruction::IntToPtr:
case Instruction::BitCast:
- New = ConstantExpr::getCast(
- OldC->getOpcode(), OldC->getOperand(0), NewTy);
+ New = ConstantExpr::getCast(OldC->getOpcode(), OldC->getOperand(0),
+ NewTy);
break;
case Instruction::Select:
New = ConstantExpr::getSelectTy(NewTy, OldC->getOperand(0),
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;
}
assert(0 && "Invalid cast opcode");
break;
case Instruction::Trunc: return getTrunc(C, Ty);
- case Instruction::ZExt: return getZeroExtend(C, Ty);
- case Instruction::SExt: return getSignExtend(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);
return 0;
}
-Constant *ConstantExpr::getCast(Constant *C, const Type *Ty) {
- // Note: we can't inline this because it requires the Instructions.h header
- return getCast(CastInst::getCastOpcode(
- C, C->getType()->isSigned(), Ty, Ty->isSigned()), C, Ty);
-}
-
-
Constant *ConstantExpr::getZExtOrBitCast(Constant *C, const Type *Ty) {
if (C->getType()->getPrimitiveSizeInBits() == Ty->getPrimitiveSizeInBits())
return getCast(Instruction::BitCast, C, Ty);
Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty) {
assert(isa<PointerType>(S->getType()) && "Invalid cast");
- assert((Ty->isIntegral() || Ty->getTypeID() == Type::PointerTyID) &&
- "Invalid cast");
+ assert((Ty->isInteger() || isa<PointerType>(Ty)) && "Invalid cast");
- if (Ty->isIntegral())
+ if (Ty->isInteger())
return getCast(Instruction::PtrToInt, S, Ty);
return getCast(Instruction::BitCast, S, Ty);
}
+Constant *ConstantExpr::getIntegerCast(Constant *C, const Type *Ty,
+ bool isSigned) {
+ assert(C->getType()->isInteger() && Ty->isInteger() && "Invalid cast");
+ unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
+ unsigned DstBits = Ty->getPrimitiveSizeInBits();
+ Instruction::CastOps opcode =
+ (SrcBits == DstBits ? Instruction::BitCast :
+ (SrcBits > DstBits ? Instruction::Trunc :
+ (isSigned ? Instruction::SExt : Instruction::ZExt)));
+ return getCast(opcode, C, Ty);
+}
+
+Constant *ConstantExpr::getFPCast(Constant *C, const Type *Ty) {
+ assert(C->getType()->isFloatingPoint() && Ty->isFloatingPoint() &&
+ "Invalid cast");
+ unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
+ unsigned DstBits = Ty->getPrimitiveSizeInBits();
+ if (SrcBits == DstBits)
+ return C; // Avoid a useless cast
+ Instruction::CastOps opcode =
+ (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);
+ return getCast(opcode, C, Ty);
+}
+
Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
assert(C->getType()->isInteger() && "Trunc operand must be integer");
- assert(Ty->isIntegral() && "Trunc produces only integral");
+ assert(Ty->isInteger() && "Trunc produces only integral");
assert(C->getType()->getPrimitiveSizeInBits() > Ty->getPrimitiveSizeInBits()&&
"SrcTy must be larger than DestTy for Trunc!");
return getFoldedCast(Instruction::Trunc, C, Ty);
}
-Constant *ConstantExpr::getSignExtend(Constant *C, const Type *Ty) {
- assert(C->getType()->isIntegral() && "SEXt operand must be integral");
+Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
+ assert(C->getType()->isInteger() && "SEXt operand must be integral");
assert(Ty->isInteger() && "SExt produces only integer");
assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
"SrcTy must be smaller than DestTy for SExt!");
return getFoldedCast(Instruction::SExt, C, Ty);
}
-Constant *ConstantExpr::getZeroExtend(Constant *C, const Type *Ty) {
- assert(C->getType()->isIntegral() && "ZEXt operand must be integral");
+Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
+ assert(C->getType()->isInteger() && "ZEXt operand must be integral");
assert(Ty->isInteger() && "ZExt produces only integer");
assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
"SrcTy must be smaller than DestTy for ZExt!");
}
Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
- assert(C->getType()->isIntegral() && Ty->isFloatingPoint() &&
- "This is an illegal uint to floating point cast!");
+ assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
+ "This is an illegal i32 to floating point cast!");
return getFoldedCast(Instruction::UIToFP, C, Ty);
}
Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty) {
- assert(C->getType()->isIntegral() && Ty->isFloatingPoint() &&
+ assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
"This is an illegal sint to floating point cast!");
return getFoldedCast(Instruction::SIToFP, C, Ty);
}
Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
- assert(C->getType()->isFloatingPoint() && Ty->isIntegral() &&
- "This is an illegal floating point to uint cast!");
+ assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
+ "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->isIntegral() &&
- "This is an illegal floating point to sint cast!");
+ assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
+ "This is an illegal floating point to i32 cast!");
return getFoldedCast(Instruction::FPToSI, C, Ty);
}
Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy) {
assert(isa<PointerType>(C->getType()) && "PtrToInt source must be pointer");
- assert(DstTy->isIntegral() && "PtrToInt destination must be integral");
+ assert(DstTy->isInteger() && "PtrToInt destination must be integral");
return getFoldedCast(Instruction::PtrToInt, C, DstTy);
}
Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy) {
- assert(C->getType()->isIntegral() && "IntToPtr source must be integral");
+ 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);
}
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::UIntTy, 1))), Type::ULongTy);
-}
-
-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::UIntTy, 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 &&
assert(C1->getType() == C2->getType() &&
"Operand types in binary constant expression should match");
- if (ReqTy == C1->getType() || (Instruction::isComparison(Opcode) &&
- ReqTy == Type::BoolTy))
+ if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty)
if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
return FC; // Fold a few common cases...
return ExprConstants->getOrCreate(ReqTy, Key);
}
-Constant *ConstantExpr::getCompareTy(unsigned Opcode, unsigned short predicate,
+Constant *ConstantExpr::getCompareTy(unsigned short predicate,
Constant *C1, Constant *C2) {
- if (Opcode == Instruction::ICmp)
- return getICmp(predicate, C1, C2);
- return getFCmp(predicate, C1, C2);
+ switch (predicate) {
+ default: assert(0 && "Invalid CmpInst predicate");
+ case FCmpInst::FCMP_FALSE: case FCmpInst::FCMP_OEQ: case FCmpInst::FCMP_OGT:
+ case FCmpInst::FCMP_OGE: case FCmpInst::FCMP_OLT: case FCmpInst::FCMP_OLE:
+ case FCmpInst::FCMP_ONE: case FCmpInst::FCMP_ORD: case FCmpInst::FCMP_UNO:
+ case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UGT: case FCmpInst::FCMP_UGE:
+ case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_ULE: case FCmpInst::FCMP_UNE:
+ case FCmpInst::FCMP_TRUE:
+ return getFCmp(predicate, C1, C2);
+ case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_NE: case ICmpInst::ICMP_UGT:
+ case ICmpInst::ICMP_UGE: case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_ULE:
+ case ICmpInst::ICMP_SGT: case ICmpInst::ICMP_SGE: case ICmpInst::ICMP_SLT:
+ case ICmpInst::ICMP_SLE:
+ return getICmp(predicate, C1, C2);
+ }
}
Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
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()->isIntegral() || 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::SetLT: case Instruction::SetGT: case Instruction::SetLE:
- case Instruction::SetGE: case Instruction::SetEQ: case Instruction::SetNE:
- assert(C1->getType() == C2->getType() && "Op types should be identical!");
- break;
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:
- assert(C2->getType() == Type::UByteTy && "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;
return getTy(C1->getType(), Opcode, C1, C2);
}
-Constant *ConstantExpr::getCompare(unsigned Opcode, unsigned short pred,
+Constant *ConstantExpr::getCompare(unsigned short pred,
Constant *C1, Constant *C2) {
assert(C1->getType() == C2->getType() && "Op types should be identical!");
- return getCompareTy(Opcode, pred, C1, C2);
+ return getCompareTy(pred, C1, C2);
}
Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
Constant *V1, Constant *V2) {
- assert(C->getType() == Type::BoolTy && "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()->isIntegral() && C2->getType() == Type::UByteTy &&
- "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, 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, 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());
assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE &&
pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
- if (Constant *FC = ConstantFoldCompare(Instruction::ICmp, LHS, RHS, pred))
+ if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec;
ArgVec.push_back(LHS);
ArgVec.push_back(RHS);
- // Fake up an opcode value that encodes both the opcode and predicate
+ // Get the key type with both the opcode and predicate
const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred);
- return ExprConstants->getOrCreate(Type::BoolTy, Key);
+ return ExprConstants->getOrCreate(Type::Int1Ty, Key);
}
Constant *
assert(LHS->getType() == RHS->getType());
assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
- if (Constant *FC = ConstantFoldCompare(Instruction::FCmp, LHS, RHS, pred))
+ if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS))
return FC; // Fold a few common cases...
// Look up the constant in the table first to ensure uniqueness
std::vector<Constant*> ArgVec;
ArgVec.push_back(LHS);
ArgVec.push_back(RHS);
- // Fake up an opcode value that encodes both the opcode and predicate
+ // Get the key type with both the opcode and predicate
const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred);
- return ExprConstants->getOrCreate(Type::BoolTy, Key);
+ return ExprConstants->getOrCreate(Type::Int1Ty, Key);
}
Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
}
Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
- assert(isa<PackedType>(Val->getType()) &&
- "Tried to create extractelement operation on non-packed type!");
- assert(Idx->getType() == Type::UIntTy &&
- "Extractelement index must be uint type!");
- return getExtractElementTy(cast<PackedType>(Val->getType())->getElementType(),
+ assert(isa<VectorType>(Val->getType()) &&
+ "Tried to create extractelement operation on non-vector type!");
+ assert(Idx->getType() == Type::Int32Ty &&
+ "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::UIntTy &&
- "Insertelement index must be uint type!");
- return getInsertElementTy(cast<PackedType>(Val->getType())->getElementType(),
+ assert(Idx->getType() == Type::Int32Ty &&
+ "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::get(PTy->getElementType(),-0.0));
+ return ConstantVector::get(PTy, zeros);
+ }
+
+ if (Ty->isFloatingPoint())
+ return ConstantFP::get(Ty, -0.0);
+
+ return Constant::getNullValue(Ty);
+}
+
// destroyConstant - Remove the constant from the constant table...
//
void ConstantExpr::destroyConstant() {
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());