Fixes for PR114: Thanks to Reid Spencer!

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

diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h
index 6135e5c563fccae3563fe203184f5037b2908308..b392ad1173779d0bfb64dae15eb22f75b7903420 100644 (file)
--- a/lib/VMCore/ConstantFolding.h
+++ b/lib/VMCore/ConstantFolding.h
@@ -1,4 +1,11 @@
-//===-- ConstantHandling.h - Stuff for manipulating constants ----*- C++ -*--=//
+//===-- ConstantHandling.h - Stuff for manipulating constants ---*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file contains the declarations of some cool operators that allow you
 // to do natural things with constant pool values.
@@ -35,20 +42,21 @@
 
 #include "llvm/Constants.h"
 #include "llvm/Type.h"
+
+namespace llvm {
+
 class PointerType;
 
 //===----------------------------------------------------------------------===//
 //  Implement == and != directly...
 //===----------------------------------------------------------------------===//
 
-inline ConstantBool *operator==(const Constant &V1, 
-                                const Constant &V2) {
+inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstantBool::get(&V1 == &V2);
 }
 
-inline ConstantBool *operator!=(const Constant &V1, 
-                                const Constant &V2) {
+inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
   return ConstantBool::get(&V1 != &V2);
 }
 
@@ -62,9 +70,6 @@ protected:
 public:
   static AnnotationID AID;    // AnnotationID for this class
 
-  // Unary Operators...
-  virtual Constant *op_not(const Constant *V) const = 0;
-
   // Binary Operators...
   virtual Constant *add(const Constant *V1, const Constant *V2) const = 0;
   virtual Constant *sub(const Constant *V1, const Constant *V2) const = 0;
@@ -92,8 +97,8 @@ public:
   virtual ConstantUInt *castToULong (const Constant *V) const = 0;
   virtual ConstantFP   *castToFloat (const Constant *V) const = 0;
   virtual ConstantFP   *castToDouble(const Constant *V) const = 0;
-  virtual ConstantPointer *castToPointer(const Constant *V,
-                                         const PointerType *Ty) const = 0;
+  virtual Constant     *castToPointer(const Constant *V,
+                                      const PointerType *Ty) const = 0;
 
   inline Constant *castTo(const Constant *V, const Type *Ty) const {
     switch (Ty->getPrimitiveID()) {
@@ -108,7 +113,8 @@ public:
     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);
+    case Type::PointerTyID:
+      return castToPointer(V, reinterpret_cast<const PointerType*>(Ty));
     default: return 0;
     }
   }
@@ -117,79 +123,87 @@ public:
   // we just want to make sure to hit the cache instead of doing it indirectly,
   //  if possible...
   //
-  static inline ConstRules *get(const Constant &V) {
-    return (ConstRules*)V.getType()->getOrCreateAnnotation(AID);
+  static inline ConstRules *get(const Constant &V1, const Constant &V2) {
+    if (isa<ConstantExpr>(V1) || isa<ConstantExpr>(V2))
+      return getConstantExprRules();
+    return static_cast<ConstRules*>(V1.getType()->getOrCreateAnnotation(AID));
   }
-private :
+private:
+  static ConstRules *getConstantExprRules();
   static Annotation *find(AnnotationID AID, const Annotable *Ty, void *);
 
   ConstRules(const ConstRules &);             // Do not implement
   ConstRules &operator=(const ConstRules &);  // Do not implement
 };
 
-
+// Unary operators...
 inline Constant *operator~(const Constant &V) {
-  return ConstRules::get(V)->op_not(&V);
+  assert(V.getType()->isIntegral() && "Cannot invert non-integral constant!");
+  return ConstRules::get(V, V)->op_xor(&V,
+                                    ConstantInt::getAllOnesValue(V.getType()));
 }
 
+inline Constant *operator-(const Constant &V) {
+  return ConstRules::get(V, V)->sub(Constant::getNullValue(V.getType()), &V);
+}
 
 // Standard binary operators...
 inline Constant *operator+(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->add(&V1, &V2);
+  return ConstRules::get(V1, V2)->add(&V1, &V2);
 }
 
 inline Constant *operator-(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->sub(&V1, &V2);
+  return ConstRules::get(V1, V2)->sub(&V1, &V2);
 }
 
 inline Constant *operator*(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->mul(&V1, &V2);
+  return ConstRules::get(V1, V2)->mul(&V1, &V2);
 }
 
 inline Constant *operator/(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->div(&V1, &V2);
+  return ConstRules::get(V1, V2)->div(&V1, &V2);
 }
 
 inline Constant *operator%(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->rem(&V1, &V2);
+  return ConstRules::get(V1, V2)->rem(&V1, &V2);
 }
 
 // Logical Operators...
 inline Constant *operator&(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->op_and(&V1, &V2);
+  return ConstRules::get(V1, V2)->op_and(&V1, &V2);
 }
 
 inline Constant *operator|(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->op_or(&V1, &V2);
+  return ConstRules::get(V1, V2)->op_or(&V1, &V2);
 }
 
 inline Constant *operator^(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->op_xor(&V1, &V2);
+  return ConstRules::get(V1, V2)->op_xor(&V1, &V2);
 }
 
 // Shift Instructions...
 inline Constant *operator<<(const Constant &V1, const Constant &V2) {
-  assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
-  return ConstRules::get(V1)->shl(&V1, &V2);
+  assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
+  return ConstRules::get(V1, V2)->shl(&V1, &V2);
 }
 
 inline Constant *operator>>(const Constant &V1, const Constant &V2) {
-  assert(V1.getType()->isIntegral() && V2.getType() == Type::UByteTy);
-  return ConstRules::get(V1)->shr(&V1, &V2);
+  assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy);
+  return ConstRules::get(V1, V2)->shr(&V1, &V2);
 }
 
 inline ConstantBool *operator<(const Constant &V1, 
                                const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstRules::get(V1)->lessthan(&V1, &V2);
+  return ConstRules::get(V1, V2)->lessthan(&V1, &V2);
 }
 
 
@@ -204,12 +218,16 @@ inline ConstantBool *operator>(const Constant &V1,
 
 inline ConstantBool *operator>=(const Constant &V1, 
                                 const Constant &V2) {
-  return (V1 < V2)->inverted();      // !(V1 < V2)
+  if (ConstantBool *V = (V1 < V2))
+    return V->inverted();                // !(V1 < V2)
+  return 0;
 }
 
 inline ConstantBool *operator<=(const Constant &V1, 
                                 const Constant &V2) {
-  return (V1 > V2)->inverted();      // !(V1 > V2)
+  if (ConstantBool *V = (V1 > V2))
+    return V->inverted();                // !(V1 > V2)
+  return 0;
 }
 
 
@@ -224,10 +242,13 @@ Constant *ConstantFoldInstruction(Instruction *I);
 
 // Constant fold various types of instruction...
 Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy);
-Constant *ConstantFoldUnaryInstruction(unsigned Opcode, const Constant *V);
 Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
                                         const Constant *V2);
 Constant *ConstantFoldShiftInstruction(unsigned Opcode, const Constant *V1,
                                        const Constant *V2);
+Constant *ConstantFoldGetElementPtr(const Constant *C,
+                                    const std::vector<Constant*> &IdxList);
+
+} // End llvm namespace
 
 #endif