From 5d5a714b24f1e31ca98f697dc02ff9b554e258cc Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 17 Nov 2003 20:19:35 +0000 Subject: [PATCH] Implement == and != correctly. Before they would incorrectly return != for some constant exprs when they could really be the same value git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10058 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ConstantHandling.h | 25 ++++++++++++------------- lib/VMCore/ConstantFold.cpp | 24 ++++++++++++++++++++++++ lib/VMCore/ConstantFold.h | 25 ++++++++++++------------- lib/VMCore/ConstantFolding.h | 25 ++++++++++++------------- 4 files changed, 60 insertions(+), 39 deletions(-) diff --git a/include/llvm/ConstantHandling.h b/include/llvm/ConstantHandling.h index d733ac80962..27eed8a7bec 100644 --- a/include/llvm/ConstantHandling.h +++ b/include/llvm/ConstantHandling.h @@ -47,19 +47,6 @@ namespace llvm { class PointerType; -//===----------------------------------------------------------------------===// -// Implement == and != directly... -//===----------------------------------------------------------------------===// - -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) { - return ConstantBool::get(&V1 != &V2); -} - //===----------------------------------------------------------------------===// // Implement all other operators indirectly through TypeRules system //===----------------------------------------------------------------------===// @@ -81,6 +68,8 @@ struct ConstRules { virtual ConstantBool *lessthan(const Constant *V1, const Constant *V2) const = 0; + virtual ConstantBool *equalto(const Constant *V1, + const Constant *V2) const = 0; // Casting operators. ick virtual ConstantBool *castToBool (const Constant *V) const = 0; @@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1, return ConstRules::get(V1, V2).lessthan(&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, V2).equalto(&V1, &V2); +} //===----------------------------------------------------------------------===// // Implement 'derived' operators based on what we already have... //===----------------------------------------------------------------------===// +inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) { + if (ConstantBool *V = (V1 == V2)) + return V->inverted(); // !(V1 == V2) + return 0; +} + inline ConstantBool *operator>(const Constant &V1, const Constant &V2) { return V2 < V1; diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 5e7bd029659..d86ef11ecf5 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -256,6 +256,10 @@ class TemplateRules : public ConstRules { const Constant *V2) const { return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2); } + virtual ConstantBool *equalto(const Constant *V1, + const Constant *V2) const { + return SubClassName::EqualTo((const ArgType *)V1, (const ArgType *)V2); + } // Casting operators. ick virtual ConstantBool *castToBool(const Constant *V) const { @@ -313,6 +317,9 @@ class TemplateRules : public ConstRules { static ConstantBool *LessThan(const ArgType *V1, const ArgType *V2) { return 0; } + static ConstantBool *EqualTo(const ArgType *V1, const ArgType *V2) { + return 0; + } // Casting operators. ick static ConstantBool *CastToBool (const Constant *V) { return 0; } @@ -339,6 +346,10 @@ class TemplateRules : public ConstRules { // EmptyRules provides a concrete base class of ConstRules that does nothing // struct EmptyRules : public TemplateRules { + static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) { + if (V1 == V2) return ConstantBool::True; + return 0; + } }; @@ -355,6 +366,10 @@ struct BoolRules : public TemplateRules { return ConstantBool::get(V1->getValue() < V2->getValue()); } + static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) { + return ConstantBool::get(V1 == V2); + } + static Constant *And(const ConstantBool *V1, const ConstantBool *V2) { return ConstantBool::get(V1->getValue() & V2->getValue()); } @@ -397,6 +412,9 @@ struct BoolRules : public TemplateRules { // struct NullPointerRules : public TemplateRules { + static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) { + return ConstantBool::True; // Null pointers are always equal + } static ConstantBool *CastToBool (const Constant *V) { return ConstantBool::False; } @@ -475,6 +493,12 @@ struct DirectRules : public TemplateRules { return ConstantBool::get(R); } + static ConstantBool *EqualTo(const ConstantClass *V1, + const ConstantClass *V2) { + bool R = (BuiltinType)V1->getValue() == (BuiltinType)V2->getValue(); + return ConstantBool::get(R); + } + static Constant *CastToPointer(const ConstantClass *V, const PointerType *PTy) { if (V->isNullValue()) // Is it a FP or Integral null value? diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index d733ac80962..27eed8a7bec 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -47,19 +47,6 @@ namespace llvm { class PointerType; -//===----------------------------------------------------------------------===// -// Implement == and != directly... -//===----------------------------------------------------------------------===// - -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) { - return ConstantBool::get(&V1 != &V2); -} - //===----------------------------------------------------------------------===// // Implement all other operators indirectly through TypeRules system //===----------------------------------------------------------------------===// @@ -81,6 +68,8 @@ struct ConstRules { virtual ConstantBool *lessthan(const Constant *V1, const Constant *V2) const = 0; + virtual ConstantBool *equalto(const Constant *V1, + const Constant *V2) const = 0; // Casting operators. ick virtual ConstantBool *castToBool (const Constant *V) const = 0; @@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1, return ConstRules::get(V1, V2).lessthan(&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, V2).equalto(&V1, &V2); +} //===----------------------------------------------------------------------===// // Implement 'derived' operators based on what we already have... //===----------------------------------------------------------------------===// +inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) { + if (ConstantBool *V = (V1 == V2)) + return V->inverted(); // !(V1 == V2) + return 0; +} + inline ConstantBool *operator>(const Constant &V1, const Constant &V2) { return V2 < V1; diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h index d733ac80962..27eed8a7bec 100644 --- a/lib/VMCore/ConstantFolding.h +++ b/lib/VMCore/ConstantFolding.h @@ -47,19 +47,6 @@ namespace llvm { class PointerType; -//===----------------------------------------------------------------------===// -// Implement == and != directly... -//===----------------------------------------------------------------------===// - -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) { - return ConstantBool::get(&V1 != &V2); -} - //===----------------------------------------------------------------------===// // Implement all other operators indirectly through TypeRules system //===----------------------------------------------------------------------===// @@ -81,6 +68,8 @@ struct ConstRules { virtual ConstantBool *lessthan(const Constant *V1, const Constant *V2) const = 0; + virtual ConstantBool *equalto(const Constant *V1, + const Constant *V2) const = 0; // Casting operators. ick virtual ConstantBool *castToBool (const Constant *V) const = 0; @@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1, return ConstRules::get(V1, V2).lessthan(&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, V2).equalto(&V1, &V2); +} //===----------------------------------------------------------------------===// // Implement 'derived' operators based on what we already have... //===----------------------------------------------------------------------===// +inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) { + if (ConstantBool *V = (V1 == V2)) + return V->inverted(); // !(V1 == V2) + return 0; +} + inline ConstantBool *operator>(const Constant &V1, const Constant &V2) { return V2 < V1;