diff options
Diffstat (limited to 'lib/VMCore/ConstantFold.cpp')
| -rw-r--r-- | lib/VMCore/ConstantFold.cpp | 197 |
1 files changed, 197 insertions, 0 deletions
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp new file mode 100644 index 0000000000..438ea4b37c --- /dev/null +++ b/lib/VMCore/ConstantFold.cpp @@ -0,0 +1,197 @@ +//===- ConstantHandling.cpp - Implement ConstantHandling.h ----------------===// +// +// This file implements the various intrinsic operations, on constant values. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Opt/ConstantHandling.h" + +//===----------------------------------------------------------------------===// +// TemplateRules Class +//===----------------------------------------------------------------------===// +// +// TemplateRules - Implement a subclass of ConstRules that provides all +// operations as noops. All other rules classes inherit from this class so +// that if functionality is needed in the future, it can simply be added here +// and to ConstRules without changing anything else... +// +// This class also provides subclasses with typesafe implementations of methods +// so that don't have to do type casting. +// +template<class ArgType, class SubClassName> +class TemplateRules : public ConstRules { + + //===--------------------------------------------------------------------===// + // Redirecting functions that cast to the appropriate types + //===--------------------------------------------------------------------===// + + virtual ConstPoolVal *neg(const ConstPoolVal *V) const { + return SubClassName::Neg((const ArgType *)V); + } + + virtual ConstPoolVal *not(const ConstPoolVal *V) const { + return SubClassName::Not((const ArgType *)V); + } + + + virtual ConstPoolVal *add(const ConstPoolVal *V1, + const ConstPoolVal *V2) const { + return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2); + } + + virtual ConstPoolVal *sub(const ConstPoolVal *V1, + const ConstPoolVal *V2) const { + return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2); + } + + virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, + const ConstPoolVal *V2) const { + return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2); + } + + //===--------------------------------------------------------------------===// + // Default "noop" implementations + //===--------------------------------------------------------------------===// + + inline static ConstPoolVal *Neg(const ArgType *V) { return 0; } + inline static ConstPoolVal *Not(const ArgType *V) { return 0; } + + inline static ConstPoolVal *Add(const ArgType *V1, const ArgType *V2) { + return 0; + } + + inline static ConstPoolVal *Sub(const ArgType *V1, const ArgType *V2) { + return 0; + } + + inline static ConstPoolBool *LessThan(const ArgType *V1, const ArgType *V2) { + return 0; + } +}; + + + +//===----------------------------------------------------------------------===// +// EmptyRules Class +//===----------------------------------------------------------------------===// +// +// EmptyRules provides a concrete base class of ConstRules that does nothing +// +static // EmptyInst is static +struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> { +} EmptyInst; + + + +//===----------------------------------------------------------------------===// +// BoolRules Class +//===----------------------------------------------------------------------===// +// +// BoolRules provides a concrete base class of ConstRules for the 'bool' type. +// +static // BoolTyInst is static... +struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> { + + inline static ConstPoolVal *Not(const ConstPoolBool *V) { + return new ConstPoolBool(!V->getValue()); + } + + inline static ConstPoolVal *Or(const ConstPoolBool *V1, + const ConstPoolBool *V2) { + bool Result = V1->getValue() | V2->getValue(); + return new ConstPoolBool(Result); + } + + inline static ConstPoolVal *And(const ConstPoolBool *V1, + const ConstPoolBool *V2) { + bool Result = V1->getValue() & V2->getValue(); + return new ConstPoolBool(Result); + } +} BoolTyInst; + + +//===----------------------------------------------------------------------===// +// DirectRules 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. +// +template<class ConstPoolClass, class BuiltinType, const Type **Ty> +struct DirectRules + : public TemplateRules<ConstPoolClass, + DirectRules<ConstPoolClass, BuiltinType, Ty> > { + + inline static ConstPoolVal *Neg(const ConstPoolClass *V) { + return new ConstPoolClass(*Ty, -(BuiltinType)V->getValue());; + } + inline static ConstPoolVal *Not(const ConstPoolClass *V) { + return new ConstPoolClass(*Ty, !(BuiltinType)V->getValue());; + } + + inline static ConstPoolVal *Add(const ConstPoolClass *V1, + const ConstPoolClass *V2) { + BuiltinType Result = (BuiltinType)V1->getValue() + + (BuiltinType)V2->getValue(); + return new ConstPoolClass(*Ty, Result); + } + + inline static ConstPoolVal *Sub(const ConstPoolClass *V1, + const ConstPoolClass *V2) { + BuiltinType Result = (BuiltinType)V1->getValue() - + (BuiltinType)V2->getValue(); + return new ConstPoolClass(*Ty, Result); + } + + inline static ConstPoolBool *LessThan(const ConstPoolClass *V1, + const ConstPoolClass *V2) { + bool Result = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue(); + return new ConstPoolBool(Result); + } +}; + +//===----------------------------------------------------------------------===// +// DirectRules Subclasses +//===----------------------------------------------------------------------===// +// +// Given the DirectRules class we can now implement lots of types with little +// code. Thank goodness C++ compilers are great at stomping out layers of +// templates... can you imagine having to do this all by hand? (/me is lazy :) +// +static DirectRules<ConstPoolSInt, signed char , &Type::SByteTy> SByteTyInst; +static DirectRules<ConstPoolUInt, unsigned char , &Type::UByteTy> UByteTyInst; +static DirectRules<ConstPoolSInt, signed short, &Type::ShortTy> ShortTyInst; +static DirectRules<ConstPoolUInt, unsigned short, &Type::UShortTy> UShortTyInst; +static DirectRules<ConstPoolSInt, signed int , &Type::IntTy> IntTyInst; +static DirectRules<ConstPoolUInt, unsigned int , &Type::UIntTy> UIntTyInst; +static DirectRules<ConstPoolSInt, int64_t , &Type::LongTy> LongTyInst; +static DirectRules<ConstPoolUInt, uint64_t , &Type::ULongTy> ULongTyInst; +static DirectRules<ConstPoolFP , float , &Type::FloatTy> FloatTyInst; +static DirectRules<ConstPoolFP , double , &Type::DoubleTy> DoubleTyInst; + + +// ConstRules::find - Return the constant rules that take care of the specified +// type. Note that this is cached in the Type value itself, so switch statement +// is only hit at most once per type. +// +const ConstRules *ConstRules::find(const Type *Ty) { + const ConstRules *Result; + switch (Ty->getPrimitiveID()) { + case Type::BoolTyID: Result = &BoolTyInst; break; + case Type::SByteTyID: Result = &SByteTyInst; break; + case Type::UByteTyID: Result = &UByteTyInst; break; + case Type::ShortTyID: Result = &ShortTyInst; break; + case Type::UShortTyID: Result = &UShortTyInst; break; + case Type::IntTyID: Result = &IntTyInst; break; + case Type::UIntTyID: Result = &UIntTyInst; break; + case Type::LongTyID: Result = &LongTyInst; break; + case Type::ULongTyID: Result = &ULongTyInst; break; + case Type::FloatTyID: Result = &FloatTyInst; break; + case Type::DoubleTyID: Result = &DoubleTyInst; break; + default: Result = &EmptyInst; break; + } + + Ty->setConstRules(Result); // Cache the value for future short circuiting! + return Result; +} |