Remove debugging info

[oota-llvm.git] / lib / VMCore / ConstantFolding.h

diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h
index cf18ef8cea498059eed4fe2889e6b05938440da2..9e9e760ea1f9fba57ec1380c0feaccc9ff537695 100644 (file)
--- a/lib/VMCore/ConstantFolding.h
+++ b/lib/VMCore/ConstantFolding.h
@@ -12,10 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// WARNING: These operators return pointers to newly 'new'd objects.  You MUST
-//          make sure to free them if you don't want them hanging around. Also,
-//          note that these may return a null object if I don't know how to 
-//          perform those operations on the specified constant types.
+// WARNING: These operators may return a null object if I don't know how to 
+//          perform the specified operation on the specified constant types.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -38,62 +36,99 @@
 #include "llvm/ConstPoolVals.h"
 #include "llvm/Instruction.h"
 #include "llvm/Type.h"
+class PointerType;
 
 namespace opt {
 
 //===----------------------------------------------------------------------===//
-//  Implement == directly...
+//  Implement == and != directly...
 //===----------------------------------------------------------------------===//
 
 inline ConstPoolBool *operator==(const ConstPoolVal &V1, 
                                  const ConstPoolVal &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return new ConstPoolBool(V1.equals(&V2));
+  return ConstPoolBool::get(&V1 == &V2);
+}
+
+inline ConstPoolBool *operator!=(const ConstPoolVal &V1, 
+                                 const ConstPoolVal &V2) {
+  return ConstPoolBool::get(&V1 != &V2);
 }
 
 //===----------------------------------------------------------------------===//
 //  Implement all other operators indirectly through TypeRules system
 //===----------------------------------------------------------------------===//
 
-class ConstRules {
+class ConstRules : public Annotation {
 protected:
-  inline ConstRules() {}  // Can only be subclassed...
+  inline ConstRules() : Annotation(AID) {}  // Can only be subclassed...
 public:
+  static AnnotationID AID;    // AnnotationID for this class
+
   // Unary Operators...
-  virtual ConstPoolVal *neg(const ConstPoolVal *V) const = 0;
-  virtual ConstPoolVal *not(const ConstPoolVal *V) const = 0;
+  virtual ConstPoolVal *op_not(const ConstPoolVal *V) const = 0;
 
   // Binary Operators...
   virtual ConstPoolVal *add(const ConstPoolVal *V1, 
                             const ConstPoolVal *V2) const = 0;
   virtual ConstPoolVal *sub(const ConstPoolVal *V1, 
                             const ConstPoolVal *V2) const = 0;
+  virtual ConstPoolVal *mul(const ConstPoolVal *V1, 
+                           const ConstPoolVal *V2) const = 0;
 
   virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, 
                                   const ConstPoolVal *V2) const = 0;
 
+  // Casting operators.  ick
+  virtual ConstPoolBool *castToBool  (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolSInt *castToSByte (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolUInt *castToUByte (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolSInt *castToShort (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolUInt *castToUShort(const ConstPoolVal *V) const = 0;
+  virtual ConstPoolSInt *castToInt   (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolUInt *castToUInt  (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolSInt *castToLong  (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolUInt *castToULong (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolFP   *castToFloat (const ConstPoolVal *V) const = 0;
+  virtual ConstPoolFP   *castToDouble(const ConstPoolVal *V) const = 0;
+  virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V,
+                                          const PointerType *Ty) const = 0;
+
+  inline ConstPoolVal *castTo(const ConstPoolVal *V, const Type *Ty) const {
+    switch (Ty->getPrimitiveID()) {
+    case Type::BoolTyID:   return castToBool(V);
+    case Type::UByteTyID:  return castToUByte(V);
+    case Type::SByteTyID:  return castToSByte(V);
+    case Type::UShortTyID: return castToUShort(V);
+    case Type::ShortTyID:  return castToShort(V);
+    case Type::UIntTyID:   return castToUInt(V);
+    case Type::IntTyID:    return castToInt(V);
+    case Type::ULongTyID:  return castToULong(V);
+    case Type::LongTyID:   return castToLong(V);
+    case Type::FloatTyID:  return castToFloat(V);
+    case Type::DoubleTyID: return castToDouble(V);
+    case Type::PointerTyID:return castToPointer(V, (PointerType*)Ty);
+    default: return 0;
+    }
+  }
+
   // ConstRules::get - A type will cache its own type rules if one is needed...
   // we just want to make sure to hit the cache instead of doing it indirectly,
   //  if possible...
   //
-  static inline const ConstRules *get(const ConstPoolVal &V) {
-    const ConstRules *Result = V.getType()->getConstRules();
-    return Result ? Result : find(V.getType());
+  static inline ConstRules *get(const ConstPoolVal &V) {
+    return (ConstRules*)V.getType()->getOrCreateAnnotation(AID);
   }
 private :
-  static const ConstRules *find(const Type *Ty);
+  static Annotation *find(AnnotationID AID, const Annotable *Ty, void *);
 
   ConstRules(const ConstRules &);             // Do not implement
   ConstRules &operator=(const ConstRules &);  // Do not implement
 };
 
 
-inline ConstPoolVal *operator-(const ConstPoolVal &V) {
-  return ConstRules::get(V)->neg(&V);
-}
-
 inline ConstPoolVal *operator!(const ConstPoolVal &V) {
-  return ConstRules::get(V)->not(&V);
+  return ConstRules::get(V)->op_not(&V);
 }
 
 
@@ -108,6 +143,11 @@ inline ConstPoolVal *operator-(const ConstPoolVal &V1, const ConstPoolVal &V2) {
   return ConstRules::get(V1)->sub(&V1, &V2);
 }
 
+inline ConstPoolVal *operator*(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+  assert(V1.getType() == V2.getType() && "Constant types must be identical!");
+  return ConstRules::get(V1)->mul(&V1, &V2);
+}
+
 inline ConstPoolBool *operator<(const ConstPoolVal &V1, 
                                 const ConstPoolVal &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
@@ -124,25 +164,14 @@ inline ConstPoolBool *operator>(const ConstPoolVal &V1,
   return V2 < V1;
 }
 
-inline ConstPoolBool *operator!=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
-  ConstPoolBool *Result = V1 == V2;
-  Result->setValue(!Result->getValue());     // Invert value
-  return Result;     // !(V1 == V2)
-}
-
 inline ConstPoolBool *operator>=(const ConstPoolVal &V1, 
                                  const ConstPoolVal &V2) {
-  ConstPoolBool *Result = V1 < V2;
-  Result->setValue(!Result->getValue());     // Invert value
-  return Result;      // !(V1 < V2)
+  return (V1 < V2)->inverted();      // !(V1 < V2)
 }
 
 inline ConstPoolBool *operator<=(const ConstPoolVal &V1, 
                                  const ConstPoolVal &V2) {
-  ConstPoolBool *Result = V1 > V2;
-  Result->setValue(!Result->getValue());     // Invert value
-  return Result;      // !(V1 > V2)
+  return (V1 > V2)->inverted();      // !(V1 > V2)
 }
 
 
@@ -150,11 +179,16 @@ inline ConstPoolBool *operator<=(const ConstPoolVal &V1,
 //  Implement higher level instruction folding type instructions
 //===----------------------------------------------------------------------===//
 
+inline ConstPoolVal *ConstantFoldCastInstruction(ConstPoolVal *V,
+                                                 const Type *DestTy) {
+  return ConstRules::get(*V)->castTo(V, DestTy);
+}
+
 inline ConstPoolVal *ConstantFoldUnaryInstruction(unsigned Opcode, 
                                                   ConstPoolVal *V) {
   switch (Opcode) {
   case Instruction::Not:  return !*V;
-  case Instruction::Neg:  return -*V;
+    // TODO: Handle get element ptr instruction here in the future? GEP null?
   }
   return 0;
 }