Initial revision

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8

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;
+}