X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstantFold.cpp;h=ad9a33f845eda22fbfa5f2bcc7c878a13c19be69;hb=b83eb6447ba155342598f0fabe1f08f5baa9164a;hp=e5ca2b37bcaec52ab9b18728567b321ecee54bef;hpb=f190d3805519beb3ec9afe4adfda30e82dcd2995;p=oota-llvm.git diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index e5ca2b37bca..ad9a33f845e 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -23,9 +23,10 @@ #include "llvm/Instructions.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "llvm/Support/Compiler.h" #include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MathExtras.h" -#include "llvm/Support/Visibility.h" #include #include using namespace llvm; @@ -225,7 +226,7 @@ namespace { struct VISIBILITY_HIDDEN EmptyRules : public TemplateRules { static Constant *EqualTo(const Constant *V1, const Constant *V2) { - if (V1 == V2) return ConstantBool::True; + if (V1 == V2) return ConstantBool::getTrue(); return 0; } }; @@ -270,14 +271,14 @@ struct VISIBILITY_HIDDEN BoolRules } DEF_CAST(Bool , ConstantBool, bool) - DEF_CAST(SByte , ConstantSInt, signed char) - DEF_CAST(UByte , ConstantUInt, unsigned char) - DEF_CAST(Short , ConstantSInt, signed short) - DEF_CAST(UShort, ConstantUInt, unsigned short) - DEF_CAST(Int , ConstantSInt, signed int) - DEF_CAST(UInt , ConstantUInt, unsigned int) - DEF_CAST(Long , ConstantSInt, int64_t) - DEF_CAST(ULong , ConstantUInt, uint64_t) + DEF_CAST(SByte , ConstantInt, signed char) + DEF_CAST(UByte , ConstantInt, unsigned char) + DEF_CAST(Short , ConstantInt, signed short) + DEF_CAST(UShort, ConstantInt, unsigned short) + DEF_CAST(Int , ConstantInt, signed int) + DEF_CAST(UInt , ConstantInt, unsigned int) + DEF_CAST(Long , ConstantInt, int64_t) + DEF_CAST(ULong , ConstantInt, uint64_t) DEF_CAST(Float , ConstantFP , float) DEF_CAST(Double, ConstantFP , double) #undef DEF_CAST @@ -296,34 +297,34 @@ namespace { struct VISIBILITY_HIDDEN NullPointerRules : public TemplateRules { static Constant *EqualTo(const Constant *V1, const Constant *V2) { - return ConstantBool::True; // Null pointers are always equal + return ConstantBool::getTrue(); // Null pointers are always equal } static Constant *CastToBool(const Constant *V) { - return ConstantBool::False; + return ConstantBool::getFalse(); } static Constant *CastToSByte (const Constant *V) { - return ConstantSInt::get(Type::SByteTy, 0); + return ConstantInt::get(Type::SByteTy, 0); } static Constant *CastToUByte (const Constant *V) { - return ConstantUInt::get(Type::UByteTy, 0); + return ConstantInt::get(Type::UByteTy, 0); } static Constant *CastToShort (const Constant *V) { - return ConstantSInt::get(Type::ShortTy, 0); + return ConstantInt::get(Type::ShortTy, 0); } static Constant *CastToUShort(const Constant *V) { - return ConstantUInt::get(Type::UShortTy, 0); + return ConstantInt::get(Type::UShortTy, 0); } static Constant *CastToInt (const Constant *V) { - return ConstantSInt::get(Type::IntTy, 0); + return ConstantInt::get(Type::IntTy, 0); } static Constant *CastToUInt (const Constant *V) { - return ConstantUInt::get(Type::UIntTy, 0); + return ConstantInt::get(Type::UIntTy, 0); } static Constant *CastToLong (const Constant *V) { - return ConstantSInt::get(Type::LongTy, 0); + return ConstantInt::get(Type::LongTy, 0); } static Constant *CastToULong (const Constant *V) { - return ConstantUInt::get(Type::ULongTy, 0); + return ConstantInt::get(Type::ULongTy, 0); } static Constant *CastToFloat (const Constant *V) { return ConstantFP::get(Type::FloatTy, 0); @@ -427,49 +428,46 @@ struct VISIBILITY_HIDDEN GeneralPackedRules //===----------------------------------------------------------------------===// -// DirectRules Class +// DirectIntRules Class //===----------------------------------------------------------------------===// // -// DirectRules provides a concrete base classes of ConstRules for a variety of -// different types. This allows the C++ compiler to automatically generate our -// constant handling operations in a typesafe and accurate manner. +// DirectIntRules provides implementations of functions that are valid on +// integer types, but not all types in general. // namespace { -template -struct VISIBILITY_HIDDEN DirectRules - : public TemplateRules { - static Constant *Add(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() + (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); - } +template +struct VISIBILITY_HIDDEN DirectIntRules + : public TemplateRules > { - static Constant *Sub(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() - (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Add(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = (BuiltinType)V1->getZExtValue() + + (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Mul(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() * (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Sub(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = (BuiltinType)V1->getZExtValue() - + (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) { - if (V2->isNullValue()) return 0; - BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Mul(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = (BuiltinType)V1->getZExtValue() * + (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *LessThan(const ConstantClass *V1, const ConstantClass *V2) { - bool R = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue(); + static Constant *LessThan(const ConstantInt *V1, const ConstantInt *V2) { + bool R = (BuiltinType)V1->getZExtValue() < (BuiltinType)V2->getZExtValue(); return ConstantBool::get(R); } - static Constant *EqualTo(const ConstantClass *V1, const ConstantClass *V2) { - bool R = (BuiltinType)V1->getValue() == (BuiltinType)V2->getValue(); + static Constant *EqualTo(const ConstantInt *V1, const ConstantInt *V2) { + bool R = (BuiltinType)V1->getZExtValue() == (BuiltinType)V2->getZExtValue(); return ConstantBool::get(R); } - static Constant *CastToPointer(const ConstantClass *V, + static Constant *CastToPointer(const ConstantInt *V, const PointerType *PTy) { if (V->isNullValue()) // Is it a FP or Integral null value? return ConstantPointerNull::get(PTy); @@ -478,79 +476,70 @@ struct VISIBILITY_HIDDEN DirectRules // Casting operators. ick #define DEF_CAST(TYPE, CLASS, CTYPE) \ - static Constant *CastTo##TYPE (const ConstantClass *V) { \ - return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getValue()); \ + static Constant *CastTo##TYPE (const ConstantInt *V) { \ + return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getZExtValue()); \ } DEF_CAST(Bool , ConstantBool, bool) - DEF_CAST(SByte , ConstantSInt, signed char) - DEF_CAST(UByte , ConstantUInt, unsigned char) - DEF_CAST(Short , ConstantSInt, signed short) - DEF_CAST(UShort, ConstantUInt, unsigned short) - DEF_CAST(Int , ConstantSInt, signed int) - DEF_CAST(UInt , ConstantUInt, unsigned int) - DEF_CAST(Long , ConstantSInt, int64_t) - DEF_CAST(ULong , ConstantUInt, uint64_t) - DEF_CAST(Float , ConstantFP , float) - DEF_CAST(Double, ConstantFP , double) + DEF_CAST(SByte , ConstantInt, signed char) + DEF_CAST(UByte , ConstantInt, unsigned char) + DEF_CAST(Short , ConstantInt, signed short) + DEF_CAST(UShort, ConstantInt, unsigned short) + DEF_CAST(Int , ConstantInt, signed int) + DEF_CAST(UInt , ConstantInt, unsigned int) + DEF_CAST(Long , ConstantInt, int64_t) + DEF_CAST(ULong , ConstantInt, uint64_t) + DEF_CAST(Float , ConstantFP , float) + DEF_CAST(Double, ConstantFP , double) #undef DEF_CAST -}; -} // end anonymous namespace - -//===----------------------------------------------------------------------===// -// DirectIntRules Class -//===----------------------------------------------------------------------===// -// -// DirectIntRules provides implementations of functions that are valid on -// integer types, but not all types in general. -// -namespace { -template -struct VISIBILITY_HIDDEN DirectIntRules - : public DirectRules > { - - static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) { + static Constant *Div(const ConstantInt *V1, const ConstantInt *V2) { if (V2->isNullValue()) return 0; if (V2->isAllOnesValue() && // MIN_INT / -1 - (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue()) + (BuiltinType)V1->getZExtValue() == -(BuiltinType)V1->getZExtValue()) return 0; - BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + BuiltinType R = + (BuiltinType)V1->getZExtValue() / (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Rem(const ConstantClass *V1, - const ConstantClass *V2) { + static Constant *Rem(const ConstantInt *V1, + const ConstantInt *V2) { if (V2->isNullValue()) return 0; // X / 0 if (V2->isAllOnesValue() && // MIN_INT / -1 - (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue()) + (BuiltinType)V1->getZExtValue() == -(BuiltinType)V1->getZExtValue()) return 0; - BuiltinType R = (BuiltinType)V1->getValue() % (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + BuiltinType R = + (BuiltinType)V1->getZExtValue() % (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *And(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() & (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *And(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = + (BuiltinType)V1->getZExtValue() & (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Or(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() | (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Or(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = + (BuiltinType)V1->getZExtValue() | (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Xor(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() ^ (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Xor(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = + (BuiltinType)V1->getZExtValue() ^ (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Shl(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() << (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Shl(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = + (BuiltinType)V1->getZExtValue() << (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } - static Constant *Shr(const ConstantClass *V1, const ConstantClass *V2) { - BuiltinType R = (BuiltinType)V1->getValue() >> (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + static Constant *Shr(const ConstantInt *V1, const ConstantInt *V2) { + BuiltinType R = + (BuiltinType)V1->getZExtValue() >> (BuiltinType)V2->getZExtValue(); + return ConstantInt::get(*Ty, R); } }; } // end anonymous namespace @@ -564,69 +553,120 @@ struct VISIBILITY_HIDDEN DirectIntRules /// floating point types, but not all types in general. /// namespace { -template +template struct VISIBILITY_HIDDEN DirectFPRules - : public DirectRules > { - static Constant *Rem(const ConstantClass *V1, const ConstantClass *V2) { + : public TemplateRules > { + + static Constant *Add(const ConstantFP *V1, const ConstantFP *V2) { + BuiltinType R = (BuiltinType)V1->getValue() + + (BuiltinType)V2->getValue(); + return ConstantFP::get(*Ty, R); + } + + static Constant *Sub(const ConstantFP *V1, const ConstantFP *V2) { + BuiltinType R = (BuiltinType)V1->getValue() - (BuiltinType)V2->getValue(); + return ConstantFP::get(*Ty, R); + } + + static Constant *Mul(const ConstantFP *V1, const ConstantFP *V2) { + BuiltinType R = (BuiltinType)V1->getValue() * (BuiltinType)V2->getValue(); + return ConstantFP::get(*Ty, R); + } + + static Constant *LessThan(const ConstantFP *V1, const ConstantFP *V2) { + bool R = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue(); + return ConstantBool::get(R); + } + + static Constant *EqualTo(const ConstantFP *V1, const ConstantFP *V2) { + bool R = (BuiltinType)V1->getValue() == (BuiltinType)V2->getValue(); + return ConstantBool::get(R); + } + + static Constant *CastToPointer(const ConstantFP *V, + const PointerType *PTy) { + if (V->isNullValue()) // Is it a FP or Integral null value? + return ConstantPointerNull::get(PTy); + return 0; // Can't const prop other types of pointers + } + + // Casting operators. ick +#define DEF_CAST(TYPE, CLASS, CTYPE) \ + static Constant *CastTo##TYPE (const ConstantFP *V) { \ + return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getValue()); \ + } + + DEF_CAST(Bool , ConstantBool, bool) + DEF_CAST(SByte , ConstantInt, signed char) + DEF_CAST(UByte , ConstantInt, unsigned char) + DEF_CAST(Short , ConstantInt, signed short) + DEF_CAST(UShort, ConstantInt, unsigned short) + DEF_CAST(Int , ConstantInt, signed int) + DEF_CAST(UInt , ConstantInt, unsigned int) + DEF_CAST(Long , ConstantInt, int64_t) + DEF_CAST(ULong , ConstantInt, uint64_t) + DEF_CAST(Float , ConstantFP , float) + DEF_CAST(Double, ConstantFP , double) +#undef DEF_CAST + + static Constant *Rem(const ConstantFP *V1, const ConstantFP *V2) { if (V2->isNullValue()) return 0; BuiltinType Result = std::fmod((BuiltinType)V1->getValue(), (BuiltinType)V2->getValue()); - return ConstantClass::get(*Ty, Result); + return ConstantFP::get(*Ty, Result); } - static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) { + static Constant *Div(const ConstantFP *V1, const ConstantFP *V2) { BuiltinType inf = std::numeric_limits::infinity(); - if (V2->isExactlyValue(0.0)) return ConstantClass::get(*Ty, inf); - if (V2->isExactlyValue(-0.0)) return ConstantClass::get(*Ty, -inf); + if (V2->isExactlyValue(0.0)) return ConstantFP::get(*Ty, inf); + if (V2->isExactlyValue(-0.0)) return ConstantFP::get(*Ty, -inf); BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue(); - return ConstantClass::get(*Ty, R); + return ConstantFP::get(*Ty, R); } }; } // end anonymous namespace +static ManagedStatic EmptyR; +static ManagedStatic BoolR; +static ManagedStatic NullPointerR; +static ManagedStatic ConstantPackedR; +static ManagedStatic GeneralPackedR; +static ManagedStatic > SByteR; +static ManagedStatic > UByteR; +static ManagedStatic > ShortR; +static ManagedStatic > UShortR; +static ManagedStatic > IntR; +static ManagedStatic > UIntR; +static ManagedStatic > LongR; +static ManagedStatic > ULongR; +static ManagedStatic > FloatR; +static ManagedStatic > DoubleR; /// ConstRules::get - This method returns the constant rules implementation that /// implements the semantics of the two specified constants. ConstRules &ConstRules::get(const Constant *V1, const Constant *V2) { - static EmptyRules EmptyR; - static BoolRules BoolR; - static NullPointerRules NullPointerR; - static ConstantPackedRules ConstantPackedR; - static GeneralPackedRules GeneralPackedR; - static DirectIntRules SByteR; - static DirectIntRules UByteR; - static DirectIntRules ShortR; - static DirectIntRules UShortR; - static DirectIntRules IntR; - static DirectIntRules UIntR; - static DirectIntRules LongR; - static DirectIntRules ULongR; - static DirectFPRules FloatR; - static DirectFPRules DoubleR; - if (isa(V1) || isa(V2) || isa(V1) || isa(V2) || isa(V1) || isa(V2)) - return EmptyR; + return *EmptyR; switch (V1->getType()->getTypeID()) { default: assert(0 && "Unknown value type for constant folding!"); - case Type::BoolTyID: return BoolR; - case Type::PointerTyID: return NullPointerR; - case Type::SByteTyID: return SByteR; - case Type::UByteTyID: return UByteR; - case Type::ShortTyID: return ShortR; - case Type::UShortTyID: return UShortR; - case Type::IntTyID: return IntR; - case Type::UIntTyID: return UIntR; - case Type::LongTyID: return LongR; - case Type::ULongTyID: return ULongR; - case Type::FloatTyID: return FloatR; - case Type::DoubleTyID: return DoubleR; + case Type::BoolTyID: return *BoolR; + case Type::PointerTyID: return *NullPointerR; + case Type::SByteTyID: return *SByteR; + case Type::UByteTyID: return *UByteR; + case Type::ShortTyID: return *ShortR; + case Type::UShortTyID: return *UShortR; + case Type::IntTyID: return *IntR; + case Type::UIntTyID: return *UIntR; + case Type::LongTyID: return *LongR; + case Type::ULongTyID: return *ULongR; + case Type::FloatTyID: return *FloatR; + case Type::DoubleTyID: return *DoubleR; case Type::PackedTyID: if (isa(V1) && isa(V2)) - return ConstantPackedR; - return GeneralPackedR; // Constant folding rules for ConstantAggregateZero. + return *ConstantPackedR; + return *GeneralPackedR; // Constant folding rules for ConstantAggregateZero. } } @@ -674,7 +714,7 @@ static Constant *CastConstantPacked(ConstantPacked *CP, if (DstEltTy->getTypeID() == Type::DoubleTyID) { for (unsigned i = 0; i != SrcNumElts; ++i) { double V = - BitsToDouble(cast(CP->getOperand(i))->getRawValue()); + BitsToDouble(cast(CP->getOperand(i))->getZExtValue()); Result.push_back(ConstantFP::get(Type::DoubleTy, V)); } return ConstantPacked::get(Result); @@ -682,7 +722,7 @@ static Constant *CastConstantPacked(ConstantPacked *CP, assert(DstEltTy == Type::FloatTy && "Unknown fp type!"); for (unsigned i = 0; i != SrcNumElts; ++i) { float V = - BitsToFloat(cast(CP->getOperand(i))->getRawValue()); + BitsToFloat(cast(CP->getOperand(i))->getZExtValue()); Result.push_back(ConstantFP::get(Type::FloatTy, V)); } return ConstantPacked::get(Result); @@ -695,7 +735,7 @@ static Constant *CastConstantPacked(ConstantPacked *CP, for (unsigned i = 0; i != SrcNumElts; ++i) { uint64_t V = DoubleToBits(cast(CP->getOperand(i))->getValue()); - Constant *C = ConstantUInt::get(Type::ULongTy, V); + Constant *C = ConstantInt::get(Type::ULongTy, V); Result.push_back(ConstantExpr::getCast(C, DstEltTy)); } return ConstantPacked::get(Result); @@ -703,8 +743,8 @@ static Constant *CastConstantPacked(ConstantPacked *CP, assert(SrcEltTy->getTypeID() == Type::FloatTyID); for (unsigned i = 0; i != SrcNumElts; ++i) { - unsigned V = FloatToBits(cast(CP->getOperand(i))->getValue()); - Constant *C = ConstantUInt::get(Type::UIntTy, V); + uint32_t V = FloatToBits(cast(CP->getOperand(i))->getValue()); + Constant *C = ConstantInt::get(Type::UIntTy, V); Result.push_back(ConstantExpr::getCast(C, DstEltTy)); } return ConstantPacked::get(Result); @@ -729,7 +769,7 @@ Constant *llvm::ConstantFoldCastInstruction(const Constant *V, // FIXME: When we support 'external weak' references, we have to prevent // this transformation from happening. This code will need to be updated // to ignore external weak symbols when we support it. - return ConstantBool::True; + return ConstantBool::getTrue(); } else if (const ConstantExpr *CE = dyn_cast(V)) { if (CE->getOpcode() == Instruction::Cast) { Constant *Op = const_cast(CE->getOperand(0)); @@ -842,10 +882,8 @@ Constant *llvm::ConstantFoldCastInstruction(const Constant *V, Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, const Constant *V1, const Constant *V2) { - if (Cond == ConstantBool::True) - return const_cast(V1); - else if (Cond == ConstantBool::False) - return const_cast(V2); + if (const ConstantBool *CB = dyn_cast(Cond)) + return const_cast(CB->getValue() ? V1 : V2); if (isa(V1)) return const_cast(V2); if (isa(V2)) return const_cast(V1); @@ -863,8 +901,8 @@ Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, cast(Val->getType())->getElementType()); if (const ConstantPacked *CVal = dyn_cast(Val)) { - if (const ConstantUInt *CIdx = dyn_cast(Idx)) { - return const_cast(CVal->getOperand(CIdx->getValue())); + if (const ConstantInt *CIdx = dyn_cast(Idx)) { + return const_cast(CVal->getOperand(CIdx->getZExtValue())); } else if (isa(Idx)) { // ee({w,x,y,z}, undef) -> w (an arbitrary value). return const_cast(CVal->getOperand(0)); @@ -876,9 +914,9 @@ Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, const Constant *Elt, const Constant *Idx) { - const ConstantUInt *CIdx = dyn_cast(Idx); + const ConstantInt *CIdx = dyn_cast(Idx); if (!CIdx) return 0; - unsigned idxVal = CIdx->getValue(); + uint64_t idxVal = CIdx->getZExtValue(); if (const UndefValue *UVal = dyn_cast(Val)) { // Insertion of scalar constant into packed undef // Optimize away insertion of undef @@ -983,7 +1021,8 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { // If they are really different, now that they are the same type, then we // found a difference! - if (cast(C1)->getValue() < cast(C2)->getValue()) + if (cast(C1)->getSExtValue() < + cast(C2)->getSExtValue()) return -1; else return 1; @@ -1011,11 +1050,11 @@ static Instruction::BinaryOps evaluateRelation(Constant *V1, Constant *V2) { // We distilled this down to a simple case, use the standard constant // folder. ConstantBool *R = dyn_cast(ConstantExpr::getSetEQ(V1, V2)); - if (R == ConstantBool::True) return Instruction::SetEQ; + if (R && R->getValue()) return Instruction::SetEQ; R = dyn_cast(ConstantExpr::getSetLT(V1, V2)); - if (R == ConstantBool::True) return Instruction::SetLT; + if (R && R->getValue()) return Instruction::SetLT; R = dyn_cast(ConstantExpr::getSetGT(V1, V2)); - if (R == ConstantBool::True) return Instruction::SetGT; + if (R && R->getValue()) return Instruction::SetGT; // If we couldn't figure it out, bail. return Instruction::BinaryOpsEnd; @@ -1212,7 +1251,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // If we successfully folded the expression, return it now. if (C) return C; - if (SetCondInst::isRelational(Opcode)) { + if (SetCondInst::isComparison(Opcode)) { if (isa(V1) || isa(V2)) return UndefValue::get(Type::BoolTy); switch (evaluateRelation(const_cast(V1), @@ -1240,20 +1279,20 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Opcode == Instruction::SetGE); case Instruction::SetLE: // If we know that V1 <= V2, we can only partially decide this relation. - if (Opcode == Instruction::SetGT) return ConstantBool::False; - if (Opcode == Instruction::SetLT) return ConstantBool::True; + if (Opcode == Instruction::SetGT) return ConstantBool::getFalse(); + if (Opcode == Instruction::SetLT) return ConstantBool::getTrue(); break; case Instruction::SetGE: // If we know that V1 >= V2, we can only partially decide this relation. - if (Opcode == Instruction::SetLT) return ConstantBool::False; - if (Opcode == Instruction::SetGT) return ConstantBool::True; + if (Opcode == Instruction::SetLT) return ConstantBool::getFalse(); + if (Opcode == Instruction::SetGT) return ConstantBool::getTrue(); break; case Instruction::SetNE: // If we know that V1 != V2, we can only partially decide this relation. - if (Opcode == Instruction::SetEQ) return ConstantBool::False; - if (Opcode == Instruction::SetNE) return ConstantBool::True; + if (Opcode == Instruction::SetEQ) return ConstantBool::getFalse(); + if (Opcode == Instruction::SetNE) return ConstantBool::getTrue(); break; } } @@ -1316,17 +1355,17 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, case Instruction::Mul: if (V2->isNullValue()) return const_cast(V2); // X * 0 == 0 if (const ConstantInt *CI = dyn_cast(V2)) - if (CI->getRawValue() == 1) + if (CI->getZExtValue() == 1) return const_cast(V1); // X * 1 == X break; case Instruction::Div: if (const ConstantInt *CI = dyn_cast(V2)) - if (CI->getRawValue() == 1) + if (CI->getZExtValue() == 1) return const_cast(V1); // X / 1 == X break; case Instruction::Rem: if (const ConstantInt *CI = dyn_cast(V2)) - if (CI->getRawValue() == 1) + if (CI->getZExtValue() == 1) return Constant::getNullValue(CI->getType()); // X % 1 == 0 break; case Instruction::And: @@ -1340,7 +1379,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // Functions are at least 4-byte aligned. If and'ing the address of a // function with a constant < 4, fold it to zero. if (const ConstantInt *CI = dyn_cast(V2)) - if (CI->getRawValue() < 4 && isa(CPR)) + if (CI->getZExtValue() < 4 && isa(CPR)) return Constant::getNullValue(CI->getType()); } break; @@ -1419,10 +1458,10 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (IdxList.size() == 1) { const Type *ElTy = cast(C->getType())->getElementType(); - if (unsigned ElSize = ElTy->getPrimitiveSize()) { + if (uint32_t ElSize = ElTy->getPrimitiveSize()) { // gep null, C is equal to C*sizeof(nullty). If nullty is a known llvm // type, we can statically fold this. - Constant *R = ConstantUInt::get(Type::UIntTy, ElSize); + Constant *R = ConstantInt::get(Type::UIntTy, ElSize); R = ConstantExpr::getCast(R, Idx0->getType()); R = ConstantExpr::getMul(R, Idx0); return ConstantExpr::getCast(R, C->getType());