diff options
Diffstat (limited to 'lib/VMCore/ConstantFold.cpp')
| -rw-r--r-- | lib/VMCore/ConstantFold.cpp | 236 |
1 files changed, 118 insertions, 118 deletions
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 7438319000..c588f72a23 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -30,67 +30,67 @@ class TemplateRules : public ConstRules { // Redirecting functions that cast to the appropriate types //===--------------------------------------------------------------------===// - virtual ConstPoolVal *op_not(const ConstPoolVal *V) const { + virtual Constant *op_not(const Constant *V) const { return SubClassName::Not((const ArgType *)V); } - virtual ConstPoolVal *add(const ConstPoolVal *V1, - const ConstPoolVal *V2) const { + virtual Constant *add(const Constant *V1, + const Constant *V2) const { return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2); } - virtual ConstPoolVal *sub(const ConstPoolVal *V1, - const ConstPoolVal *V2) const { + virtual Constant *sub(const Constant *V1, + const Constant *V2) const { return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2); } - virtual ConstPoolVal *mul(const ConstPoolVal *V1, - const ConstPoolVal *V2) const { + virtual Constant *mul(const Constant *V1, + const Constant *V2) const { return SubClassName::Mul((const ArgType *)V1, (const ArgType *)V2); } - virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, - const ConstPoolVal *V2) const { + virtual ConstantBool *lessthan(const Constant *V1, + const Constant *V2) const { return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2); } // Casting operators. ick - virtual ConstPoolBool *castToBool(const ConstPoolVal *V) const { + virtual ConstantBool *castToBool(const Constant *V) const { return SubClassName::CastToBool((const ArgType*)V); } - virtual ConstPoolSInt *castToSByte(const ConstPoolVal *V) const { + virtual ConstantSInt *castToSByte(const Constant *V) const { return SubClassName::CastToSByte((const ArgType*)V); } - virtual ConstPoolUInt *castToUByte(const ConstPoolVal *V) const { + virtual ConstantUInt *castToUByte(const Constant *V) const { return SubClassName::CastToUByte((const ArgType*)V); } - virtual ConstPoolSInt *castToShort(const ConstPoolVal *V) const { + virtual ConstantSInt *castToShort(const Constant *V) const { return SubClassName::CastToShort((const ArgType*)V); } - virtual ConstPoolUInt *castToUShort(const ConstPoolVal *V) const { + virtual ConstantUInt *castToUShort(const Constant *V) const { return SubClassName::CastToUShort((const ArgType*)V); } - virtual ConstPoolSInt *castToInt(const ConstPoolVal *V) const { + virtual ConstantSInt *castToInt(const Constant *V) const { return SubClassName::CastToInt((const ArgType*)V); } - virtual ConstPoolUInt *castToUInt(const ConstPoolVal *V) const { + virtual ConstantUInt *castToUInt(const Constant *V) const { return SubClassName::CastToUInt((const ArgType*)V); } - virtual ConstPoolSInt *castToLong(const ConstPoolVal *V) const { + virtual ConstantSInt *castToLong(const Constant *V) const { return SubClassName::CastToLong((const ArgType*)V); } - virtual ConstPoolUInt *castToULong(const ConstPoolVal *V) const { + virtual ConstantUInt *castToULong(const Constant *V) const { return SubClassName::CastToULong((const ArgType*)V); } - virtual ConstPoolFP *castToFloat(const ConstPoolVal *V) const { + virtual ConstantFP *castToFloat(const Constant *V) const { return SubClassName::CastToFloat((const ArgType*)V); } - virtual ConstPoolFP *castToDouble(const ConstPoolVal *V) const { + virtual ConstantFP *castToDouble(const Constant *V) const { return SubClassName::CastToDouble((const ArgType*)V); } - virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, - const PointerType *Ty) const { + virtual ConstantPointer *castToPointer(const Constant *V, + const PointerType *Ty) const { return SubClassName::CastToPointer((const ArgType*)V, Ty); } @@ -98,35 +98,35 @@ class TemplateRules : public ConstRules { // Default "noop" implementations //===--------------------------------------------------------------------===// - inline static ConstPoolVal *Not(const ArgType *V) { return 0; } + inline static Constant *Not(const ArgType *V) { return 0; } - inline static ConstPoolVal *Add(const ArgType *V1, const ArgType *V2) { + inline static Constant *Add(const ArgType *V1, const ArgType *V2) { return 0; } - inline static ConstPoolVal *Sub(const ArgType *V1, const ArgType *V2) { + inline static Constant *Sub(const ArgType *V1, const ArgType *V2) { return 0; } - inline static ConstPoolVal *Mul(const ArgType *V1, const ArgType *V2) { + inline static Constant *Mul(const ArgType *V1, const ArgType *V2) { return 0; } - inline static ConstPoolBool *LessThan(const ArgType *V1, const ArgType *V2) { + inline static ConstantBool *LessThan(const ArgType *V1, const ArgType *V2) { return 0; } // Casting operators. ick - inline static ConstPoolBool *CastToBool (const ConstPoolVal *V) { return 0; } - inline static ConstPoolSInt *CastToSByte (const ConstPoolVal *V) { return 0; } - inline static ConstPoolUInt *CastToUByte (const ConstPoolVal *V) { return 0; } - inline static ConstPoolSInt *CastToShort (const ConstPoolVal *V) { return 0; } - inline static ConstPoolUInt *CastToUShort(const ConstPoolVal *V) { return 0; } - inline static ConstPoolSInt *CastToInt (const ConstPoolVal *V) { return 0; } - inline static ConstPoolUInt *CastToUInt (const ConstPoolVal *V) { return 0; } - inline static ConstPoolSInt *CastToLong (const ConstPoolVal *V) { return 0; } - inline static ConstPoolUInt *CastToULong (const ConstPoolVal *V) { return 0; } - inline static ConstPoolFP *CastToFloat (const ConstPoolVal *V) { return 0; } - inline static ConstPoolFP *CastToDouble(const ConstPoolVal *V) { return 0; } - inline static ConstPoolPointer *CastToPointer(const ConstPoolVal *, - const PointerType *) {return 0;} + inline static ConstantBool *CastToBool (const Constant *V) { return 0; } + inline static ConstantSInt *CastToSByte (const Constant *V) { return 0; } + inline static ConstantUInt *CastToUByte (const Constant *V) { return 0; } + inline static ConstantSInt *CastToShort (const Constant *V) { return 0; } + inline static ConstantUInt *CastToUShort(const Constant *V) { return 0; } + inline static ConstantSInt *CastToInt (const Constant *V) { return 0; } + inline static ConstantUInt *CastToUInt (const Constant *V) { return 0; } + inline static ConstantSInt *CastToLong (const Constant *V) { return 0; } + inline static ConstantUInt *CastToULong (const Constant *V) { return 0; } + inline static ConstantFP *CastToFloat (const Constant *V) { return 0; } + inline static ConstantFP *CastToDouble(const Constant *V) { return 0; } + inline static ConstantPointer *CastToPointer(const Constant *, + const PointerType *) {return 0;} }; @@ -137,7 +137,7 @@ class TemplateRules : public ConstRules { // // EmptyRules provides a concrete base class of ConstRules that does nothing // -struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> { +struct EmptyRules : public TemplateRules<Constant, EmptyRules> { }; @@ -148,20 +148,20 @@ struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> { // // BoolRules provides a concrete base class of ConstRules for the 'bool' type. // -struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> { +struct BoolRules : public TemplateRules<ConstantBool, BoolRules> { - inline static ConstPoolVal *Not(const ConstPoolBool *V) { - return ConstPoolBool::get(!V->getValue()); + inline static Constant *Not(const ConstantBool *V) { + return ConstantBool::get(!V->getValue()); } - inline static ConstPoolVal *Or(const ConstPoolBool *V1, - const ConstPoolBool *V2) { - return ConstPoolBool::get(V1->getValue() | V2->getValue()); + inline static Constant *Or(const ConstantBool *V1, + const ConstantBool *V2) { + return ConstantBool::get(V1->getValue() | V2->getValue()); } - inline static ConstPoolVal *And(const ConstPoolBool *V1, - const ConstPoolBool *V2) { - return ConstPoolBool::get(V1->getValue() & V2->getValue()); + inline static Constant *And(const ConstantBool *V1, + const ConstantBool *V2) { + return ConstantBool::get(V1->getValue() & V2->getValue()); } }; @@ -172,56 +172,56 @@ struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> { // // PointerRules provides a concrete base class of ConstRules for pointer types // -struct PointerRules : public TemplateRules<ConstPoolPointer, PointerRules> { - inline static ConstPoolBool *CastToBool (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolBool::False; +struct PointerRules : public TemplateRules<ConstantPointer, PointerRules> { + inline static ConstantBool *CastToBool (const Constant *V) { + if (V->isNullValue()) return ConstantBool::False; return 0; // Can't const prop other types of pointers } - inline static ConstPoolSInt *CastToSByte (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolSInt::get(Type::SByteTy, 0); + inline static ConstantSInt *CastToSByte (const Constant *V) { + if (V->isNullValue()) return ConstantSInt::get(Type::SByteTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolUInt *CastToUByte (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolUInt::get(Type::UByteTy, 0); + inline static ConstantUInt *CastToUByte (const Constant *V) { + if (V->isNullValue()) return ConstantUInt::get(Type::UByteTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolSInt *CastToShort (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolSInt::get(Type::ShortTy, 0); + inline static ConstantSInt *CastToShort (const Constant *V) { + if (V->isNullValue()) return ConstantSInt::get(Type::ShortTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolUInt *CastToUShort(const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolUInt::get(Type::UShortTy, 0); + inline static ConstantUInt *CastToUShort(const Constant *V) { + if (V->isNullValue()) return ConstantUInt::get(Type::UShortTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolSInt *CastToInt (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolSInt::get(Type::IntTy, 0); + inline static ConstantSInt *CastToInt (const Constant *V) { + if (V->isNullValue()) return ConstantSInt::get(Type::IntTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolUInt *CastToUInt (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolUInt::get(Type::UIntTy, 0); + inline static ConstantUInt *CastToUInt (const Constant *V) { + if (V->isNullValue()) return ConstantUInt::get(Type::UIntTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolSInt *CastToLong (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolSInt::get(Type::LongTy, 0); + inline static ConstantSInt *CastToLong (const Constant *V) { + if (V->isNullValue()) return ConstantSInt::get(Type::LongTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolUInt *CastToULong (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolUInt::get(Type::ULongTy, 0); + inline static ConstantUInt *CastToULong (const Constant *V) { + if (V->isNullValue()) return ConstantUInt::get(Type::ULongTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolFP *CastToFloat (const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolFP::get(Type::FloatTy, 0); + inline static ConstantFP *CastToFloat (const Constant *V) { + if (V->isNullValue()) return ConstantFP::get(Type::FloatTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolFP *CastToDouble(const ConstPoolVal *V) { - if (V->isNullValue()) return ConstPoolFP::get(Type::DoubleTy, 0); + inline static ConstantFP *CastToDouble(const Constant *V) { + if (V->isNullValue()) return ConstantFP::get(Type::DoubleTy, 0); return 0; // Can't const prop other types of pointers } - inline static ConstPoolPointer *CastToPointer(const ConstPoolPointer *V, - const PointerType *PTy) { + inline static ConstantPointer *CastToPointer(const ConstantPointer *V, + const PointerType *PTy) { if (V->isNullValue()) - return ConstPoolPointerNull::get(PTy); + return ConstantPointerNull::get(PTy); return 0; // Can't const prop other types of pointers } }; @@ -235,66 +235,66 @@ struct PointerRules : public TemplateRules<ConstPoolPointer, PointerRules> { // different types. This allows the C++ compiler to automatically generate our // constant handling operations in a typesafe and accurate manner. // -template<class ConstPoolClass, class BuiltinType, Type **Ty> +template<class ConstantClass, class BuiltinType, Type **Ty> struct DirectRules - : public TemplateRules<ConstPoolClass, - DirectRules<ConstPoolClass, BuiltinType, Ty> > { + : public TemplateRules<ConstantClass, + DirectRules<ConstantClass, BuiltinType, Ty> > { - inline static ConstPoolVal *Not(const ConstPoolClass *V) { - return ConstPoolClass::get(*Ty, !(BuiltinType)V->getValue());; + inline static Constant *Not(const ConstantClass *V) { + return ConstantClass::get(*Ty, !(BuiltinType)V->getValue());; } - inline static ConstPoolVal *Add(const ConstPoolClass *V1, - const ConstPoolClass *V2) { + inline static Constant *Add(const ConstantClass *V1, + const ConstantClass *V2) { BuiltinType Result = (BuiltinType)V1->getValue() + (BuiltinType)V2->getValue(); - return ConstPoolClass::get(*Ty, Result); + return ConstantClass::get(*Ty, Result); } - inline static ConstPoolVal *Sub(const ConstPoolClass *V1, - const ConstPoolClass *V2) { + inline static Constant *Sub(const ConstantClass *V1, + const ConstantClass *V2) { BuiltinType Result = (BuiltinType)V1->getValue() - (BuiltinType)V2->getValue(); - return ConstPoolClass::get(*Ty, Result); + return ConstantClass::get(*Ty, Result); } - inline static ConstPoolVal *Mul(const ConstPoolClass *V1, - const ConstPoolClass *V2) { + inline static Constant *Mul(const ConstantClass *V1, + const ConstantClass *V2) { BuiltinType Result = (BuiltinType)V1->getValue() * (BuiltinType)V2->getValue(); - return ConstPoolClass::get(*Ty, Result); + return ConstantClass::get(*Ty, Result); } - inline static ConstPoolBool *LessThan(const ConstPoolClass *V1, - const ConstPoolClass *V2) { + inline static ConstantBool *LessThan(const ConstantClass *V1, + const ConstantClass *V2) { bool Result = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue(); - return ConstPoolBool::get(Result); + return ConstantBool::get(Result); } - inline static ConstPoolPointer *CastToPointer(const ConstPoolClass *V, - const PointerType *PTy) { + inline static ConstantPointer *CastToPointer(const ConstantClass *V, + const PointerType *PTy) { if (V->isNullValue()) // Is it a FP or Integral null value? - return ConstPoolPointerNull::get(PTy); + return ConstantPointerNull::get(PTy); return 0; // Can't const prop other types of pointers } // Casting operators. ick #define DEF_CAST(TYPE, CLASS, CTYPE) \ - inline static CLASS *CastTo##TYPE (const ConstPoolClass *V) { \ + inline static CLASS *CastTo##TYPE (const ConstantClass *V) { \ return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getValue()); \ } - DEF_CAST(Bool , ConstPoolBool, bool) - DEF_CAST(SByte , ConstPoolSInt, signed char) - DEF_CAST(UByte , ConstPoolUInt, unsigned char) - DEF_CAST(Short , ConstPoolSInt, signed short) - DEF_CAST(UShort, ConstPoolUInt, unsigned short) - DEF_CAST(Int , ConstPoolSInt, signed int) - DEF_CAST(UInt , ConstPoolUInt, unsigned int) - DEF_CAST(Long , ConstPoolSInt, int64_t) - DEF_CAST(ULong , ConstPoolUInt, uint64_t) - DEF_CAST(Float , ConstPoolFP , float) - DEF_CAST(Double, ConstPoolFP , double) + 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) #undef DEF_CAST }; @@ -318,25 +318,25 @@ Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) { case Type::BoolTyID: return new BoolRules(); case Type::PointerTyID: return new PointerRules(); case Type::SByteTyID: - return new DirectRules<ConstPoolSInt, signed char , &Type::SByteTy>(); + return new DirectRules<ConstantSInt, signed char , &Type::SByteTy>(); case Type::UByteTyID: - return new DirectRules<ConstPoolUInt, unsigned char , &Type::UByteTy>(); + return new DirectRules<ConstantUInt, unsigned char , &Type::UByteTy>(); case Type::ShortTyID: - return new DirectRules<ConstPoolSInt, signed short, &Type::ShortTy>(); + return new DirectRules<ConstantSInt, signed short, &Type::ShortTy>(); case Type::UShortTyID: - return new DirectRules<ConstPoolUInt, unsigned short, &Type::UShortTy>(); + return new DirectRules<ConstantUInt, unsigned short, &Type::UShortTy>(); case Type::IntTyID: - return new DirectRules<ConstPoolSInt, signed int , &Type::IntTy>(); + return new DirectRules<ConstantSInt, signed int , &Type::IntTy>(); case Type::UIntTyID: - return new DirectRules<ConstPoolUInt, unsigned int , &Type::UIntTy>(); + return new DirectRules<ConstantUInt, unsigned int , &Type::UIntTy>(); case Type::LongTyID: - return new DirectRules<ConstPoolSInt, int64_t , &Type::LongTy>(); + return new DirectRules<ConstantSInt, int64_t , &Type::LongTy>(); case Type::ULongTyID: - return new DirectRules<ConstPoolUInt, uint64_t , &Type::ULongTy>(); + return new DirectRules<ConstantUInt, uint64_t , &Type::ULongTy>(); case Type::FloatTyID: - return new DirectRules<ConstPoolFP , float , &Type::FloatTy>(); + return new DirectRules<ConstantFP , float , &Type::FloatTy>(); case Type::DoubleTyID: - return new DirectRules<ConstPoolFP , double , &Type::DoubleTy>(); + return new DirectRules<ConstantFP , double , &Type::DoubleTy>(); default: return new EmptyRules(); } |