Add ne, eq, fix fold bug.

examples/lvn.py

@@ -15,6 +15,7 @@ class Numbering(dict):
     """A dict mapping anything to numbers that can generate new numbers
     for you when adding new values.
     """
+
     def __init__(self, init={}):
         super(Numbering, self).__init__(init)
         self._next_fresh = 0
@@ -160,7 +161,7 @@ def lvn_block(block, lookup, canonicalize, fold):
             if val:
                 # Is this value foldable to a constant?
                 const = fold(num2const, val)
-                if const:
+                if const is not None:
                     num2const[newnum] = const
                     instr.update({
                         'op': 'const',
@@ -196,6 +197,8 @@ def _lookup(value2num, value):
     'lt': lambda a, b: a < b,
     'ge': lambda a, b: a >= b,
     'le': lambda a, b: a <= b,
+    'ne': lambda a, b: a != b,
+    'eq': lambda a, b: a == b,
 }
 
 
@@ -205,6 +208,10 @@ def _fold(num2const, value):
             const_args = [num2const[n] for n in value.args]
             return FOLDABLE_OPS[value.op](*const_args)
         except KeyError:  # At least one argument is not a constant.
+            if value.op in {'eq', 'ne', 'le', 'ge'} and value.args[0] == value.args[1]:
+                # Equivalent arguments may be evaluated for equality.
+                # E.g. `eq x x`, where `x` is not a constant evaluates to `true`.
+                return value.op != 'ne'
             return None
         except ZeroDivisionError:  # If we hit a dynamic error, bail!
             return None

examples/test/lvn/fold-comparisons.bril

@@ -0,0 +1,25 @@
+# ARGS: -f
+
+@main(arg1: int, arg2: int) {
+  a: int = const 4;
+  b: int = const 3;
+  constant_fold1: bool = ne b a;
+  constant_fold2: bool = eq a b;
+  constant_fold3: bool = le a b;
+  constant_fold4: bool = lt b a;
+  constant_fold5: bool = gt b a;
+  constant_fold6: bool = ge b a;
+
+  should_fold1: bool = eq arg1 arg1;
+  should_fold2: bool = ne arg1 arg1;
+  should_fold3: bool = le arg1 arg1;
+  should_fold4: bool = ge arg1 arg1;
+
+  no_fold1: bool = eq arg1 arg2;
+  no_fold2: bool = ne arg1 arg2;
+  no_fold3: bool = le arg1 arg2;
+  no_fold4: bool = ge arg1 arg2;
+
+  no_fold5: bool = lt arg1 arg1;
+  no_fold6: bool = gt arg2 arg2;
+}

examples/test/lvn/fold-comparisons.out

@@ -0,0 +1,20 @@
+@main(arg1: int, arg2: int) {
+  a: int = const 4;
+  b: int = const 3;
+  constant_fold1: bool = const true;
+  constant_fold2: bool = const false;
+  constant_fold3: bool = const false;
+  constant_fold4: bool = const true;
+  constant_fold5: bool = const false;
+  constant_fold6: bool = const false;
+  should_fold1: bool = const true;
+  should_fold2: bool = const false;
+  should_fold3: bool = const true;
+  should_fold4: bool = const true;
+  no_fold1: bool = eq arg1 arg2;
+  no_fold2: bool = ne arg1 arg2;
+  no_fold3: bool = le arg1 arg2;
+  no_fold4: bool = ge arg1 arg2;
+  no_fold5: bool = lt arg1 arg1;
+  no_fold6: bool = gt arg2 arg2;
+}