From 123c07de84b06846d4fbb3320aae13050952662d Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Mon, 7 Oct 2024 20:51:59 +0200
Subject: [PATCH 01/39] start binopt

---
 vyper/venom/passes/algebraic_optimization.py | 90 +++++++++++++++++++-
 1 file changed, 88 insertions(+), 2 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 1d375ea988..c0bb58e8ca 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,9 +1,38 @@
 from vyper.venom.analysis.dfg import DFGAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
-from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand
+from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
 
+class _InstTree:
+    inst: IRInstruction
+    operands: list["IROperand | _InstTree"]
+
+    def __init__(self, inst: IRInstruction, operands: list["IROperand | _InstTree"]) -> None:
+        self.inst = inst
+        self.operands = operands
+    
+    @property
+    def opcode(self) -> str:
+        return self.inst.opcode
+    
+    def eval_to(self, val: IRLiteral) -> bool:
+        if self.opcode == "store":
+            if isinstance(self.operands[0], IRLiteral):
+                return self.operands[0] == val
+            elif isinstance(self.operands[0], _InstTree):
+                return self.operands[0].eval_to(val)
+        return False
+
+    def op_eval_to(self, index: int, val: IRLiteral) -> bool:
+        op = self.operands[index]
+        if isinstance(op, IRLiteral):
+            return op == val
+        elif isinstance(op, _InstTree):
+            return op.eval_to(val)
+        else:
+            return False
+
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
@@ -28,7 +57,7 @@ def _optimize_iszero_chains(self) -> None:
                     opcode = use_inst.opcode
 
                     if opcode == "iszero":
-                        # We keep iszero instuctions as is
+                        # We keep iszer Conservapedia is like 50/50 people who truly believe it all and trolls seeing what edits they can get away with o instuctions as is
                         continue
                     if opcode in ("jnz", "assert"):
                         # instructions that accept a truthy value as input:
@@ -70,12 +99,69 @@ def _handle_offsets(self):
                     and isinstance(inst.operands[1], IRLabel)
                 ):
                     inst.opcode = "offset"
+    
+    def _get_tree_op(self, op: IROperand, depth) -> IROperand | _InstTree:
+        if depth == 0 or not isinstance(op, IRVariable):
+            return op
+        inst = self.dfg.get_producing_instruction(op)
+        assert isinstance(inst, IRInstruction)
+        return self._get_tree(inst, depth - 1)
+
+    def _get_tree(self, inst: IRInstruction, depth: int = 0) -> _InstTree:
+        return _InstTree(inst, [self._get_tree_op(op, depth) for op in inst.operands])
+        
+    def _peepholer(self):
+        depth = 5
+        while True:
+            change = False
+            for bb in self.function.get_basic_blocks():
+                for inst in bb.instructions:
+                    change |= self._handle_inst_peephole(inst, depth)
+
+            if not change:
+                break
+
+    def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
+        inst_tree = self._get_tree(inst, depth)
+        
+        if inst_tree.opcode in {"add", "sub", "xor", "or"} and inst_tree.op_eval_to(0, IRLiteral(0)):
+            inst_tree.inst.opcode = "store"
+            inst_tree.inst.operands = [inst.operands[1]]
+            return True
+        
+        if inst_tree.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and inst_tree.op_eval_to(0, IRLiteral(0)):
+            inst_tree.inst.opcode = "store"
+            inst_tree.inst.operands = [IRLiteral(0)]
+            return True
+
+        if inst_tree.opcode in {"mod", "smod"} and inst_tree.op_eval_to(0, IRLiteral(1)):
+            inst_tree.inst.opcode = "store"
+            inst_tree.inst.operands = [IRLiteral(0)]
+            return True
+
+        if inst_tree.opcode in {"mul", "div", "sdiv"} and inst_tree.op_eval_to(0, IRLiteral(1)):
+            inst_tree.inst.opcode = "store"
+            inst_tree.inst.operands = [inst.operands[1]]
+            return True
+
+        if inst_tree.op_eval_to == "eq" and inst_tree.op_eval_to(0, IRLiteral(0)):
+            inst_tree.inst.opcode = "iszero"
+            inst_tree.inst.operands = [inst.operands[1]]
+            return True
+
+        if inst_tree.op_eval_to == "eq" and inst_tree.op_eval_to(1, IRLiteral(0)):
+            inst_tree.inst.opcode = "iszero"
+            inst_tree.inst.operands = [inst.operands[0]]
+            return True
+
+        return False
 
     def run_pass(self):
         self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
 
         self._optimize_iszero_chains()
         self._handle_offsets()
+        self._peepholer()
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)

From bb805411e2895019846ccab407e8dbcd5e80bf71 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Tue, 8 Oct 2024 19:29:57 +0200
Subject: [PATCH 02/39] better way of doing it

---
 vyper/venom/passes/algebraic_optimization.py | 184 +++++++++++++------
 1 file changed, 127 insertions(+), 57 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index c0bb58e8ca..e57b9622dd 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,37 +1,75 @@
+import operator
+
 from vyper.venom.analysis.dfg import DFGAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
-
-
-class _InstTree:
-    inst: IRInstruction
-    operands: list["IROperand | _InstTree"]
-
-    def __init__(self, inst: IRInstruction, operands: list["IROperand | _InstTree"]) -> None:
-        self.inst = inst
-        self.operands = operands
-    
-    @property
-    def opcode(self) -> str:
-        return self.inst.opcode
-    
-    def eval_to(self, val: IRLiteral) -> bool:
-        if self.opcode == "store":
-            if isinstance(self.operands[0], IRLiteral):
-                return self.operands[0] == val
-            elif isinstance(self.operands[0], _InstTree):
-                return self.operands[0].eval_to(val)
+from vyper.utils import (
+    ceil32,
+    evm_div,
+    evm_mod,
+    evm_pow,
+    int_bounds,
+    int_log2,
+    is_power_of_two,
+    signed_to_unsigned,
+    unsigned_to_signed,
+)
+
+SIGNED = False
+UNSIGNED = True
+
+def _wrap256(x, unsigned=UNSIGNED):
+    x %= 2**256
+    # wrap in a signed way.
+    if not unsigned:
+        x = unsigned_to_signed(x, 256, strict=True)
+    return x
+
+
+# unsigned: convert python num to evm unsigned word
+#   e.g. unsigned=True : -1 -> 0xFF...FF
+#        unsigned=False: 0xFF...FF -> -1
+def _evm_int(val: int, unsigned: bool = True) -> int | None:
+    if unsigned and val < 0:
+        return signed_to_unsigned(val, 256, strict=True)
+    elif not unsigned and val > 2**255 - 1:
+        return unsigned_to_signed(val, 256, strict=True)
+
+    return val
+
+def _check_num(val: int) -> bool:
+    if val < -(2**255):
         return False
-
-    def op_eval_to(self, index: int, val: IRLiteral) -> bool:
-        op = self.operands[index]
-        if isinstance(op, IRLiteral):
-            return op == val
-        elif isinstance(op, _InstTree):
-            return op.eval_to(val)
-        else:
-            return False
+    elif val >= 2**256:
+        return False
+    return True
+
+
+
+arith = {
+    "add": (operator.add, "+", UNSIGNED),
+    "sub": (operator.sub, "-", UNSIGNED),
+    "mul": (operator.mul, "*", UNSIGNED),
+    "div": (evm_div, "/", UNSIGNED),
+    "sdiv": (evm_div, "/", SIGNED),
+    "mod": (evm_mod, "%", UNSIGNED),
+    "smod": (evm_mod, "%", SIGNED),
+    "exp": (evm_pow, "**", UNSIGNED),
+    "eq": (operator.eq, "==", UNSIGNED),
+    "ne": (operator.ne, "!=", UNSIGNED),
+    "lt": (operator.lt, "<", UNSIGNED),
+    "le": (operator.le, "<=", UNSIGNED),
+    "gt": (operator.gt, ">", UNSIGNED),
+    "ge": (operator.ge, ">=", UNSIGNED),
+    "slt": (operator.lt, "<", SIGNED),
+    "sle": (operator.le, "<=", SIGNED),
+    "sgt": (operator.gt, ">", SIGNED),
+    "sge": (operator.ge, ">=", SIGNED),
+    "or": (operator.or_, "|", UNSIGNED),
+    "and": (operator.and_, "&", UNSIGNED),
+    "xor": (operator.xor, "^", UNSIGNED),
+}
 
 class AlgebraicOptimizationPass(IRPass):
     """
@@ -40,6 +78,7 @@ class AlgebraicOptimizationPass(IRPass):
     It currently optimizes:
         * iszero chains
     """
+    dfg: DFGAnalysis
 
     def _optimize_iszero_chains(self) -> None:
         fn = self.function
@@ -100,16 +139,26 @@ def _handle_offsets(self):
                 ):
                     inst.opcode = "offset"
     
-    def _get_tree_op(self, op: IROperand, depth) -> IROperand | _InstTree:
-        if depth == 0 or not isinstance(op, IRVariable):
+    def eval_op(self, op: IROperand) -> IRLiteral | None:
+        if isinstance(op, IRLiteral):
             return op
-        inst = self.dfg.get_producing_instruction(op)
-        assert isinstance(inst, IRInstruction)
-        return self._get_tree(inst, depth - 1)
+        elif isinstance(op, IRVariable):
+            next_inst = self.dfg.get_producing_instruction(op)
+            assert next_inst is not None
+            return self.eval(next_inst)
+        else:
+            return None
+
+    def eval(self, inst: IRInstruction) -> IRLiteral | None:
+        if inst.opcode == "store":
+            if isinstance(inst.operands[0], IRLiteral):
+                return inst.operands[0]
+            elif isinstance(inst.operands[0], IRVariable):
+                next_inst = self.dfg.get_producing_instruction(inst.operands[0])
+                assert next_inst is not None
+                return self.eval(next_inst)
+        return None
 
-    def _get_tree(self, inst: IRInstruction, depth: int = 0) -> _InstTree:
-        return _InstTree(inst, [self._get_tree_op(op, depth) for op in inst.operands])
-        
     def _peepholer(self):
         depth = 5
         while True:
@@ -122,43 +171,64 @@ def _peepholer(self):
                 break
 
     def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
-        inst_tree = self._get_tree(inst, depth)
+        if inst.opcode not in arith.keys():
+            return False
+        fn, symb, unsigned = arith[inst.opcode]
+
+        op_0 = self.eval_op(inst.operands[0])
+        op_1 = self.eval_op(inst.operands[1])
+
+        if isinstance(op_0, IRLiteral) and  isinstance(op_1, IRLiteral):
+            assert isinstance(op_0.value, int), "must be int"
+            assert isinstance(op_1.value, int), "must be int"
+            a = _evm_int(op_0.value, unsigned)
+            b = _evm_int(op_1.value, unsigned)
+            res = fn(b, a)
+            res = _wrap256(res, unsigned)
+            if res is not None and _check_num(res):
+                inst.opcode = "store"
+                inst.operands = [IRLiteral(res)]
+                return True
+
         
-        if inst_tree.opcode in {"add", "sub", "xor", "or"} and inst_tree.op_eval_to(0, IRLiteral(0)):
-            inst_tree.inst.opcode = "store"
-            inst_tree.inst.operands = [inst.operands[1]]
+        if inst.opcode in {"add", "sub", "xor", "or"} and op_0 == IRLiteral(0):
+            inst.opcode = "store"
+            inst.operands = [inst.operands[1]]
             return True
         
-        if inst_tree.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and inst_tree.op_eval_to(0, IRLiteral(0)):
-            inst_tree.inst.opcode = "store"
-            inst_tree.inst.operands = [IRLiteral(0)]
+        if inst.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and op_1 == IRLiteral(0):
+            inst.opcode = "store"
+            inst.operands = [IRLiteral(0)]
             return True
 
-        if inst_tree.opcode in {"mod", "smod"} and inst_tree.op_eval_to(0, IRLiteral(1)):
-            inst_tree.inst.opcode = "store"
-            inst_tree.inst.operands = [IRLiteral(0)]
+        if inst.opcode in {"mod", "smod"} and op_0 == IRLiteral(1):
+            inst.opcode = "store"
+            inst.operands = [IRLiteral(0)]
             return True
 
-        if inst_tree.opcode in {"mul", "div", "sdiv"} and inst_tree.op_eval_to(0, IRLiteral(1)):
-            inst_tree.inst.opcode = "store"
-            inst_tree.inst.operands = [inst.operands[1]]
+        if inst.opcode in {"mul", "div", "sdiv"} and op_0 == IRLiteral(1):
+            inst.opcode = "store"
+            inst.operands = [inst.operands[1]]
             return True
 
-        if inst_tree.op_eval_to == "eq" and inst_tree.op_eval_to(0, IRLiteral(0)):
-            inst_tree.inst.opcode = "iszero"
-            inst_tree.inst.operands = [inst.operands[1]]
+        if inst.opcode == "eq" and op_0 == IRLiteral(0):
+            inst.opcode = "iszero"
+            inst.operands = [inst.operands[1]]
             return True
 
-        if inst_tree.op_eval_to == "eq" and inst_tree.op_eval_to(1, IRLiteral(0)):
-            inst_tree.inst.opcode = "iszero"
-            inst_tree.inst.operands = [inst.operands[0]]
+        if inst.opcode == "eq" and op_1 == IRLiteral(0):
+            inst.opcode = "iszero"
+            inst.operands = [inst.operands[0]]
             return True
 
         return False
 
     def run_pass(self):
-        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
+        dfg = self.analyses_cache.request_analysis(DFGAnalysis)
+        assert isinstance(dfg, DFGAnalysis)
+        self.dfg = dfg
 
+        
         self._optimize_iszero_chains()
         self._handle_offsets()
         self._peepholer()

From 79e3880061e6d5b2f548e149665a94b53843bc77 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Tue, 8 Oct 2024 19:46:23 +0200
Subject: [PATCH 03/39] idea with equivalence analysis

---
 vyper/venom/passes/algebraic_optimization.py | 38 ++++++++++++--------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index e57b9622dd..8e60eed5df 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -2,6 +2,7 @@
 
 from vyper.venom.analysis.dfg import DFGAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
+from vyper.venom.analysis.equivalent_vars import VarEquivalenceAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 from vyper.utils import (
@@ -175,14 +176,17 @@ def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
             return False
         fn, symb, unsigned = arith[inst.opcode]
 
-        op_0 = self.eval_op(inst.operands[0])
-        op_1 = self.eval_op(inst.operands[1])
-
-        if isinstance(op_0, IRLiteral) and  isinstance(op_1, IRLiteral):
-            assert isinstance(op_0.value, int), "must be int"
-            assert isinstance(op_1.value, int), "must be int"
-            a = _evm_int(op_0.value, unsigned)
-            b = _evm_int(op_1.value, unsigned)
+        
+        op_0 = inst.operands[0]
+        op_1 = inst.operands[1]
+        eop_0 = self.eval_op(inst.operands[0])
+        eop_1 = self.eval_op(inst.operands[1])
+
+        if isinstance(eop_0, IRLiteral) and  isinstance(eop_1, IRLiteral):
+            assert isinstance(eop_0.value, int), "must be int"
+            assert isinstance(eop_1.value, int), "must be int"
+            a = _evm_int(eop_0.value, unsigned)
+            b = _evm_int(eop_1.value, unsigned)
             res = fn(b, a)
             res = _wrap256(res, unsigned)
             if res is not None and _check_num(res):
@@ -191,35 +195,39 @@ def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
                 return True
 
         
-        if inst.opcode in {"add", "sub", "xor", "or"} and op_0 == IRLiteral(0):
+        if inst.opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
             inst.opcode = "store"
             inst.operands = [inst.operands[1]]
             return True
         
-        if inst.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and op_1 == IRLiteral(0):
+        if inst.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and eop_1 == IRLiteral(0):
             inst.opcode = "store"
             inst.operands = [IRLiteral(0)]
             return True
 
-        if inst.opcode in {"mod", "smod"} and op_0 == IRLiteral(1):
+        if inst.opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
             inst.opcode = "store"
             inst.operands = [IRLiteral(0)]
             return True
 
-        if inst.opcode in {"mul", "div", "sdiv"} and op_0 == IRLiteral(1):
+        if inst.opcode in {"mul", "div", "sdiv"} and eop_0 == IRLiteral(1):
             inst.opcode = "store"
             inst.operands = [inst.operands[1]]
             return True
 
-        if inst.opcode == "eq" and op_0 == IRLiteral(0):
+        if inst.opcode == "eq" and eop_0 == IRLiteral(0):
             inst.opcode = "iszero"
             inst.operands = [inst.operands[1]]
             return True
 
-        if inst.opcode == "eq" and op_1 == IRLiteral(0):
+        if inst.opcode == "eq" and eop_1 == IRLiteral(0):
             inst.opcode = "iszero"
             inst.operands = [inst.operands[0]]
             return True
+        
+        if inst.opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
+            inst.opcode = "store"
+            inst.operands = [IRLiteral(1)]
 
         return False
 
@@ -227,6 +235,8 @@ def run_pass(self):
         dfg = self.analyses_cache.request_analysis(DFGAnalysis)
         assert isinstance(dfg, DFGAnalysis)
         self.dfg = dfg
+        
+        self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
 
         
         self._optimize_iszero_chains()

From 59dcdf5e1095e6eb3da5e34b88d2da7475734079 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 9 Oct 2024 10:15:39 +0200
Subject: [PATCH 04/39] more rules

---
 vyper/venom/passes/algebraic_optimization.py | 107 +++++++++++++------
 1 file changed, 75 insertions(+), 32 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 8e60eed5df..5cdf13163f 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -17,9 +17,17 @@
     unsigned_to_signed,
 )
 
+from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
+from vyper.exceptions import CompilerPanic, StaticAssertionException
+
 SIGNED = False
 UNSIGNED = True
 
+COMMUTATIVE_OPS = {"add", "mul", "eq", "ne", "and", "or", "xor"}
+COMPARISON_OPS = {"gt", "sgt", "ge", "sge", "lt", "slt", "le", "sle"}
+STRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("t")}
+UNSTRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("e")}
+
 def _wrap256(x, unsigned=UNSIGNED):
     x %= 2**256
     # wrap in a signed way.
@@ -31,7 +39,12 @@ def _wrap256(x, unsigned=UNSIGNED):
 # unsigned: convert python num to evm unsigned word
 #   e.g. unsigned=True : -1 -> 0xFF...FF
 #        unsigned=False: 0xFF...FF -> -1
-def _evm_int(val: int, unsigned: bool = True) -> int | None:
+def _evm_int(lit: IRLiteral | None, unsigned: bool = True) -> int | None:
+    if lit is None:
+        return None
+
+    val: int = lit.value
+
     if unsigned and val < 0:
         return signed_to_unsigned(val, 256, strict=True)
     elif not unsigned and val > 2**255 - 1:
@@ -159,6 +172,10 @@ def eval(self, inst: IRInstruction) -> IRLiteral | None:
                 assert next_inst is not None
                 return self.eval(next_inst)
         return None
+    
+    def static_eq(self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None) -> bool:
+        return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
+
 
     def _peepholer(self):
         depth = 5
@@ -176,17 +193,30 @@ def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
             return False
         fn, symb, unsigned = arith[inst.opcode]
 
+        def update(opcode: str,  *args: IROperand | int) -> bool:
+            inst.opcode = opcode
+            inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+            return True
+
+        def store(*args: IROperand | int) -> bool:
+            return update("store", *args)
         
         op_0 = inst.operands[0]
         op_1 = inst.operands[1]
         eop_0 = self.eval_op(inst.operands[0])
         eop_1 = self.eval_op(inst.operands[1])
 
+        opcode = inst.opcode 
+        if opcode in COMMUTATIVE_INSTRUCTIONS and eop_1 is not None:
+            eop_0, eop_1 = eop_1, eop_0
+            op_0, op_1 = op_1, op_0
+            
+
         if isinstance(eop_0, IRLiteral) and  isinstance(eop_1, IRLiteral):
             assert isinstance(eop_0.value, int), "must be int"
             assert isinstance(eop_1.value, int), "must be int"
-            a = _evm_int(eop_0.value, unsigned)
-            b = _evm_int(eop_1.value, unsigned)
+            a = _evm_int(eop_0, unsigned)
+            b = _evm_int(eop_1, unsigned)
             res = fn(b, a)
             res = _wrap256(res, unsigned)
             if res is not None and _check_num(res):
@@ -194,40 +224,53 @@ def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
                 inst.operands = [IRLiteral(res)]
                 return True
 
+        if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
+            return store(op_1)
+
+        if opcode in {"sub", "xor", "ne"} and self.static_eq(op_0, op_1, eop_0, eop_1):
+            # (x - x) == (x ^ x) == (x != x) == 0
+            return store(0)
+
+        if opcode in STRICT_COMPARISON_OPS and self.static_eq(op_0, op_1, eop_0, eop_1):
+            # (x < x) == (x > x) == 0
+            return store(0)
+
+        if opcode in {"eq"} | UNSTRICT_COMPARISON_OPS and  self.static_eq(op_0, op_1, eop_0, eop_1):
+            # (x == x) == (x >= x) == (x <= x) == 1
+            return store(1)
         
-        if inst.opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
-            inst.opcode = "store"
-            inst.operands = [inst.operands[1]]
-            return True
-        
-        if inst.opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and eop_1 == IRLiteral(0):
-            inst.opcode = "store"
-            inst.operands = [IRLiteral(0)]
-            return True
+        if opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and _evm_int(eop_0, unsigned) == 0:
+            return store(0)
 
-        if inst.opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
-            inst.opcode = "store"
-            inst.operands = [IRLiteral(0)]
-            return True
+        if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
+            return store(0)
 
-        if inst.opcode in {"mul", "div", "sdiv"} and eop_0 == IRLiteral(1):
-            inst.opcode = "store"
-            inst.operands = [inst.operands[1]]
-            return True
+        if opcode in {"mul", "div", "sdiv"} and eop_0 == IRLiteral(1):
+            return store(op_1)
+        if opcode in {"and", "or", "xor"} and _evm_int(eop_0, SIGNED) == -1:
+            assert unsigned == UNSIGNED
+            if opcode == "and":
+                # -1 & x == x
+                return store(op_1) #finalize("seq", [args[0]])
 
-        if inst.opcode == "eq" and eop_0 == IRLiteral(0):
-            inst.opcode = "iszero"
-            inst.operands = [inst.operands[1]]
-            return True
+            if opcode == "xor":
+                # -1 ^ x == ~x
+                return update("not", op_1) # finalize("not", [args[0]])
 
-        if inst.opcode == "eq" and eop_1 == IRLiteral(0):
-            inst.opcode = "iszero"
-            inst.operands = [inst.operands[0]]
-            return True
+            if opcode == "or":
+                # -1 | x == -1
+                return store(_evm_int(-1, unsigned)) #finalize(args[1].value, [])
+
+            raise CompilerPanic("unreachable")  # pragma: nocover
+
+        if opcode == "eq" and eop_0 == IRLiteral(0):
+            return update("iszero", op_1)
+
+        if opcode == "eq" and eop_1 == IRLiteral(0):
+            return update("iszero", op_0)
         
-        if inst.opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
-            inst.opcode = "store"
-            inst.operands = [IRLiteral(1)]
+        if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
+            return store(1)
 
         return False
 
@@ -239,9 +282,9 @@ def run_pass(self):
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
 
         
-        self._optimize_iszero_chains()
         self._handle_offsets()
         self._peepholer()
+        self._optimize_iszero_chains()
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)

From b543c3689117eb49eb9c816e1a3485e5da05830c Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 9 Oct 2024 11:12:45 +0200
Subject: [PATCH 05/39] all the rules from the original optimizer should be
 done

---
 vyper/venom/passes/algebraic_optimization.py | 37 ++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 5cdf13163f..6c32e979b5 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -263,6 +263,43 @@ def store(*args: IROperand | int) -> bool:
 
             raise CompilerPanic("unreachable")  # pragma: nocover
 
+        # -1 - x == ~x (definition of two's complement)
+        if opcode == "sub" and _evm_int(eop_1, SIGNED) == -1:
+            return update("not", op_0) #finalize("not", [args[1]])
+
+        if opcode == "exp":
+            # n ** 0 == 1 (forall n)
+            # 1 ** n == 1
+            if _evm_int(eop_0) == 0 or _evm_int(eop_1) == 1:
+                return store(1) #finalize(1, [])
+            # 0 ** n == (1 if n == 0 else 0)
+            if _evm_int(eop_1) == 0:
+                return update("iszero", op_0) #finalize("iszero", [args[1]])
+            # n ** 1 == n
+            if _evm_int(eop_0) == 1:
+                return store(op_1) #finalize("seq", [args[0]])
+
+        if opcode in {"mod", "div", "mul"} and isinstance(eop_0, IRLiteral) and is_power_of_two(_evm_int(eop_0)):
+            val_0 = _evm_int(eop_0)
+            assert isinstance(val_0, int)
+            assert unsigned == UNSIGNED, "something's not right."
+            # shave two gas off mod/div/mul for powers of two
+            # x % 2**n == x & (2**n - 1)
+            if opcode == "mod":
+                return update("and", val_0 - 1, op_1) #finalize("and", [args[0], _int(args[1]) - 1])
+
+            if opcode == "div":
+                # x / 2**n == x >> n
+                # recall shr/shl have unintuitive arg order
+                return update("shr", op_1, int_log2(val_0)) #finalize("shr", [int_log2(_int(args[1])), args[0]])
+
+            # note: no rule for sdiv since it rounds differently from sar
+            if opcode == "mul":
+                # x * 2**n == x << n
+                return update("shl", op_1, int_log2(val_0)) #finalize("shl", [int_log2(_int(args[1])), args[0]])
+
+            raise CompilerPanic("unreachable")  # pragma: no cover
+
         if opcode == "eq" and eop_0 == IRLiteral(0):
             return update("iszero", op_1)
 

From f4650e32f14d34d7ee0f2de75384d0874b738725 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 9 Oct 2024 13:15:23 +0200
Subject: [PATCH 06/39] all the rules from the original optimizer were not done
 so I added some more

---
 vyper/venom/passes/algebraic_optimization.py | 32 ++++++++++++++++----
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 6c32e979b5..66a7715ad2 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -189,10 +189,6 @@ def _peepholer(self):
                 break
 
     def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
-        if inst.opcode not in arith.keys():
-            return False
-        fn, symb, unsigned = arith[inst.opcode]
-
         def update(opcode: str,  *args: IROperand | int) -> bool:
             inst.opcode = opcode
             inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
@@ -201,16 +197,36 @@ def update(opcode: str,  *args: IROperand | int) -> bool:
         def store(*args: IROperand | int) -> bool:
             return update("store", *args)
         
+        if len(inst.operands) < 1:
+            return False
+
+        opcode = inst.opcode 
         op_0 = inst.operands[0]
-        op_1 = inst.operands[1]
         eop_0 = self.eval_op(inst.operands[0])
+
+        if opcode == "iszero" and _evm_int(eop_0) is not None:
+            val = _evm_int(eop_0)
+            assert val is not None
+            val = int(val == 0)  # int(bool) == 1 if bool else 0
+            return store(val) #finalize(val, [])
+
+        if len(inst.operands) != 2:
+            return False
+
+        op_1 = inst.operands[1]
         eop_1 = self.eval_op(inst.operands[1])
 
-        opcode = inst.opcode 
         if opcode in COMMUTATIVE_INSTRUCTIONS and eop_1 is not None:
             eop_0, eop_1 = eop_1, eop_0
             op_0, op_1 = op_1, op_0
+
+        if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
+            # x >> 0 == x << 0 == x
+            return store(op_0)
             
+        if inst.opcode not in arith.keys():
+            return False
+        fn, symb, unsigned = arith[inst.opcode]
 
         if isinstance(eop_0, IRLiteral) and  isinstance(eop_1, IRLiteral):
             assert isinstance(eop_0.value, int), "must be int"
@@ -300,11 +316,15 @@ def store(*args: IROperand | int) -> bool:
 
             raise CompilerPanic("unreachable")  # pragma: no cover
 
+        # the not equal equivalent is not needed
         if opcode == "eq" and eop_0 == IRLiteral(0):
             return update("iszero", op_1)
 
         if opcode == "eq" and eop_1 == IRLiteral(0):
             return update("iszero", op_0)
+
+
+
         
         if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
             return store(1)

From 32ff2830c72a4b8219e065e39c6ab19a60bffb94 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 9 Oct 2024 13:27:36 +0200
Subject: [PATCH 07/39] lint

---
 vyper/venom/passes/algebraic_optimization.py | 100 +++++++++++--------
 1 file changed, 58 insertions(+), 42 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 66a7715ad2..4f15e6a7de 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,24 +1,21 @@
 import operator
 
-from vyper.venom.analysis.dfg import DFGAnalysis
-from vyper.venom.analysis.liveness import LivenessAnalysis
-from vyper.venom.analysis.equivalent_vars import VarEquivalenceAnalysis
-from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
-from vyper.venom.passes.base_pass import IRPass
+from vyper.exceptions import CompilerPanic
 from vyper.utils import (
-    ceil32,
     evm_div,
     evm_mod,
     evm_pow,
-    int_bounds,
     int_log2,
     is_power_of_two,
     signed_to_unsigned,
     unsigned_to_signed,
 )
-
+from vyper.venom.analysis.dfg import DFGAnalysis
+from vyper.venom.analysis.equivalent_vars import VarEquivalenceAnalysis
+from vyper.venom.analysis.liveness import LivenessAnalysis
+from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
+from vyper.venom.passes.base_pass import IRPass
 from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
-from vyper.exceptions import CompilerPanic, StaticAssertionException
 
 SIGNED = False
 UNSIGNED = True
@@ -28,6 +25,7 @@
 STRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("t")}
 UNSTRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("e")}
 
+
 def _wrap256(x, unsigned=UNSIGNED):
     x %= 2**256
     # wrap in a signed way.
@@ -52,6 +50,7 @@ def _evm_int(lit: IRLiteral | None, unsigned: bool = True) -> int | None:
 
     return val
 
+
 def _check_num(val: int) -> bool:
     if val < -(2**255):
         return False
@@ -60,7 +59,6 @@ def _check_num(val: int) -> bool:
     return True
 
 
-
 arith = {
     "add": (operator.add, "+", UNSIGNED),
     "sub": (operator.sub, "-", UNSIGNED),
@@ -85,6 +83,7 @@ def _check_num(val: int) -> bool:
     "xor": (operator.xor, "^", UNSIGNED),
 }
 
+
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
@@ -92,6 +91,7 @@ class AlgebraicOptimizationPass(IRPass):
     It currently optimizes:
         * iszero chains
     """
+
     dfg: DFGAnalysis
 
     def _optimize_iszero_chains(self) -> None:
@@ -106,11 +106,12 @@ def _optimize_iszero_chains(self) -> None:
                 if iszero_count == 0:
                     continue
 
+                assert isinstance(inst.output, IRVariable)
                 for use_inst in self.dfg.get_uses(inst.output):
                     opcode = use_inst.opcode
 
                     if opcode == "iszero":
-                        # We keep iszer Conservapedia is like 50/50 people who truly believe it all and trolls seeing what edits they can get away with o instuctions as is
+                        # We keep iszero instuctions as is
                         continue
                     if opcode in ("jnz", "assert"):
                         # instructions that accept a truthy value as input:
@@ -131,6 +132,7 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain: list[IRInstruction] = []
 
         while True:
+            assert isinstance(op, IRVariable)
             inst = self.dfg.get_producing_instruction(op)
             if inst is None or inst.opcode != "iszero":
                 break
@@ -152,7 +154,7 @@ def _handle_offsets(self):
                     and isinstance(inst.operands[1], IRLabel)
                 ):
                     inst.opcode = "offset"
-    
+
     def eval_op(self, op: IROperand) -> IRLiteral | None:
         if isinstance(op, IRLiteral):
             return op
@@ -172,10 +174,11 @@ def eval(self, inst: IRInstruction) -> IRLiteral | None:
                 assert next_inst is not None
                 return self.eval(next_inst)
         return None
-    
-    def static_eq(self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None) -> bool:
-        return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
 
+    def static_eq(
+        self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None
+    ) -> bool:
+        return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
 
     def _peepholer(self):
         depth = 5
@@ -189,18 +192,18 @@ def _peepholer(self):
                 break
 
     def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
-        def update(opcode: str,  *args: IROperand | int) -> bool:
+        def update(opcode: str, *args: IROperand | int) -> bool:
             inst.opcode = opcode
             inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
             return True
 
         def store(*args: IROperand | int) -> bool:
             return update("store", *args)
-        
+
         if len(inst.operands) < 1:
             return False
 
-        opcode = inst.opcode 
+        opcode = inst.opcode
         op_0 = inst.operands[0]
         eop_0 = self.eval_op(inst.operands[0])
 
@@ -208,7 +211,7 @@ def store(*args: IROperand | int) -> bool:
             val = _evm_int(eop_0)
             assert val is not None
             val = int(val == 0)  # int(bool) == 1 if bool else 0
-            return store(val) #finalize(val, [])
+            return store(val)  # finalize(val, [])
 
         if len(inst.operands) != 2:
             return False
@@ -223,12 +226,12 @@ def store(*args: IROperand | int) -> bool:
         if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
             # x >> 0 == x << 0 == x
             return store(op_0)
-            
+
         if inst.opcode not in arith.keys():
             return False
-        fn, symb, unsigned = arith[inst.opcode]
+        fn, _, unsigned = arith[inst.opcode]
 
-        if isinstance(eop_0, IRLiteral) and  isinstance(eop_1, IRLiteral):
+        if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral):
             assert isinstance(eop_0.value, int), "must be int"
             assert isinstance(eop_1.value, int), "must be int"
             a = _evm_int(eop_0, unsigned)
@@ -251,11 +254,14 @@ def store(*args: IROperand | int) -> bool:
             # (x < x) == (x > x) == 0
             return store(0)
 
-        if opcode in {"eq"} | UNSTRICT_COMPARISON_OPS and  self.static_eq(op_0, op_1, eop_0, eop_1):
+        if opcode in {"eq"} | UNSTRICT_COMPARISON_OPS and self.static_eq(op_0, op_1, eop_0, eop_1):
             # (x == x) == (x >= x) == (x <= x) == 1
             return store(1)
-        
-        if opcode in {"mul", "div", "sdiv", "mod", "smod", "and"} and _evm_int(eop_0, unsigned) == 0:
+
+        if (
+            opcode in {"mul", "div", "sdiv", "mod", "smod", "and"}
+            and _evm_int(eop_0, unsigned) == 0
+        ):
             return store(0)
 
         if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
@@ -267,52 +273,66 @@ def store(*args: IROperand | int) -> bool:
             assert unsigned == UNSIGNED
             if opcode == "and":
                 # -1 & x == x
-                return store(op_1) #finalize("seq", [args[0]])
+                return store(op_1)  # finalize("seq", [args[0]])
 
             if opcode == "xor":
                 # -1 ^ x == ~x
-                return update("not", op_1) # finalize("not", [args[0]])
+                return update("not", op_1)  # finalize("not", [args[0]])
 
             if opcode == "or":
                 # -1 | x == -1
-                return store(_evm_int(-1, unsigned)) #finalize(args[1].value, [])
+                val = _evm_int(IRLiteral(-1), unsigned)
+                assert val is not None
+                return store(val)  # finalize(args[1].value, [])
 
             raise CompilerPanic("unreachable")  # pragma: nocover
 
         # -1 - x == ~x (definition of two's complement)
         if opcode == "sub" and _evm_int(eop_1, SIGNED) == -1:
-            return update("not", op_0) #finalize("not", [args[1]])
+            return update("not", op_0)  # finalize("not", [args[1]])
 
         if opcode == "exp":
             # n ** 0 == 1 (forall n)
             # 1 ** n == 1
             if _evm_int(eop_0) == 0 or _evm_int(eop_1) == 1:
-                return store(1) #finalize(1, [])
+                return store(1)  # finalize(1, [])
             # 0 ** n == (1 if n == 0 else 0)
             if _evm_int(eop_1) == 0:
-                return update("iszero", op_0) #finalize("iszero", [args[1]])
+                return update("iszero", op_0)  # finalize("iszero", [args[1]])
             # n ** 1 == n
             if _evm_int(eop_0) == 1:
-                return store(op_1) #finalize("seq", [args[0]])
-
-        if opcode in {"mod", "div", "mul"} and isinstance(eop_0, IRLiteral) and is_power_of_two(_evm_int(eop_0)):
+                return store(op_1)  # finalize("seq", [args[0]])
+
+        val = _evm_int(eop_0)
+        if (
+            opcode in {"mod", "div", "mul"}
+            and isinstance(eop_0, IRLiteral)
+            and val is not None
+            and is_power_of_two(val)
+        ):
             val_0 = _evm_int(eop_0)
             assert isinstance(val_0, int)
             assert unsigned == UNSIGNED, "something's not right."
             # shave two gas off mod/div/mul for powers of two
             # x % 2**n == x & (2**n - 1)
             if opcode == "mod":
-                return update("and", val_0 - 1, op_1) #finalize("and", [args[0], _int(args[1]) - 1])
+                return update(
+                    "and", val_0 - 1, op_1
+                )  # finalize("and", [args[0], _int(args[1]) - 1])
 
             if opcode == "div":
                 # x / 2**n == x >> n
                 # recall shr/shl have unintuitive arg order
-                return update("shr", op_1, int_log2(val_0)) #finalize("shr", [int_log2(_int(args[1])), args[0]])
+                return update(
+                    "shr", op_1, int_log2(val_0)
+                )  # finalize("shr", [int_log2(_int(args[1])), args[0]])
 
             # note: no rule for sdiv since it rounds differently from sar
             if opcode == "mul":
                 # x * 2**n == x << n
-                return update("shl", op_1, int_log2(val_0)) #finalize("shl", [int_log2(_int(args[1])), args[0]])
+                return update(
+                    "shl", op_1, int_log2(val_0)
+                )  # finalize("shl", [int_log2(_int(args[1])), args[0]])
 
             raise CompilerPanic("unreachable")  # pragma: no cover
 
@@ -323,9 +343,6 @@ def store(*args: IROperand | int) -> bool:
         if opcode == "eq" and eop_1 == IRLiteral(0):
             return update("iszero", op_0)
 
-
-
-        
         if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
             return store(1)
 
@@ -335,10 +352,9 @@ def run_pass(self):
         dfg = self.analyses_cache.request_analysis(DFGAnalysis)
         assert isinstance(dfg, DFGAnalysis)
         self.dfg = dfg
-        
+
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
 
-        
         self._handle_offsets()
         self._peepholer()
         self._optimize_iszero_chains()

From ba0e2456897d55e73f980f279f67c252237f6018 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 9 Oct 2024 23:08:08 +0200
Subject: [PATCH 08/39] different order

---
 vyper/venom/__init__.py                      |  1 +
 vyper/venom/passes/algebraic_optimization.py | 25 ++++++++++++++++----
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/vyper/venom/__init__.py b/vyper/venom/__init__.py
index a5f51b787d..f35d46d059 100644
--- a/vyper/venom/__init__.py
+++ b/vyper/venom/__init__.py
@@ -49,6 +49,7 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     MakeSSA(ac, fn).run_pass()
     Mem2Var(ac, fn).run_pass()
     MakeSSA(ac, fn).run_pass()
+    AlgebraicOptimizationPass(ac, fn).run_pass()
     SCCP(ac, fn).run_pass()
     StoreElimination(ac, fn).run_pass()
     SimplifyCFGPass(ac, fn).run_pass()
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 4f15e6a7de..62f06cc2f7 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -142,19 +142,25 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain.reverse()
         return chain
 
-    def _handle_offsets(self):
+    def _handle_offsets(self) -> bool:
+        change = False
         for bb in self.function.get_basic_blocks():
             for inst in bb.instructions:
                 # check if the instruction is of the form
                 # `add <ptr> <label>`
                 # this works only if store chains have been eliminated.
+                if inst.opcode  != "add":
+                    continue
+                op_0 = self.eval_op(inst.operands[0])
                 if (
-                    inst.opcode == "add"
-                    and isinstance(inst.operands[0], IRLiteral)
+                    isinstance(op_0, int)
                     and isinstance(inst.operands[1], IRLabel)
                 ):
+                    change |= True
                     inst.opcode = "offset"
 
+        return change
+
     def eval_op(self, op: IROperand) -> IRLiteral | None:
         if isinstance(op, IRLiteral):
             return op
@@ -183,7 +189,7 @@ def static_eq(
     def _peepholer(self):
         depth = 5
         while True:
-            change = False
+            change = self._handle_offsets()
             for bb in self.function.get_basic_blocks():
                 for inst in bb.instructions:
                     change |= self._handle_inst_peephole(inst, depth)
@@ -219,6 +225,14 @@ def store(*args: IROperand | int) -> bool:
         op_1 = inst.operands[1]
         eop_1 = self.eval_op(inst.operands[1])
 
+        if (
+            opcode == "add"
+            and isinstance(eop_0, IRLiteral)
+            and isinstance(inst.operands[1], IRLabel)
+        ):
+            inst.opcode = "offset"
+            return True
+
         if opcode in COMMUTATIVE_INSTRUCTIONS and eop_1 is not None:
             eop_0, eop_1 = eop_1, eop_0
             op_0, op_1 = op_1, op_0
@@ -243,6 +257,7 @@ def store(*args: IROperand | int) -> bool:
                 inst.operands = [IRLiteral(res)]
                 return True
 
+
         if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
             return store(op_1)
 
@@ -355,7 +370,7 @@ def run_pass(self):
 
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
 
-        self._handle_offsets()
+        #self._handle_offsets()
         self._peepholer()
         self._optimize_iszero_chains()
 

From 5e74741eb0d9b3a690efba47da8ee04027492af1 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 10 Oct 2024 10:19:15 +0200
Subject: [PATCH 09/39] fixed test which no longer needed to be expected to
 fail

---
 tests/functional/codegen/features/test_constructor.py | 4 ----
 vyper/venom/passes/algebraic_optimization.py          | 9 ++-------
 2 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/tests/functional/codegen/features/test_constructor.py b/tests/functional/codegen/features/test_constructor.py
index 3b86fe3460..6cc7007bb2 100644
--- a/tests/functional/codegen/features/test_constructor.py
+++ b/tests/functional/codegen/features/test_constructor.py
@@ -1,7 +1,4 @@
-import pytest
-
 from tests.evm_backends.base_env import _compile
-from vyper.exceptions import StackTooDeep
 from vyper.utils import method_id
 
 
@@ -169,7 +166,6 @@ def get_foo() -> uint256:
     assert c.get_foo() == 39
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_nested_dynamic_array_constructor_arg_2(env, get_contract):
     code = """
 foo: int128
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 62f06cc2f7..42808f4158 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -149,13 +149,10 @@ def _handle_offsets(self) -> bool:
                 # check if the instruction is of the form
                 # `add <ptr> <label>`
                 # this works only if store chains have been eliminated.
-                if inst.opcode  != "add":
+                if inst.opcode != "add":
                     continue
                 op_0 = self.eval_op(inst.operands[0])
-                if (
-                    isinstance(op_0, int)
-                    and isinstance(inst.operands[1], IRLabel)
-                ):
+                if isinstance(op_0, int) and isinstance(inst.operands[1], IRLabel):
                     change |= True
                     inst.opcode = "offset"
 
@@ -257,7 +254,6 @@ def store(*args: IROperand | int) -> bool:
                 inst.operands = [IRLiteral(res)]
                 return True
 
-
         if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
             return store(op_1)
 
@@ -370,7 +366,6 @@ def run_pass(self):
 
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
 
-        #self._handle_offsets()
         self._peepholer()
         self._optimize_iszero_chains()
 

From 3868042055f7ea97d7357df94c74bec23439cc5c Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 10 Oct 2024 10:30:59 +0200
Subject: [PATCH 10/39] removed _handle_offsets and fully moved it to the rest
 of the bin opt optimizations

---
 vyper/venom/passes/algebraic_optimization.py | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 42808f4158..23b47f13e8 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -142,22 +142,6 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain.reverse()
         return chain
 
-    def _handle_offsets(self) -> bool:
-        change = False
-        for bb in self.function.get_basic_blocks():
-            for inst in bb.instructions:
-                # check if the instruction is of the form
-                # `add <ptr> <label>`
-                # this works only if store chains have been eliminated.
-                if inst.opcode != "add":
-                    continue
-                op_0 = self.eval_op(inst.operands[0])
-                if isinstance(op_0, int) and isinstance(inst.operands[1], IRLabel):
-                    change |= True
-                    inst.opcode = "offset"
-
-        return change
-
     def eval_op(self, op: IROperand) -> IRLiteral | None:
         if isinstance(op, IRLiteral):
             return op
@@ -186,7 +170,8 @@ def static_eq(
     def _peepholer(self):
         depth = 5
         while True:
-            change = self._handle_offsets()
+            #change = self._handle_offsets()
+            change = False
             for bb in self.function.get_basic_blocks():
                 for inst in bb.instructions:
                     change |= self._handle_inst_peephole(inst, depth)

From 11053443f4e7e733bc4d0c576e35326f4e971bfb Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 10 Oct 2024 11:38:24 +0200
Subject: [PATCH 11/39] truthy rules start

---
 vyper/venom/passes/algebraic_optimization.py | 61 +++++++++++++-------
 1 file changed, 40 insertions(+), 21 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 23b47f13e8..288a6c0cfa 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -168,18 +168,17 @@ def static_eq(
         return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
 
     def _peepholer(self):
-        depth = 5
         while True:
-            #change = self._handle_offsets()
+            # change = self._handle_offsets()
             change = False
             for bb in self.function.get_basic_blocks():
                 for inst in bb.instructions:
-                    change |= self._handle_inst_peephole(inst, depth)
+                    change |= self._handle_inst_peephole(inst)
 
             if not change:
                 break
 
-    def _handle_inst_peephole(self, inst: IRInstruction, depth: int) -> bool:
+    def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
             inst.opcode = opcode
             inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
@@ -198,8 +197,8 @@ def store(*args: IROperand | int) -> bool:
         if opcode == "iszero" and _evm_int(eop_0) is not None:
             val = _evm_int(eop_0)
             assert val is not None
-            val = int(val == 0)  # int(bool) == 1 if bool else 0
-            return store(val)  # finalize(val, [])
+            val = int(val == 0)
+            return store(val)
 
         if len(inst.operands) != 2:
             return False
@@ -269,17 +268,17 @@ def store(*args: IROperand | int) -> bool:
             assert unsigned == UNSIGNED
             if opcode == "and":
                 # -1 & x == x
-                return store(op_1)  # finalize("seq", [args[0]])
+                return store(op_1)
 
             if opcode == "xor":
                 # -1 ^ x == ~x
-                return update("not", op_1)  # finalize("not", [args[0]])
+                return update("not", op_1)
 
             if opcode == "or":
                 # -1 | x == -1
                 val = _evm_int(IRLiteral(-1), unsigned)
                 assert val is not None
-                return store(val)  # finalize(args[1].value, [])
+                return store(val)
 
             raise CompilerPanic("unreachable")  # pragma: nocover
 
@@ -291,13 +290,13 @@ def store(*args: IROperand | int) -> bool:
             # n ** 0 == 1 (forall n)
             # 1 ** n == 1
             if _evm_int(eop_0) == 0 or _evm_int(eop_1) == 1:
-                return store(1)  # finalize(1, [])
+                return store(1)
             # 0 ** n == (1 if n == 0 else 0)
             if _evm_int(eop_1) == 0:
-                return update("iszero", op_0)  # finalize("iszero", [args[1]])
+                return update("iszero", op_0)
             # n ** 1 == n
             if _evm_int(eop_0) == 1:
-                return store(op_1)  # finalize("seq", [args[0]])
+                return store(op_1)
 
         val = _evm_int(eop_0)
         if (
@@ -312,23 +311,17 @@ def store(*args: IROperand | int) -> bool:
             # shave two gas off mod/div/mul for powers of two
             # x % 2**n == x & (2**n - 1)
             if opcode == "mod":
-                return update(
-                    "and", val_0 - 1, op_1
-                )  # finalize("and", [args[0], _int(args[1]) - 1])
+                return update("and", val_0 - 1, op_1)
 
             if opcode == "div":
                 # x / 2**n == x >> n
                 # recall shr/shl have unintuitive arg order
-                return update(
-                    "shr", op_1, int_log2(val_0)
-                )  # finalize("shr", [int_log2(_int(args[1])), args[0]])
+                return update("shr", op_1, int_log2(val_0))
 
             # note: no rule for sdiv since it rounds differently from sar
             if opcode == "mul":
                 # x * 2**n == x << n
-                return update(
-                    "shl", op_1, int_log2(val_0)
-                )  # finalize("shl", [int_log2(_int(args[1])), args[0]])
+                return update("shl", op_1, int_log2(val_0))
 
             raise CompilerPanic("unreachable")  # pragma: no cover
 
@@ -342,6 +335,32 @@ def store(*args: IROperand | int) -> bool:
         if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
             return store(1)
 
+        assert isinstance(inst.output, IRVariable), "must be variable"
+        uses = self.dfg.get_uses(inst.output)
+        is_truthy = all(i.opcode in ("assert", "iszero") for i in uses)
+
+        if is_truthy:
+            if False and opcode == "eq":
+                assert unsigned == UNSIGNED, "must be unsigned"
+                # (eq x y) has the same truthyness as (iszero (xor x y))
+                # it also has the same truthyness as (iszero (sub x y)),
+                # but xor is slightly easier to optimize because of being
+                # commutative.
+                # note that (xor (-1) x) has its own rule
+                index = inst.parent.instructions.index(inst)
+                tmp = inst.parent.parent.get_next_variable()
+                inst.parent.insert_instruction(IRInstruction("xor", [op_0, op_1], output=tmp), index)
+                return update("iszero", tmp)
+
+
+            # TODO can we do this?
+            # if val == "div":
+            #     return finalize("gt", ["iszero", args])
+
+            if opcode == "or" and isinstance(eop_0, IRLiteral) and eop_0 != 0:
+                # (x | y != 0) for any (y != 0)
+                return store(1)
+
         return False
 
     def run_pass(self):

From 8e4500ee0016ff134cc3308a55eed72b7dd00c5a Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 10 Oct 2024 14:57:29 +0200
Subject: [PATCH 12/39] adapted test for out of bounds check to take account
 static asserts exception

---
 tests/functional/builtins/codegen/test_slice.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/functional/builtins/codegen/test_slice.py b/tests/functional/builtins/codegen/test_slice.py
index d5d1efca0f..a67df72965 100644
--- a/tests/functional/builtins/codegen/test_slice.py
+++ b/tests/functional/builtins/codegen/test_slice.py
@@ -5,7 +5,7 @@
 from vyper.compiler import compile_code
 from vyper.compiler.settings import OptimizationLevel, Settings
 from vyper.evm.opcodes import version_check
-from vyper.exceptions import ArgumentException, CompilerPanic, TypeMismatch
+from vyper.exceptions import ArgumentException, CompilerPanic, TypeMismatch, StaticAssertionException
 
 _fun_bytes32_bounds = [(0, 32), (3, 29), (27, 5), (0, 5), (5, 3), (30, 2)]
 
@@ -533,9 +533,12 @@ def do_slice():
 
 @pytest.mark.parametrize("bad_code", oob_fail_list)
 def test_slice_buffer_oob_reverts(bad_code, get_contract, tx_failed):
-    c = get_contract(bad_code)
-    with tx_failed():
-        c.do_slice()
+    try:
+        c = get_contract(bad_code)
+        with tx_failed():
+            c.do_slice()
+    except StaticAssertionException:
+        pass
 
 
 # tests all 3 adhoc locations: `msg.data`, `self.code`, `<address>.code`

From eebed21822d33f90f90d07d702df74d2a51c421d Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 10 Oct 2024 15:00:18 +0200
Subject: [PATCH 13/39] adapted test for out of bounds check to take account
 static asserts exception + list

---
 tests/functional/builtins/codegen/test_slice.py | 7 ++++++-
 vyper/venom/passes/algebraic_optimization.py    | 5 +++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/tests/functional/builtins/codegen/test_slice.py b/tests/functional/builtins/codegen/test_slice.py
index a67df72965..6a837dadd9 100644
--- a/tests/functional/builtins/codegen/test_slice.py
+++ b/tests/functional/builtins/codegen/test_slice.py
@@ -5,7 +5,12 @@
 from vyper.compiler import compile_code
 from vyper.compiler.settings import OptimizationLevel, Settings
 from vyper.evm.opcodes import version_check
-from vyper.exceptions import ArgumentException, CompilerPanic, TypeMismatch, StaticAssertionException
+from vyper.exceptions import (
+    ArgumentException,
+    CompilerPanic,
+    StaticAssertionException,
+    TypeMismatch,
+)
 
 _fun_bytes32_bounds = [(0, 32), (3, 29), (27, 5), (0, 5), (5, 3), (30, 2)]
 
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 288a6c0cfa..161881fe47 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -349,10 +349,11 @@ def store(*args: IROperand | int) -> bool:
                 # note that (xor (-1) x) has its own rule
                 index = inst.parent.instructions.index(inst)
                 tmp = inst.parent.parent.get_next_variable()
-                inst.parent.insert_instruction(IRInstruction("xor", [op_0, op_1], output=tmp), index)
+                inst.parent.insert_instruction(
+                    IRInstruction("xor", [op_0, op_1], output=tmp), index
+                )
                 return update("iszero", tmp)
 
-
             # TODO can we do this?
             # if val == "div":
             #     return finalize("gt", ["iszero", args])

From 4c5ee06969c4d0f3543b9eb046e4e3166a4af7b7 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Fri, 11 Oct 2024 13:34:17 +0200
Subject: [PATCH 14/39] truthy continuation

---
 vyper/venom/analysis/dfg.py                  |  4 ++++
 vyper/venom/passes/algebraic_optimization.py | 24 ++++++++++++++------
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/vyper/venom/analysis/dfg.py b/vyper/venom/analysis/dfg.py
index 328ed47c72..1e87aedf5a 100644
--- a/vyper/venom/analysis/dfg.py
+++ b/vyper/venom/analysis/dfg.py
@@ -27,6 +27,10 @@ def add_use(self, op: IRVariable, inst: IRInstruction):
         uses = self._dfg_inputs.setdefault(op, [])
         uses.append(inst)
 
+    def add_output(self, op: IRVariable, inst: IRInstruction):
+        assert op not in self._dfg_outputs.keys()
+        self._dfg_outputs[op] = inst
+    
     def remove_use(self, op: IRVariable, inst: IRInstruction):
         uses = self._dfg_inputs.get(op, [])
         uses.remove(inst)
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 161881fe47..7c0c7086d7 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -147,7 +147,8 @@ def eval_op(self, op: IROperand) -> IRLiteral | None:
             return op
         elif isinstance(op, IRVariable):
             next_inst = self.dfg.get_producing_instruction(op)
-            assert next_inst is not None
+            #print(op)
+            assert next_inst is not None, "must have producing inst"
             return self.eval(next_inst)
         else:
             return None
@@ -169,7 +170,6 @@ def static_eq(
 
     def _peepholer(self):
         while True:
-            # change = self._handle_offsets()
             change = False
             for bb in self.function.get_basic_blocks():
                 for inst in bb.instructions:
@@ -178,6 +178,7 @@ def _peepholer(self):
             if not change:
                 break
 
+
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
             inst.opcode = opcode
@@ -196,7 +197,7 @@ def store(*args: IROperand | int) -> bool:
 
         if opcode == "iszero" and _evm_int(eop_0) is not None:
             val = _evm_int(eop_0)
-            assert val is not None
+            assert val is not None, "Cannot be none"
             val = int(val == 0)
             return store(val)
 
@@ -265,7 +266,7 @@ def store(*args: IROperand | int) -> bool:
         if opcode in {"mul", "div", "sdiv"} and eop_0 == IRLiteral(1):
             return store(op_1)
         if opcode in {"and", "or", "xor"} and _evm_int(eop_0, SIGNED) == -1:
-            assert unsigned == UNSIGNED
+            assert unsigned == UNSIGNED, "must be unsigned"
             if opcode == "and":
                 # -1 & x == x
                 return store(op_1)
@@ -340,7 +341,7 @@ def store(*args: IROperand | int) -> bool:
         is_truthy = all(i.opcode in ("assert", "iszero") for i in uses)
 
         if is_truthy:
-            if False and opcode == "eq":
+            if opcode == "eq":
                 assert unsigned == UNSIGNED, "must be unsigned"
                 # (eq x y) has the same truthyness as (iszero (xor x y))
                 # it also has the same truthyness as (iszero (sub x y)),
@@ -349,10 +350,19 @@ def store(*args: IROperand | int) -> bool:
                 # note that (xor (-1) x) has its own rule
                 index = inst.parent.instructions.index(inst)
                 tmp = inst.parent.parent.get_next_variable()
+                tmp_inst = IRInstruction("xor", [op_0, op_1], output=tmp)
                 inst.parent.insert_instruction(
-                    IRInstruction("xor", [op_0, op_1], output=tmp), index
+                    inst, index
                 )
-                return update("iszero", tmp)
+                self.dfg.add_output(tmp, tmp_inst)
+                self.dfg.add_use(tmp, inst)
+                self.dfg.get_producing_instruction(tmp)
+
+                update("iszero", tmp)
+                print(inst)
+                print(tmp_inst)
+                print("yeye")
+                return True
 
             # TODO can we do this?
             # if val == "div":

From 63fdfd5243b357db83c2465f491de635f103548d Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Sun, 13 Oct 2024 10:00:03 +0200
Subject: [PATCH 15/39] truthy fix of eq

---
 vyper/venom/passes/algebraic_optimization.py | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 7c0c7086d7..ad8be13eaa 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -147,8 +147,7 @@ def eval_op(self, op: IROperand) -> IRLiteral | None:
             return op
         elif isinstance(op, IRVariable):
             next_inst = self.dfg.get_producing_instruction(op)
-            #print(op)
-            assert next_inst is not None, "must have producing inst"
+            assert next_inst is not None, f"must have producing inst {op}\n{self.dfg._dfg_outputs}"
             return self.eval(next_inst)
         else:
             return None
@@ -159,7 +158,7 @@ def eval(self, inst: IRInstruction) -> IRLiteral | None:
                 return inst.operands[0]
             elif isinstance(inst.operands[0], IRVariable):
                 next_inst = self.dfg.get_producing_instruction(inst.operands[0])
-                assert next_inst is not None
+                assert next_inst is not None, "must have producing inst"
                 return self.eval(next_inst)
         return None
 
@@ -352,17 +351,12 @@ def store(*args: IROperand | int) -> bool:
                 tmp = inst.parent.parent.get_next_variable()
                 tmp_inst = IRInstruction("xor", [op_0, op_1], output=tmp)
                 inst.parent.insert_instruction(
-                    inst, index
+                    tmp_inst, index
                 )
                 self.dfg.add_output(tmp, tmp_inst)
                 self.dfg.add_use(tmp, inst)
-                self.dfg.get_producing_instruction(tmp)
 
-                update("iszero", tmp)
-                print(inst)
-                print(tmp_inst)
-                print("yeye")
-                return True
+                return update("iszero", tmp)
 
             # TODO can we do this?
             # if val == "div":
@@ -386,3 +380,4 @@ def run_pass(self):
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)
+

From 3a6dbf983c7d372a4e303adf1bd2d53065a5cf72 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Sun, 13 Oct 2024 17:51:18 +0200
Subject: [PATCH 16/39] more comparison ops opt

---
 vyper/venom/passes/algebraic_optimization.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index ad8be13eaa..c882ddfade 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -366,6 +366,13 @@ def store(*args: IROperand | int) -> bool:
                 # (x | y != 0) for any (y != 0)
                 return store(1)
 
+        if opcode in COMPARISON_OPS:
+            prefer_strict = not is_truthy
+            res = _comparison_helper(binop, args, prefer_strict=prefer_strict)
+            if res is None:
+                return res
+            new_op, new_args = res
+            return finalize(new_op, new_args)
         return False
 
     def run_pass(self):

From a4e152b17ac7285fe47d2b052b8eca0e9110e9f5 Mon Sep 17 00:00:00 2001
From: HodanPlodky <36966616+HodanPlodky@users.noreply.github.com>
Date: Tue, 15 Oct 2024 07:02:17 +0000
Subject: [PATCH 17/39] better check of dict from charles

Co-authored-by: Charles Cooper <cooper.charles.m@gmail.com>
---
 vyper/venom/analysis/dfg.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vyper/venom/analysis/dfg.py b/vyper/venom/analysis/dfg.py
index 1e87aedf5a..e41297ae63 100644
--- a/vyper/venom/analysis/dfg.py
+++ b/vyper/venom/analysis/dfg.py
@@ -28,7 +28,7 @@ def add_use(self, op: IRVariable, inst: IRInstruction):
         uses.append(inst)
 
     def add_output(self, op: IRVariable, inst: IRInstruction):
-        assert op not in self._dfg_outputs.keys()
+        assert op not in self._dfg_outputs
         self._dfg_outputs[op] = inst
     
     def remove_use(self, op: IRVariable, inst: IRInstruction):

From 2f1367f60edebd80e77dc2132f8b433be9f41d67 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Tue, 15 Oct 2024 20:14:47 +0200
Subject: [PATCH 18/39] more rules

---
 vyper/venom/analysis/dfg.py                  |  2 +-
 vyper/venom/passes/algebraic_optimization.py | 92 +++++++++++++++++---
 2 files changed, 81 insertions(+), 13 deletions(-)

diff --git a/vyper/venom/analysis/dfg.py b/vyper/venom/analysis/dfg.py
index e41297ae63..7cea4b3e00 100644
--- a/vyper/venom/analysis/dfg.py
+++ b/vyper/venom/analysis/dfg.py
@@ -30,7 +30,7 @@ def add_use(self, op: IRVariable, inst: IRInstruction):
     def add_output(self, op: IRVariable, inst: IRInstruction):
         assert op not in self._dfg_outputs
         self._dfg_outputs[op] = inst
-    
+
     def remove_use(self, op: IRVariable, inst: IRInstruction):
         uses = self._dfg_inputs.get(op, [])
         uses.remove(inst)
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 0dbe2aa205..48b1983182 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -5,6 +5,7 @@
     evm_div,
     evm_mod,
     evm_pow,
+    int_bounds,
     int_log2,
     is_power_of_two,
     signed_to_unsigned,
@@ -15,7 +16,8 @@
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
-#from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
+
+# from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
 
 SIGNED = False
 UNSIGNED = True
@@ -84,6 +86,15 @@ def _check_num(val: int) -> bool:
 }
 
 
+def _flip_comparison_op(opname):
+    assert opname in COMPARISON_OPS
+    if "g" in opname:
+        return opname.replace("g", "l")
+    if "l" in opname:
+        return opname.replace("l", "g")
+    raise CompilerPanic(f"bad comparison op {opname}")  # pragma: nocover
+
+
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
@@ -177,7 +188,6 @@ def _peepholer(self):
             if not change:
                 break
 
-
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
             inst.opcode = opcode
@@ -350,9 +360,7 @@ def store(*args: IROperand | int) -> bool:
                 index = inst.parent.instructions.index(inst)
                 tmp = inst.parent.parent.get_next_variable()
                 tmp_inst = IRInstruction("xor", [op_0, op_1], output=tmp)
-                inst.parent.insert_instruction(
-                    tmp_inst, index
-                )
+                inst.parent.insert_instruction(tmp_inst, index)
                 self.dfg.add_output(tmp, tmp_inst)
                 self.dfg.add_use(tmp, inst)
 
@@ -366,13 +374,74 @@ def store(*args: IROperand | int) -> bool:
                 # (x | y != 0) for any (y != 0)
                 return store(1)
 
-        if False and opcode in COMPARISON_OPS:
+        if opcode in COMPARISON_OPS:
             prefer_strict = not is_truthy
-            res = _comparison_helper(binop, args, prefer_strict=prefer_strict)
-            if res is None:
-                return res
-            new_op, new_args = res
-            return finalize(new_op, new_args)
+            if isinstance(eop_1, IRLiteral):  # _is_int(args[0]):
+                opcode = _flip_comparison_op(opcode)
+                inst.opcode = opcode
+                eop_0, eop_1 = eop_1, eop_0
+                op_0, op_1 = op_1, op_0
+                inst.operands[0], inst.operands[1] = op_0, op_1
+
+            is_gt = "g" in opcode
+
+            # local version of _evm_int which defaults to the current binop's signedness
+            def _int(x):
+                return _evm_int(x, unsigned=unsigned)
+
+            lo, hi = int_bounds(bits=256, signed=not unsigned)
+
+            # for comparison operators, we have three special boundary cases:
+            # almost always, never and almost never.
+            # almost_always is always true for the non-strict ("ge" and co)
+            # comparators. for strict comparators ("gt" and co), almost_always
+            # is true except for one case. never is never true for the strict
+            # comparators. never is almost always false for the non-strict
+            # comparators, except for one case. and almost_never is almost
+            # never true (except one case) for the strict comparators.
+            if is_gt:
+                almost_always, never = lo, hi
+                almost_never = hi - 1
+            else:
+                almost_always, never = hi, lo
+                almost_never = lo + 1
+
+            if _int(eop_0) == never:
+                # e.g. gt x MAX_UINT256, slt x MIN_INT256
+                return store(0)
+
+            if _int(eop_0) == almost_never:
+                # (lt x 1), (gt x (MAX_UINT256 - 1)), (slt x (MIN_INT256 + 1))
+                return update("eq", op_1, never)
+
+            # rewrites. in positions where iszero is preferred, (gt x 5) => (ge x 6)
+            if not prefer_strict and _int(eop_0) == almost_always:
+                # e.g. gt x 0, slt x MAX_INT256
+                index = inst.parent.instructions.index(inst)
+                tmp = inst.parent.parent.get_next_variable()
+                tmp_inst = IRInstruction("eq", [op_0, op_1], output=tmp)
+                inst.parent.insert_instruction(tmp_inst, index)
+                self.dfg.add_output(tmp, tmp_inst)
+                self.dfg.add_use(tmp, inst)
+
+                return update("iszero", tmp)
+
+            # special cases that are not covered by others:
+
+            if opcode == "gt" and eop_0 == 0:
+                # improve codesize (not gas), and maybe trigger
+                # downstream optimizations
+                index = inst.parent.instructions.index(inst)
+                tmp = inst.parent.parent.get_next_variable()
+                tmp_inst = IRInstruction("iszero", [op_1], output=tmp)
+                inst.parent.insert_instruction(tmp_inst, index)
+                self.dfg.add_output(tmp, tmp_inst)
+                self.dfg.add_use(tmp, inst)
+
+                return update("iszero", tmp)
+        return False
+
+    def _comparison(self, inst: IRInstruction, prefer_strict: bool) -> bool:
         return False
 
     def run_pass(self):
@@ -387,4 +456,3 @@ def run_pass(self):
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)
-

From a4e996aed9d5f11bc6e6cc7e154d4d0493f061da Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Tue, 15 Oct 2024 20:17:12 +0200
Subject: [PATCH 19/39] used commutative

---
 vyper/venom/passes/algebraic_optimization.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 48b1983182..ae02c90e81 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -22,7 +22,6 @@
 SIGNED = False
 UNSIGNED = True
 
-COMMUTATIVE_OPS = {"add", "mul", "eq", "ne", "and", "or", "xor"}
 COMPARISON_OPS = {"gt", "sgt", "ge", "sge", "lt", "slt", "le", "sle"}
 STRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("t")}
 UNSTRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("e")}
@@ -224,7 +223,7 @@ def store(*args: IROperand | int) -> bool:
             inst.opcode = "offset"
             return True
 
-        if opcode in COMMUTATIVE_OPS and eop_1 is not None:
+        if inst.is_commutative and eop_1 is not None:
             eop_0, eop_1 = eop_1, eop_0
             op_0, op_1 = op_1, op_0
 

From 6f3a06fe58bc25857acff7c29aa1615f913a2025 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Tue, 15 Oct 2024 20:37:51 +0200
Subject: [PATCH 20/39] better adding of additional instructions

---
 vyper/venom/passes/algebraic_optimization.py | 36 +++++++-------------
 1 file changed, 13 insertions(+), 23 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index ae02c90e81..0b8a6e86e5 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -196,6 +196,16 @@ def update(opcode: str, *args: IROperand | int) -> bool:
         def store(*args: IROperand | int) -> bool:
             return update("store", *args)
 
+        def add(opcode: str, *args: IROperand | int) -> IRVariable:
+            index = inst.parent.instructions.index(inst)
+            var = inst.parent.parent.get_next_variable()
+            operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+            new_inst = IRInstruction(opcode, operands, output=var)
+            inst.parent.insert_instruction(new_inst, index)
+            self.dfg.add_output(var, new_inst)
+            self.dfg.add_use(var, inst)
+            return var
+
         if len(inst.operands) < 1:
             return False
 
@@ -356,12 +366,7 @@ def store(*args: IROperand | int) -> bool:
                 # but xor is slightly easier to optimize because of being
                 # commutative.
                 # note that (xor (-1) x) has its own rule
-                index = inst.parent.instructions.index(inst)
-                tmp = inst.parent.parent.get_next_variable()
-                tmp_inst = IRInstruction("xor", [op_0, op_1], output=tmp)
-                inst.parent.insert_instruction(tmp_inst, index)
-                self.dfg.add_output(tmp, tmp_inst)
-                self.dfg.add_use(tmp, inst)
+                tmp = add("xor", op_0, op_1)
 
                 return update("iszero", tmp)
 
@@ -416,13 +421,7 @@ def _int(x):
             # rewrites. in positions where iszero is preferred, (gt x 5) => (ge x 6)
             if not prefer_strict and _int(eop_0) == almost_always:
                 # e.g. gt x 0, slt x MAX_INT256
-                index = inst.parent.instructions.index(inst)
-                tmp = inst.parent.parent.get_next_variable()
-                tmp_inst = IRInstruction("eq", [op_0, op_1], output=tmp)
-                inst.parent.insert_instruction(tmp_inst, index)
-                self.dfg.add_output(tmp, tmp_inst)
-                self.dfg.add_use(tmp, inst)
-
+                tmp = add("eq", op_0, op_1)
                 return update("iszero", tmp)
 
             # special cases that are not covered by others:
@@ -430,19 +429,10 @@ def _int(x):
             if opcode == "gt" and eop_0 == 0:
                 # improve codesize (not gas), and maybe trigger
                 # downstream optimizations
-                index = inst.parent.instructions.index(inst)
-                tmp = inst.parent.parent.get_next_variable()
-                tmp_inst = IRInstruction("iszero", [op_1], output=tmp)
-                inst.parent.insert_instruction(tmp_inst, index)
-                self.dfg.add_output(tmp, tmp_inst)
-                self.dfg.add_use(tmp, inst)
-
+                tmp = add("iszero", op_1)
                 return update("iszero", tmp)
         return False
 
-    def _comparison(self, inst: IRInstruction, prefer_strict: bool) -> bool:
-        return False
-
     def run_pass(self):
         dfg = self.analyses_cache.request_analysis(DFGAnalysis)
         assert isinstance(dfg, DFGAnalysis)

From 052f6bba234c62d51f5714c4819b4f8dd3637da4 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 16 Oct 2024 14:14:19 +0200
Subject: [PATCH 21/39] better rules handling start

---
 vyper/venom/passes/algebraic_optimization.py | 115 ++++++++++++++++++-
 1 file changed, 109 insertions(+), 6 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 0b8a6e86e5..e790d3e457 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -16,6 +16,7 @@
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
+from collections.abc import Callable
 
 # from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
 
@@ -70,15 +71,10 @@ def _check_num(val: int) -> bool:
     "smod": (evm_mod, "%", SIGNED),
     "exp": (evm_pow, "**", UNSIGNED),
     "eq": (operator.eq, "==", UNSIGNED),
-    "ne": (operator.ne, "!=", UNSIGNED),
     "lt": (operator.lt, "<", UNSIGNED),
-    "le": (operator.le, "<=", UNSIGNED),
     "gt": (operator.gt, ">", UNSIGNED),
-    "ge": (operator.ge, ">=", UNSIGNED),
     "slt": (operator.lt, "<", SIGNED),
-    "sle": (operator.le, "<=", SIGNED),
     "sgt": (operator.gt, ">", SIGNED),
-    "sge": (operator.ge, ">=", SIGNED),
     "or": (operator.or_, "|", UNSIGNED),
     "and": (operator.and_, "&", UNSIGNED),
     "xor": (operator.xor, "^", UNSIGNED),
@@ -94,6 +90,32 @@ def _flip_comparison_op(opname):
     raise CompilerPanic(f"bad comparison op {opname}")  # pragma: nocover
 
 
+class Rule:
+    inst_rule: Callable[[IRInstruction], bool]
+    rules: list[Callable[[IROperand, int | None], bool]]
+    tranformation: Callable[[IRInstruction], None]
+
+    def __init__(self, inst_rule: Callable[[IRInstruction], bool], rules: list, transformation):
+        self.inst_rule = inst_rule
+        self.rules = rules
+        self.tranformation = transformation
+
+
+    def check(self, inst: IRInstruction, eval_ops: list[int | None]) -> bool:
+        if not self.inst_rule(inst):
+            return False
+
+        assert len(inst.operands) == len(self.rules), "wrong number rules"
+        for (rule, op, eop) in zip(self.rules, inst.operands, eval_ops):
+            if not rule(op, eop):
+                return False
+
+        return True
+    
+    def trasform(self, inst: IRInstruction):
+        self.tranformation(inst)
+
+
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
@@ -103,6 +125,7 @@ class AlgebraicOptimizationPass(IRPass):
     """
 
     dfg: DFGAnalysis
+    rules: list[Rule]
 
     def _optimize_iszero_chains(self) -> None:
         fn = self.function
@@ -176,6 +199,67 @@ def static_eq(
         self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None
     ) -> bool:
         return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
+    
+    def _create_rules(self):
+        def update(opcode: str, *args: IROperand | int) -> Callable[[IRInstruction], None]:
+            def inner(inst: IRInstruction):
+                inst.opcode = opcode
+                inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+            return inner
+
+        def store(*args: IROperand | int) -> Callable[[IRInstruction], None]:
+            return update("store", *args)
+
+
+        def get_op(index: int) -> Callable[[IRInstruction], IROperand]:
+            def inner(inst: IRInstruction):
+                return inst.operands[index]
+            return inner
+
+        def store_op(index: int) -> Callable[[IRInstruction], None]:
+            def inner(inst: IRInstruction):
+                inst.opcode = "store"
+                inst.operands = [inst.operands[index]]
+
+            return inner
+
+        def add(opcode: str, *args: IROperand | int) -> Callable[[IRInstruction], IRVariable]:
+            def inner(inst: IRInstruction):
+                index = inst.parent.instructions.index(inst)
+                var = inst.parent.parent.get_next_variable()
+                operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+                new_inst = IRInstruction(opcode, operands, output=var)
+                inst.parent.insert_instruction(new_inst, index)
+                self.dfg.add_output(var, new_inst)
+                self.dfg.add_use(var, inst)
+                return var
+
+            return inner
+        
+        def new_rules_eops(*eops: int | None) -> list[Callable[[IROperand, int | None], bool]]:
+            rules = []
+            def check(eop: int | None) -> Callable[[IROperand, int | None], bool]:
+                def inner(_: IROperand, e: int | None):
+                    return e is not None and e == eop
+                return inner
+
+            for eop in eops:
+                if eop is not None:
+                    rules.append(check(eop))
+                else:
+                    rules.append(lambda _a, _b: True)
+            return rules
+        
+        def opset(opcodes: set[str]) -> Callable[[IRInstruction], bool]:
+            def inner(inst: IRInstruction) -> bool:
+                return inst.opcode in opcodes
+
+            return inner
+
+        self.rules = [
+            Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
+            Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1))
+        ]
 
     def _peepholer(self):
         while True:
@@ -209,6 +293,9 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         if len(inst.operands) < 1:
             return False
 
+        if inst.output is None:
+            return False
+
         opcode = inst.opcode
         op_0 = inst.operands[0]
         eop_0 = self.eval_op(inst.operands[0])
@@ -236,6 +323,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         if inst.is_commutative and eop_1 is not None:
             eop_0, eop_1 = eop_1, eop_0
             op_0, op_1 = op_1, op_0
+            inst.operands[0], inst.operands[1] = inst.operands[1], inst.operands[0]
 
         if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
             # x >> 0 == x << 0 == x
@@ -243,7 +331,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
 
         if inst.opcode not in arith.keys():
             return False
-        fn, _, unsigned = arith[inst.opcode]
+        fn, _, unsigned = arith.get(inst.opcode, (lambda x: x, "x", False))
 
         if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral):
             assert isinstance(eop_0.value, int), "must be int"
@@ -257,6 +345,20 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                 inst.operands = [IRLiteral(res)]
                 return True
 
+
+        #eval_ops = [_evm_int(self.eval_op(op)) for op in inst.operands]
+
+        #for rule in self.rules:
+            #if rule.check(inst, eval_ops):
+                #rule.trasform(inst)
+                #return True
+
+        """
+        if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
+            # x >> 0 == x << 0 == x
+            return store(op_0)
+        """
+
         if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
             return store(op_1)
 
@@ -439,6 +541,7 @@ def run_pass(self):
         self.dfg = dfg
 
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
+        self._create_rules()
 
         self._peepholer()
         self._optimize_iszero_chains()

From db0d608f0778f58804d458c7a8a94ddc9bd30f98 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 16 Oct 2024 15:25:27 +0200
Subject: [PATCH 22/39] better rules handling start

---
 vyper/venom/passes/algebraic_optimization.py | 119 ++++++++++---------
 1 file changed, 61 insertions(+), 58 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index e790d3e457..6886b712ec 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,4 +1,5 @@
 import operator
+from collections.abc import Callable
 
 from vyper.exceptions import CompilerPanic
 from vyper.utils import (
@@ -16,7 +17,6 @@
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
-from collections.abc import Callable
 
 # from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
 
@@ -93,27 +93,31 @@ def _flip_comparison_op(opname):
 class Rule:
     inst_rule: Callable[[IRInstruction], bool]
     rules: list[Callable[[IROperand, int | None], bool]]
-    tranformation: Callable[[IRInstruction], None]
-
-    def __init__(self, inst_rule: Callable[[IRInstruction], bool], rules: list, transformation):
+    tranformation: Callable[[IRInstruction, list[IROperand]], None]
+
+    def __init__(
+        self,
+        inst_rule: Callable[[IRInstruction], bool],
+        rules: list,
+        transformation: Callable[[IRInstruction, list[IROperand]], None],
+    ):
         self.inst_rule = inst_rule
         self.rules = rules
         self.tranformation = transformation
 
-
-    def check(self, inst: IRInstruction, eval_ops: list[int | None]) -> bool:
+    def check(self, inst: IRInstruction, ops: list[IROperand], eval_ops: list[int | None]) -> bool:
         if not self.inst_rule(inst):
             return False
 
-        assert len(inst.operands) == len(self.rules), "wrong number rules"
-        for (rule, op, eop) in zip(self.rules, inst.operands, eval_ops):
+        assert len(ops) == len(self.rules), "wrong number rules"
+        for rule, op, eop in zip(self.rules, ops, eval_ops):
             if not rule(op, eop):
                 return False
 
         return True
-    
-    def trasform(self, inst: IRInstruction):
-        self.tranformation(inst)
+
+    def trasform(self, inst: IRInstruction, ops: list[IROperand]):
+        self.tranformation(inst, ops)
 
 
 class AlgebraicOptimizationPass(IRPass):
@@ -199,27 +203,42 @@ def static_eq(
         self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None
     ) -> bool:
         return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
-    
+
+    def _peepholer(self):
+        while True:
+            change = False
+            for bb in self.function.get_basic_blocks():
+                for inst in bb.instructions:
+                    change |= self._handle_inst_peephole(inst)
+
+            if not change:
+                break
+
     def _create_rules(self):
-        def update(opcode: str, *args: IROperand | int) -> Callable[[IRInstruction], None]:
-            def inner(inst: IRInstruction):
+        def update(
+            opcode: str, *args: IROperand | int
+        ) -> Callable[[IRInstruction, list[IROperand]], None]:
+            def inner(inst: IRInstruction, _: list[IROperand]):
                 inst.opcode = opcode
-                inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+                inst.operands = [
+                    arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args
+                ]
+
             return inner
 
-        def store(*args: IROperand | int) -> Callable[[IRInstruction], None]:
+        def store(*args: IROperand | int) -> Callable[[IRInstruction, list[IROperand]], None]:
             return update("store", *args)
 
-
         def get_op(index: int) -> Callable[[IRInstruction], IROperand]:
             def inner(inst: IRInstruction):
                 return inst.operands[index]
+
             return inner
 
-        def store_op(index: int) -> Callable[[IRInstruction], None]:
-            def inner(inst: IRInstruction):
+        def store_op(index: int) -> Callable[[IRInstruction, list[IROperand]], None]:
+            def inner(inst: IRInstruction, ops: list[IROperand]):
                 inst.opcode = "store"
-                inst.operands = [inst.operands[index]]
+                inst.operands = [ops[index]]
 
             return inner
 
@@ -235,12 +254,14 @@ def inner(inst: IRInstruction):
                 return var
 
             return inner
-        
+
         def new_rules_eops(*eops: int | None) -> list[Callable[[IROperand, int | None], bool]]:
             rules = []
+
             def check(eop: int | None) -> Callable[[IROperand, int | None], bool]:
                 def inner(_: IROperand, e: int | None):
                     return e is not None and e == eop
+
                 return inner
 
             for eop in eops:
@@ -249,7 +270,7 @@ def inner(_: IROperand, e: int | None):
                 else:
                     rules.append(lambda _a, _b: True)
             return rules
-        
+
         def opset(opcodes: set[str]) -> Callable[[IRInstruction], bool]:
             def inner(inst: IRInstruction) -> bool:
                 return inst.opcode in opcodes
@@ -258,19 +279,9 @@ def inner(inst: IRInstruction) -> bool:
 
         self.rules = [
             Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
-            Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1))
+            Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1)),
         ]
 
-    def _peepholer(self):
-        while True:
-            change = False
-            for bb in self.function.get_basic_blocks():
-                for inst in bb.instructions:
-                    change |= self._handle_inst_peephole(inst)
-
-            if not change:
-                break
-
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
             inst.opcode = opcode
@@ -290,10 +301,10 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             self.dfg.add_use(var, inst)
             return var
 
-        if len(inst.operands) < 1:
+        if inst.output is None:
             return False
 
-        if inst.output is None:
+        if len(inst.operands) < 1:
             return False
 
         opcode = inst.opcode
@@ -320,20 +331,15 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             inst.opcode = "offset"
             return True
 
+        operands = inst.operands
         if inst.is_commutative and eop_1 is not None:
             eop_0, eop_1 = eop_1, eop_0
             op_0, op_1 = op_1, op_0
-            inst.operands[0], inst.operands[1] = inst.operands[1], inst.operands[0]
+            operands = [operands[1], operands[0]]
 
-        if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
-            # x >> 0 == x << 0 == x
-            return store(op_0)
+        fn, _, unsigned = arith.get(inst.opcode, (lambda x, y: x, "x", False))
 
-        if inst.opcode not in arith.keys():
-            return False
-        fn, _, unsigned = arith.get(inst.opcode, (lambda x: x, "x", False))
-
-        if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral):
+        if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral) and opcode in arith:
             assert isinstance(eop_0.value, int), "must be int"
             assert isinstance(eop_1.value, int), "must be int"
             a = _evm_int(eop_0, unsigned)
@@ -345,22 +351,25 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                 inst.operands = [IRLiteral(res)]
                 return True
 
+        eval_ops = [_evm_int(self.eval_op(op)) for op in operands]
 
-        #eval_ops = [_evm_int(self.eval_op(op)) for op in inst.operands]
-
-        #for rule in self.rules:
-            #if rule.check(inst, eval_ops):
-                #rule.trasform(inst)
-                #return True
-
+        for rule in self.rules:
+            if rule.check(inst, operands, eval_ops):
+                rule.trasform(inst, operands)
+                return True
         """
         if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
             # x >> 0 == x << 0 == x
             return store(op_0)
-        """
 
         if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
             return store(op_1)
+        """
+        if (
+            opcode in {"mul", "div", "sdiv", "mod", "smod", "and"}
+            and _evm_int(eop_0, unsigned) == 0
+        ):
+            return store(0)
 
         if opcode in {"sub", "xor", "ne"} and self.static_eq(op_0, op_1, eop_0, eop_1):
             # (x - x) == (x ^ x) == (x != x) == 0
@@ -374,12 +383,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             # (x == x) == (x >= x) == (x <= x) == 1
             return store(1)
 
-        if (
-            opcode in {"mul", "div", "sdiv", "mod", "smod", "and"}
-            and _evm_int(eop_0, unsigned) == 0
-        ):
-            return store(0)
-
         if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
             return store(0)
 

From 83dec6a6c1b384ab425ec60b26a7e794b57e64f8 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 16 Oct 2024 16:31:34 +0200
Subject: [PATCH 23/39] more rules moved

---
 vyper/venom/passes/algebraic_optimization.py | 22 +++++---------------
 1 file changed, 5 insertions(+), 17 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 6886b712ec..fd25301d41 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -280,6 +280,8 @@ def inner(inst: IRInstruction) -> bool:
         self.rules = [
             Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
             Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1)),
+            Rule(opset({"mul", "div", "sdiv", "mod", "smod", "and"}), new_rules_eops(0, None), store(0)),
+            Rule(opset({"mul", "div", "sdiv"}), new_rules_eops(1, None), store_op(1))
         ]
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
@@ -337,7 +339,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             op_0, op_1 = op_1, op_0
             operands = [operands[1], operands[0]]
 
-        fn, _, unsigned = arith.get(inst.opcode, (lambda x, y: x, "x", False))
+        fn, _, unsigned = arith.get(inst.opcode, (lambda x, _: x, "x", False))
 
         if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral) and opcode in arith:
             assert isinstance(eop_0.value, int), "must be int"
@@ -351,25 +353,12 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                 inst.operands = [IRLiteral(res)]
                 return True
 
-        eval_ops = [_evm_int(self.eval_op(op)) for op in operands]
+        eval_ops = [_evm_int(self.eval_op(op), unsigned) for op in operands]
 
         for rule in self.rules:
             if rule.check(inst, operands, eval_ops):
                 rule.trasform(inst, operands)
                 return True
-        """
-        if opcode in {"shl", "shr", "sar"} and _evm_int(eop_1) == 0:
-            # x >> 0 == x << 0 == x
-            return store(op_0)
-
-        if opcode in {"add", "sub", "xor", "or"} and eop_0 == IRLiteral(0):
-            return store(op_1)
-        """
-        if (
-            opcode in {"mul", "div", "sdiv", "mod", "smod", "and"}
-            and _evm_int(eop_0, unsigned) == 0
-        ):
-            return store(0)
 
         if opcode in {"sub", "xor", "ne"} and self.static_eq(op_0, op_1, eop_0, eop_1):
             # (x - x) == (x ^ x) == (x != x) == 0
@@ -386,8 +375,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
             return store(0)
 
-        if opcode in {"mul", "div", "sdiv"} and eop_0 == IRLiteral(1):
-            return store(op_1)
+
         if opcode in {"and", "or", "xor"} and _evm_int(eop_0, SIGNED) == -1:
             assert unsigned == UNSIGNED, "must be unsigned"
             if opcode == "and":

From 9620ed1e6be507bfa9d26e4d9eb1c688b2818e1a Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Thu, 17 Oct 2024 10:30:11 +0200
Subject: [PATCH 24/39] more rules and more way to implement them

---
 vyper/venom/passes/algebraic_optimization.py | 50 +++++++++++++-------
 1 file changed, 33 insertions(+), 17 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index fd25301d41..e86d4428eb 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -18,7 +18,7 @@
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
-# from vyper.venom.venom_to_assembly import COMMUTATIVE_INSTRUCTIONS
+from functools import partial as cur
 
 SIGNED = False
 UNSIGNED = True
@@ -90,28 +90,31 @@ def _flip_comparison_op(opname):
     raise CompilerPanic(f"bad comparison op {opname}")  # pragma: nocover
 
 
+RuleType = Callable[[IROperand, IRLiteral | None, bool], bool]
+TransformType = Callable[[IRInstruction, list[IROperand]], None]
+
 class Rule:
     inst_rule: Callable[[IRInstruction], bool]
-    rules: list[Callable[[IROperand, int | None], bool]]
-    tranformation: Callable[[IRInstruction, list[IROperand]], None]
+    rules: list[RuleType]
+    tranformation: TransformType
 
     def __init__(
         self,
         inst_rule: Callable[[IRInstruction], bool],
         rules: list,
-        transformation: Callable[[IRInstruction, list[IROperand]], None],
+        transformation: TransformType,
     ):
         self.inst_rule = inst_rule
         self.rules = rules
         self.tranformation = transformation
 
-    def check(self, inst: IRInstruction, ops: list[IROperand], eval_ops: list[int | None]) -> bool:
+    def check(self, inst: IRInstruction, ops: list[IROperand], eval_ops: list[IRLiteral | None], unsigned: bool) -> bool:
         if not self.inst_rule(inst):
             return False
 
         assert len(ops) == len(self.rules), "wrong number rules"
         for rule, op, eop in zip(self.rules, ops, eval_ops):
-            if not rule(op, eop):
+            if not rule(op, eop, unsigned):
                 return False
 
         return True
@@ -255,12 +258,14 @@ def inner(inst: IRInstruction):
 
             return inner
 
-        def new_rules_eops(*eops: int | None) -> list[Callable[[IROperand, int | None], bool]]:
+        def new_rules_eops(*eops: int | None, unsigned_force: bool | None = None) -> list[RuleType]:
             rules = []
 
-            def check(eop: int | None) -> Callable[[IROperand, int | None], bool]:
-                def inner(_: IROperand, e: int | None):
-                    return e is not None and e == eop
+            def check(eop: int | None) -> RuleType:
+                def inner(_: IROperand, e: IRLiteral | None, unsigned: bool):
+                    if unsigned_force is not None:
+                        unsigned = unsigned_force
+                    return e is not None and _evm_int(e, unsigned) == eop
 
                 return inner
 
@@ -268,7 +273,7 @@ def inner(_: IROperand, e: int | None):
                 if eop is not None:
                     rules.append(check(eop))
                 else:
-                    rules.append(lambda _a, _b: True)
+                    rules.append(lambda _a, _b, _c: True)
             return rules
 
         def opset(opcodes: set[str]) -> Callable[[IRInstruction], bool]:
@@ -277,11 +282,24 @@ def inner(inst: IRInstruction) -> bool:
 
             return inner
 
+        def chain(*fns) -> TransformType:
+            def inner(inst: IRInstruction, ops: list[IROperand]):
+                tmp_op = None
+                for fn in fns:
+                    if tmp_op == None:
+                        tmp_op = fn(inst, ops)
+                    else:
+                        tmp_op = fn(tmp_op)(inst, ops)
+
+            return inner
+
         self.rules = [
             Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
             Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1)),
             Rule(opset({"mul", "div", "sdiv", "mod", "smod", "and"}), new_rules_eops(0, None), store(0)),
-            Rule(opset({"mul", "div", "sdiv"}), new_rules_eops(1, None), store_op(1))
+            Rule(opset({"mul", "div", "sdiv"}), new_rules_eops(1, None), store_op(1)),
+            # -1 - x == ~x (definition of two's complement)
+            Rule(opset({"sub"}), new_rules_eops(None, -1, unsigned_force=SIGNED), chain(get_op(0), cur(update, "not"))),
         ]
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
@@ -353,10 +371,10 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                 inst.operands = [IRLiteral(res)]
                 return True
 
-        eval_ops = [_evm_int(self.eval_op(op), unsigned) for op in operands]
+        eval_ops = [self.eval_op(op) for op in operands]
 
         for rule in self.rules:
-            if rule.check(inst, operands, eval_ops):
+            if rule.check(inst, operands, eval_ops, unsigned):
                 rule.trasform(inst, operands)
                 return True
 
@@ -394,9 +412,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
 
             raise CompilerPanic("unreachable")  # pragma: nocover
 
-        # -1 - x == ~x (definition of two's complement)
-        if opcode == "sub" and _evm_int(eop_1, SIGNED) == -1:
-            return update("not", op_0)  # finalize("not", [args[1]])
+
 
         if opcode == "exp":
             # n ** 0 == 1 (forall n)

From 372317c66fc83d8cc2cb68d0abd0ef6abb4471c0 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Thu, 17 Oct 2024 12:30:33 +0200
Subject: [PATCH 25/39] more rules in different way

---
 vyper/venom/passes/algebraic_optimization.py | 60 +++++++++++---------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index e86d4428eb..c4da61526d 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,5 +1,6 @@
 import operator
 from collections.abc import Callable
+from functools import partial as cur
 
 from vyper.exceptions import CompilerPanic
 from vyper.utils import (
@@ -18,8 +19,6 @@
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
-from functools import partial as cur
-
 SIGNED = False
 UNSIGNED = True
 
@@ -93,22 +92,26 @@ def _flip_comparison_op(opname):
 RuleType = Callable[[IROperand, IRLiteral | None, bool], bool]
 TransformType = Callable[[IRInstruction, list[IROperand]], None]
 
+
 class Rule:
     inst_rule: Callable[[IRInstruction], bool]
     rules: list[RuleType]
     tranformation: TransformType
 
     def __init__(
-        self,
-        inst_rule: Callable[[IRInstruction], bool],
-        rules: list,
-        transformation: TransformType,
+        self, inst_rule: Callable[[IRInstruction], bool], rules: list, transformation: TransformType
     ):
         self.inst_rule = inst_rule
         self.rules = rules
         self.tranformation = transformation
 
-    def check(self, inst: IRInstruction, ops: list[IROperand], eval_ops: list[IRLiteral | None], unsigned: bool) -> bool:
+    def check(
+        self,
+        inst: IRInstruction,
+        ops: list[IROperand],
+        eval_ops: list[IRLiteral | None],
+        unsigned: bool,
+    ) -> bool:
         if not self.inst_rule(inst):
             return False
 
@@ -232,9 +235,9 @@ def inner(inst: IRInstruction, _: list[IROperand]):
         def store(*args: IROperand | int) -> Callable[[IRInstruction, list[IROperand]], None]:
             return update("store", *args)
 
-        def get_op(index: int) -> Callable[[IRInstruction], IROperand]:
-            def inner(inst: IRInstruction):
-                return inst.operands[index]
+        def get_op(index: int) -> Callable[[IRInstruction, list[IROperand]], IROperand]:
+            def inner(inst: IRInstruction, ops: list[IROperand]):
+                return ops[index]
 
             return inner
 
@@ -286,7 +289,7 @@ def chain(*fns) -> TransformType:
             def inner(inst: IRInstruction, ops: list[IROperand]):
                 tmp_op = None
                 for fn in fns:
-                    if tmp_op == None:
+                    if tmp_op is None:
                         tmp_op = fn(inst, ops)
                     else:
                         tmp_op = fn(tmp_op)(inst, ops)
@@ -296,10 +299,26 @@ def inner(inst: IRInstruction, ops: list[IROperand]):
         self.rules = [
             Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
             Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1)),
-            Rule(opset({"mul", "div", "sdiv", "mod", "smod", "and"}), new_rules_eops(0, None), store(0)),
+            Rule(
+                opset({"mul", "div", "sdiv", "mod", "smod", "and"}),
+                new_rules_eops(0, None),
+                store(0),
+            ),
             Rule(opset({"mul", "div", "sdiv"}), new_rules_eops(1, None), store_op(1)),
             # -1 - x == ~x (definition of two's complement)
-            Rule(opset({"sub"}), new_rules_eops(None, -1, unsigned_force=SIGNED), chain(get_op(0), cur(update, "not"))),
+            Rule(
+                opset({"sub"}),
+                new_rules_eops(None, -1, unsigned_force=SIGNED),
+                chain(get_op(0), cur(update, "not")),
+            ),
+            # n ** 0 == 1 (forall n)
+            # 1 ** n == 1
+            Rule(opset({"exp"}), new_rules_eops(0, None), store(1)),
+            Rule(opset({"exp"}), new_rules_eops(None, 1), store(1)),
+            # 0 ** n == (1 if n == 0 else 0)
+            Rule(opset({"exp"}), new_rules_eops(None, 0), chain(get_op(0), cur(update, "iszero"))),
+            # n ** 1 == n
+            Rule(opset({"exp"}), new_rules_eops(1, None), store_op(1)),
         ]
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
@@ -393,7 +412,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
             return store(0)
 
-
         if opcode in {"and", "or", "xor"} and _evm_int(eop_0, SIGNED) == -1:
             assert unsigned == UNSIGNED, "must be unsigned"
             if opcode == "and":
@@ -412,20 +430,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
 
             raise CompilerPanic("unreachable")  # pragma: nocover
 
-
-
-        if opcode == "exp":
-            # n ** 0 == 1 (forall n)
-            # 1 ** n == 1
-            if _evm_int(eop_0) == 0 or _evm_int(eop_1) == 1:
-                return store(1)
-            # 0 ** n == (1 if n == 0 else 0)
-            if _evm_int(eop_1) == 0:
-                return update("iszero", op_0)
-            # n ** 1 == n
-            if _evm_int(eop_0) == 1:
-                return store(op_1)
-
         val = _evm_int(eop_0)
         if (
             opcode in {"mod", "div", "mul"}

From 7e69bf5cfda0818aaa81cd64256b194403a3f964 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Fri, 18 Oct 2024 08:09:09 +0200
Subject: [PATCH 26/39] more rules in different way

---
 vyper/venom/passes/algebraic_optimization.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index c4da61526d..535b025684 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -319,6 +319,8 @@ def inner(inst: IRInstruction, ops: list[IROperand]):
             Rule(opset({"exp"}), new_rules_eops(None, 0), chain(get_op(0), cur(update, "iszero"))),
             # n ** 1 == n
             Rule(opset({"exp"}), new_rules_eops(1, None), store_op(1)),
+            Rule(opset({"eq"}), new_rules_eops(0, None), chain(get_op(1), cur(update, "iszero"))),
+            Rule(opset({"eq"}), new_rules_eops(None, 0), chain(get_op(0), cur(update, "iszero"))),
         ]
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
@@ -457,13 +459,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
 
             raise CompilerPanic("unreachable")  # pragma: no cover
 
-        # the not equal equivalent is not needed
-        if opcode == "eq" and eop_0 == IRLiteral(0):
-            return update("iszero", op_1)
-
-        if opcode == "eq" and eop_1 == IRLiteral(0):
-            return update("iszero", op_0)
-
         if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
             return store(1)
 

From d084c1ff8f99423e0c79f1ac76607dc1944f00be Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Wed, 23 Oct 2024 18:30:29 +0200
Subject: [PATCH 27/39] move some of the binopt into the sccp

---
 tests/unit/compiler/venom/test_sccp.py       |  13 +-
 vyper/venom/__init__.py                      |   5 +-
 vyper/venom/passes/algebraic_optimization.py |   6 +-
 vyper/venom/passes/sccp/sccp.py              | 273 ++++++++++++++++++-
 4 files changed, 283 insertions(+), 14 deletions(-)

diff --git a/tests/unit/compiler/venom/test_sccp.py b/tests/unit/compiler/venom/test_sccp.py
index 375dfd5dac..1b88ff1682 100644
--- a/tests/unit/compiler/venom/test_sccp.py
+++ b/tests/unit/compiler/venom/test_sccp.py
@@ -112,7 +112,7 @@ def test_cont_jump_case():
     op1 = bb.append_instruction("store", 32)
     op2 = bb.append_instruction("store", 64)
     op3 = bb.append_instruction("add", op1, op2)
-    bb.append_instruction("jnz", op3, br1.label, br2.label)
+    bb.append_instruction("jnz", p1, br1.label, br2.label)
 
     br1.append_instruction("add", op3, 10)
     br1.append_instruction("stop")
@@ -123,6 +123,7 @@ def test_cont_jump_case():
     MakeSSA(ac, fn).run_pass()
     sccp = SCCP(ac, fn)
     sccp.run_pass()
+    print(fn)
 
     assert sccp.lattice[IRVariable("%1")] == LatticeEnum.BOTTOM
     assert sccp.lattice[IRVariable("%2")].value == 32
@@ -149,7 +150,7 @@ def test_cont_phi_case():
     op1 = bb.append_instruction("store", 32)
     op2 = bb.append_instruction("store", 64)
     op3 = bb.append_instruction("add", op1, op2)
-    bb.append_instruction("jnz", op3, br1.label, br2.label)
+    bb.append_instruction("jnz", p1, br1.label, br2.label)
 
     op4 = br1.append_instruction("add", op3, 10)
     br1.append_instruction("jmp", join.label)
@@ -160,9 +161,13 @@ def test_cont_phi_case():
 
     ac = IRAnalysesCache(fn)
     MakeSSA(ac, fn).run_pass()
+    print(fn)
     sccp = SCCP(ac, fn)
     sccp.run_pass()
 
+    print(fn)
+    print(sccp.lattice)
+
     assert sccp.lattice[IRVariable("%1")] == LatticeEnum.BOTTOM
     assert sccp.lattice[IRVariable("%2")].value == 32
     assert sccp.lattice[IRVariable("%3")].value == 64
@@ -208,8 +213,8 @@ def test_cont_phi_const_case():
     assert sccp.lattice[IRVariable("%3")].value == 64
     assert sccp.lattice[IRVariable("%4")].value == 96
     assert sccp.lattice[IRVariable("%5", version=1)].value == 106
-    assert sccp.lattice[IRVariable("%5", version=2)].value == 97
-    assert sccp.lattice[IRVariable("%5")].value == 2
+    assert sccp.lattice[IRVariable("%5", version=2)] == LatticeEnum.TOP
+    assert sccp.lattice[IRVariable("%5")].value == 106
 
 
 def test_phi_reduction_after_unreachable_block():
diff --git a/vyper/venom/__init__.py b/vyper/venom/__init__.py
index 311edd3269..6ca8e3de93 100644
--- a/vyper/venom/__init__.py
+++ b/vyper/venom/__init__.py
@@ -51,11 +51,12 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     MakeSSA(ac, fn).run_pass()
     Mem2Var(ac, fn).run_pass()
     MakeSSA(ac, fn).run_pass()
-    AlgebraicOptimizationPass(ac, fn).run_pass()
     SCCP(ac, fn).run_pass()
+    AlgebraicOptimizationPass(ac, fn).run_pass()
     StoreElimination(ac, fn).run_pass()
-    SimplifyCFGPass(ac, fn).run_pass()
     AlgebraicOptimizationPass(ac, fn).run_pass()
+    SimplifyCFGPass(ac, fn).run_pass()
+    # AlgebraicOptimizationPass(ac, fn).run_pass()
     # NOTE: MakeSSA is after algebraic optimization it currently produces
     #       smaller code by adding some redundant phi nodes. This is not a
     #       problem for us, but we need to be aware of it, and should be
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index 535b025684..cc6a37cfa7 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -175,7 +175,8 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain: list[IRInstruction] = []
 
         while True:
-            assert isinstance(op, IRVariable)
+            if not isinstance(op, IRVariable):
+                break
             inst = self.dfg.get_producing_instruction(op)
             if inst is None or inst.opcode != "iszero":
                 break
@@ -352,7 +353,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         op_0 = inst.operands[0]
         eop_0 = self.eval_op(inst.operands[0])
 
-        if opcode == "iszero" and _evm_int(eop_0) is not None:
+        if False and opcode == "iszero" and _evm_int(eop_0) is not None:
             val = _evm_int(eop_0)
             assert val is not None, "Cannot be none"
             val = int(val == 0)
@@ -371,6 +372,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
         ):
             inst.opcode = "offset"
             return True
+        return False
 
         operands = inst.operands
         if inst.is_commutative and eop_1 is not None:
diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 19d373f81a..04cca51e4a 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -4,8 +4,14 @@
 from typing import Union
 
 from vyper.exceptions import CompilerPanic, StaticAssertionException
-from vyper.utils import OrderedSet
-from vyper.venom.analysis import CFGAnalysis, DominatorTreeAnalysis, IRAnalysesCache
+from vyper.utils import OrderedSet, int_bounds, int_log2, is_power_of_two
+from vyper.venom.analysis import (
+    CFGAnalysis,
+    DFGAnalysis,
+    DominatorTreeAnalysis,
+    IRAnalysesCache,
+    VarEquivalenceAnalysis,
+)
 from vyper.venom.basicblock import (
     IRBasicBlock,
     IRInstruction,
@@ -16,7 +22,7 @@
 )
 from vyper.venom.function import IRFunction
 from vyper.venom.passes.base_pass import IRPass
-from vyper.venom.passes.sccp.eval import ARITHMETIC_OPS
+from vyper.venom.passes.sccp.eval import ARITHMETIC_OPS, signed_to_unsigned
 
 
 class LatticeEnum(Enum):
@@ -40,6 +46,20 @@ class FlowWorkItem:
 Lattice = dict[IRVariable, LatticeItem]
 
 
+COMPARISON_OPS = {"gt", "sgt", "ge", "sge", "lt", "slt", "le", "sle"}
+STRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("t")}
+UNSTRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("e")}
+
+
+def _flip_comparison_op(opname):
+    assert opname in COMPARISON_OPS
+    if "g" in opname:
+        return opname.replace("g", "l")
+    if "l" in opname:
+        return opname.replace("l", "g")
+    raise CompilerPanic(f"bad comparison op {opname}")  # pragma: nocover
+
+
 class SCCP(IRPass):
     """
     This class implements the Sparse Conditional Constant Propagation
@@ -67,9 +87,16 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
     def run_pass(self):
         self.fn = self.function
         self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
-        self._compute_uses()
-        self._calculate_sccp(self.fn.entry)
-        self._propagate_constants()
+        while True:
+            self.uses = dict()
+            self._compute_uses()
+            self.lattice = {}
+            self.work_list: list[WorkListItem] = []
+            self._calculate_sccp(self.fn.entry)
+            self._propagate_constants()
+            if not self._algebraic_opt():
+                break
+            self.analyses_cache.invalidate_analysis(DFGAnalysis)
 
         if self.cfg_dirty:
             self.analyses_cache.force_analysis(CFGAnalysis)
@@ -356,6 +383,240 @@ def _fix_phi_inst(self, inst: IRInstruction, cfg_in_labels: OrderedSet):
         inst.operands = operands
         return True
 
+    def _algebraic_opt(self) -> bool:
+        self.eq = self.analyses_cache.force_analysis(VarEquivalenceAnalysis)
+        assert isinstance(self.eq, VarEquivalenceAnalysis)
+        full_change = False
+        while True:
+            change = False
+            for bb in self.function.get_basic_blocks():
+                for inst in bb.instructions:
+                    change |= self._handle_inst_peephole(inst)
+            full_change |= change
+
+            if not change:
+                break
+        return full_change
+
+    def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
+        # print(inst)
+        def update(opcode: str, *args: IROperand | int) -> bool:
+            if inst.opcode == opcode:
+                return False
+            inst.opcode = opcode
+            inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+            return True
+
+        def store(*args: IROperand | int) -> bool:
+            return update("store", *args)
+
+        def add(opcode: str, *args: IROperand | int) -> IRVariable:
+            index = inst.parent.instructions.index(inst)
+            var = inst.parent.parent.get_next_variable()
+            operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+            new_inst = IRInstruction(opcode, operands, output=var)
+            inst.parent.insert_instruction(new_inst, index)
+            # self.dfg.add_output(var, new_inst)
+            # self.dfg.add_use(var, inst)
+            self._get_uses(var).add(inst)
+            return var
+
+        operands = inst.operands
+
+        def match(opcodes: set[str], *ops: int | None):
+            if inst.opcode not in opcodes:
+                return False
+
+            assert len(ops) == len(operands), "wrong number of operands"
+            for cond_op, op in zip(ops, operands):
+                if cond_op is None:
+                    continue
+                if not isinstance(op, IRLiteral):
+                    return False
+                if op.value != cond_op:
+                    return False
+            return True
+
+        def is_lit(index: int) -> bool:
+            if isinstance(operands[index], IRLabel):
+                return False
+            if isinstance(operands[index], IRVariable) and operands[index] not in self.lattice:
+                return False
+            return isinstance(self._eval_from_lattice(operands[index]), IRLiteral)
+
+        def get_lit(index: int) -> IRLiteral:
+            x = self._eval_from_lattice(operands[index])
+            assert isinstance(x, IRLiteral), f"is not literal {x}"
+            return x
+
+        def op_eq(idx_a: int, idx_b: int) -> bool:
+            if is_lit(idx_a) and is_lit(idx_b):
+                return get_lit(idx_a) == get_lit(idx_b)
+            else:
+                assert isinstance(self.eq, VarEquivalenceAnalysis)
+                return self.eq.equivalent(operands[idx_a], operands[idx_b])
+
+        if (
+            inst.opcode == "add"
+            and is_lit(0)
+            and isinstance(get_lit(0), IRLiteral)
+            and isinstance(inst.operands[1], IRLabel)
+        ):
+            inst.opcode = "offset"
+            return True
+
+        if inst.is_commutative and is_lit(1):
+            operands = [operands[1], operands[0]]
+
+        if inst.opcode in ARITHMETIC_OPS and all(is_lit(i) for i in range(len(operands))):
+            oper = ARITHMETIC_OPS[inst.opcode]
+            val = oper([get_lit(i) for i in range(len(operands))])
+            return store(val)
+
+        # return False
+        if inst.opcode == "iszero" and is_lit(0):
+            lit = get_lit(0).value
+            val = int(lit == 0)
+            return store(val)
+
+        if match({"shl", "shr", "sar"}, None, 0):
+            return store(operands[0])
+
+        if match({"add", "sub", "xor", "or"}, 0, None):
+            return store(operands[1])
+
+        if match({"mul", "div", "sdiv", "mod", "smod", "and"}, 0, None):
+            return store(0)
+
+        if match({"mul", "div", "sdiv"}, 1, None):
+            return store(operands[1])
+
+        if match({"sub"}, None, -1):
+            return update("not", operands[0])
+
+        if match({"exp"}, 0, None):
+            return store(1)
+
+        if match({"exp"}, None, 1):
+            return store(1)
+
+        if match({"exp"}, None, 0):
+            return update("iszero", operands[0])
+
+        if match({"exp"}, 1, None):
+            return store(operands[1])
+
+        if match({"eq"}, 0, None):
+            return update("iszero", operands[1])
+
+        if match({"eq"}, None, 0):
+            return update("iszero", operands[0])
+
+        if inst.opcode in {"sub", "xor", "ne"} and op_eq(0, 1):
+            # (x - x) == (x ^ x) == (x != x) == 0
+            return store(0)
+
+        if inst.opcode in STRICT_COMPARISON_OPS and op_eq(0, 1):
+            # (x < x) == (x > x) == 0
+            return store(0)
+
+        if inst.opcode in {"eq"} | UNSTRICT_COMPARISON_OPS and op_eq(0, 1):
+            # (x == x) == (x >= x) == (x <= x) == 1
+            return store(1)
+
+        if match({"mod", "smod"}, 1, None):
+            return store(0)
+
+        if match({"and"}, -1, None):
+            return store(operands[1])
+
+        if match({"xor"}, -1, None):
+            return update("not", operands[1])
+
+        if match({"or"}, -1, None):
+            return store(signed_to_unsigned(-1, 256))
+
+        if inst.opcode in {"mod", "div", "mul"} and is_lit(0) and is_power_of_two(get_lit(0).value):
+            val = get_lit(0).value
+            if inst.opcode == "mod":
+                return update("and", val - 1, operands[1])
+            if inst.opcode == "div":
+                return update("shr", operands[1], int_log2(val))
+            if inst.opcode == "mul":
+                return update("shl", operands[1], int_log2(val))
+
+        if inst.output is None:
+            return False
+
+        assert isinstance(inst.output, IRVariable), "must be variable"
+        uses = self._get_uses(inst.output)
+        is_truthy = all(i.opcode in ("assert", "iszero") for i in uses)
+
+        if is_truthy:
+            if inst.opcode == "eq":
+                # (eq x y) has the same truthyness as (iszero (xor x y))
+                # it also has the same truthyness as (iszero (sub x y)),
+                # but xor is slightly easier to optimize because of being
+                # commutative.
+                # note that (xor (-1) x) has its own rule
+                tmp = add("xor", operands[0], operands[1])
+
+                return update("iszero", tmp)
+            if inst.opcode == "or" and is_lit(0) and get_lit(0).value != 0:
+                return store(1)
+
+        if inst.opcode in COMPARISON_OPS:
+            prefer_strict = not is_truthy
+            opcode = inst.opcode
+            if is_lit(1):  # _is_int(args[0]):
+                opcode = _flip_comparison_op(inst.opcode)
+                operands = [operands[1], operands[0]]
+
+            is_gt = "g" in opcode
+
+            unsigned = "s" not in opcode
+
+            lo, hi = int_bounds(bits=256, signed=not unsigned)
+
+            # for comparison operators, we have three special boundary cases:
+            # almost always, never and almost never.
+            # almost_always is always true for the non-strict ("ge" and co)
+            # comparators. for strict comparators ("gt" and co), almost_always
+            # is true except for one case. never is never true for the strict
+            # comparators. never is almost always false for the non-strict
+            # comparators, except for one case. and almost_never is almost
+            # never true (except one case) for the strict comparators.
+            if is_gt:
+                almost_always, never = lo, hi
+                almost_never = hi - 1
+            else:
+                almost_always, never = hi, lo
+                almost_never = lo + 1
+
+            if is_lit(0) and get_lit(0).value == never:
+                # e.g. gt x MAX_UINT256, slt x MIN_INT256
+                return store(0)
+
+            if is_lit(0) and get_lit(0).value == almost_never:
+                # (lt x 1), (gt x (MAX_UINT256 - 1)), (slt x (MIN_INT256 + 1))
+                return update("eq", operands[1], never)
+
+            # rewrites. in positions where iszero is preferred, (gt x 5) => (ge x 6)
+            if not prefer_strict and is_lit(0) and get_lit(0).value == almost_always:
+                # e.g. gt x 0, slt x MAX_INT256
+                tmp = add("eq", *operands)
+                return update("iszero", tmp)
+
+            # special cases that are not covered by others:
+
+            if opcode == "gt" and is_lit(0) and get_lit(0) == 0:
+                # improve codesize (not gas), and maybe trigger
+                # downstream optimizations
+                tmp = add("iszero", operands[1])
+                return update("iszero", tmp)
+
+        return False
+
 
 def _meet(x: LatticeItem, y: LatticeItem) -> LatticeItem:
     if x == LatticeEnum.TOP:

From b2c8bd2206dde8a83ca47870a199c8b638befb9b Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 09:42:10 +0200
Subject: [PATCH 28/39] fix of the negative number rules

---
 vyper/venom/passes/sccp/sccp.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 04cca51e4a..408a64c154 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -88,6 +88,8 @@ def run_pass(self):
         self.fn = self.function
         self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
         while True:
+            # TODO compute uses and sccp only once
+            # and then modify them on the fly
             self.uses = dict()
             self._compute_uses()
             self.lattice = {}
@@ -98,6 +100,7 @@ def run_pass(self):
                 break
             self.analyses_cache.invalidate_analysis(DFGAnalysis)
 
+
         if self.cfg_dirty:
             self.analyses_cache.force_analysis(CFGAnalysis)
             self._fix_phi_nodes()
@@ -527,13 +530,13 @@ def op_eq(idx_a: int, idx_b: int) -> bool:
         if match({"mod", "smod"}, 1, None):
             return store(0)
 
-        if match({"and"}, -1, None):
+        if match({"and"}, signed_to_unsigned(-1, 256), None):
             return store(operands[1])
 
-        if match({"xor"}, -1, None):
+        if match({"xor"}, signed_to_unsigned(-1, 256), None):
             return update("not", operands[1])
 
-        if match({"or"}, -1, None):
+        if match({"or"}, signed_to_unsigned(-1, 256), None):
             return store(signed_to_unsigned(-1, 256))
 
         if inst.opcode in {"mod", "div", "mul"} and is_lit(0) and is_power_of_two(get_lit(0).value):

From db29ad579a2e82c0ce59d1dfa748cafd33f9d0f4 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 09:52:42 +0200
Subject: [PATCH 29/39] removed the opts from algebraic ops

---
 vyper/venom/__init__.py                      |   1 -
 vyper/venom/passes/algebraic_optimization.py | 477 -------------------
 vyper/venom/passes/sccp/sccp.py              |   2 -
 3 files changed, 480 deletions(-)

diff --git a/vyper/venom/__init__.py b/vyper/venom/__init__.py
index 6ca8e3de93..22fd448209 100644
--- a/vyper/venom/__init__.py
+++ b/vyper/venom/__init__.py
@@ -52,7 +52,6 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     Mem2Var(ac, fn).run_pass()
     MakeSSA(ac, fn).run_pass()
     SCCP(ac, fn).run_pass()
-    AlgebraicOptimizationPass(ac, fn).run_pass()
     StoreElimination(ac, fn).run_pass()
     AlgebraicOptimizationPass(ac, fn).run_pass()
     SimplifyCFGPass(ac, fn).run_pass()
diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index cc6a37cfa7..e22b643a8f 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -3,129 +3,12 @@
 from functools import partial as cur
 
 from vyper.exceptions import CompilerPanic
-from vyper.utils import (
-    evm_div,
-    evm_mod,
-    evm_pow,
-    int_bounds,
-    int_log2,
-    is_power_of_two,
-    signed_to_unsigned,
-    unsigned_to_signed,
-)
 from vyper.venom.analysis.dfg import DFGAnalysis
 from vyper.venom.analysis.equivalent_vars import VarEquivalenceAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
-SIGNED = False
-UNSIGNED = True
-
-COMPARISON_OPS = {"gt", "sgt", "ge", "sge", "lt", "slt", "le", "sle"}
-STRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("t")}
-UNSTRICT_COMPARISON_OPS = {t for t in COMPARISON_OPS if t.endswith("e")}
-
-
-def _wrap256(x, unsigned=UNSIGNED):
-    x %= 2**256
-    # wrap in a signed way.
-    if not unsigned:
-        x = unsigned_to_signed(x, 256, strict=True)
-    return x
-
-
-# unsigned: convert python num to evm unsigned word
-#   e.g. unsigned=True : -1 -> 0xFF...FF
-#        unsigned=False: 0xFF...FF -> -1
-def _evm_int(lit: IRLiteral | None, unsigned: bool = True) -> int | None:
-    if lit is None:
-        return None
-
-    val: int = lit.value
-
-    if unsigned and val < 0:
-        return signed_to_unsigned(val, 256, strict=True)
-    elif not unsigned and val > 2**255 - 1:
-        return unsigned_to_signed(val, 256, strict=True)
-
-    return val
-
-
-def _check_num(val: int) -> bool:
-    if val < -(2**255):
-        return False
-    elif val >= 2**256:
-        return False
-    return True
-
-
-arith = {
-    "add": (operator.add, "+", UNSIGNED),
-    "sub": (operator.sub, "-", UNSIGNED),
-    "mul": (operator.mul, "*", UNSIGNED),
-    "div": (evm_div, "/", UNSIGNED),
-    "sdiv": (evm_div, "/", SIGNED),
-    "mod": (evm_mod, "%", UNSIGNED),
-    "smod": (evm_mod, "%", SIGNED),
-    "exp": (evm_pow, "**", UNSIGNED),
-    "eq": (operator.eq, "==", UNSIGNED),
-    "lt": (operator.lt, "<", UNSIGNED),
-    "gt": (operator.gt, ">", UNSIGNED),
-    "slt": (operator.lt, "<", SIGNED),
-    "sgt": (operator.gt, ">", SIGNED),
-    "or": (operator.or_, "|", UNSIGNED),
-    "and": (operator.and_, "&", UNSIGNED),
-    "xor": (operator.xor, "^", UNSIGNED),
-}
-
-
-def _flip_comparison_op(opname):
-    assert opname in COMPARISON_OPS
-    if "g" in opname:
-        return opname.replace("g", "l")
-    if "l" in opname:
-        return opname.replace("l", "g")
-    raise CompilerPanic(f"bad comparison op {opname}")  # pragma: nocover
-
-
-RuleType = Callable[[IROperand, IRLiteral | None, bool], bool]
-TransformType = Callable[[IRInstruction, list[IROperand]], None]
-
-
-class Rule:
-    inst_rule: Callable[[IRInstruction], bool]
-    rules: list[RuleType]
-    tranformation: TransformType
-
-    def __init__(
-        self, inst_rule: Callable[[IRInstruction], bool], rules: list, transformation: TransformType
-    ):
-        self.inst_rule = inst_rule
-        self.rules = rules
-        self.tranformation = transformation
-
-    def check(
-        self,
-        inst: IRInstruction,
-        ops: list[IROperand],
-        eval_ops: list[IRLiteral | None],
-        unsigned: bool,
-    ) -> bool:
-        if not self.inst_rule(inst):
-            return False
-
-        assert len(ops) == len(self.rules), "wrong number rules"
-        for rule, op, eop in zip(self.rules, ops, eval_ops):
-            if not rule(op, eop, unsigned):
-                return False
-
-        return True
-
-    def trasform(self, inst: IRInstruction, ops: list[IROperand]):
-        self.tranformation(inst, ops)
-
-
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
@@ -135,7 +18,6 @@ class AlgebraicOptimizationPass(IRPass):
     """
 
     dfg: DFGAnalysis
-    rules: list[Rule]
 
     def _optimize_iszero_chains(self) -> None:
         fn = self.function
@@ -186,372 +68,13 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain.reverse()
         return chain
 
-    def eval_op(self, op: IROperand) -> IRLiteral | None:
-        if isinstance(op, IRLiteral):
-            return op
-        elif isinstance(op, IRVariable):
-            next_inst = self.dfg.get_producing_instruction(op)
-            assert next_inst is not None, f"must have producing inst {op}\n{self.dfg._dfg_outputs}"
-            return self.eval(next_inst)
-        else:
-            return None
-
-    def eval(self, inst: IRInstruction) -> IRLiteral | None:
-        if inst.opcode == "store":
-            if isinstance(inst.operands[0], IRLiteral):
-                return inst.operands[0]
-            elif isinstance(inst.operands[0], IRVariable):
-                next_inst = self.dfg.get_producing_instruction(inst.operands[0])
-                assert next_inst is not None, "must have producing inst"
-                return self.eval(next_inst)
-        return None
-
-    def static_eq(
-        self, op_0: IROperand, op_1: IROperand, eop_0: IRLiteral | None, eop_1: IRLiteral | None
-    ) -> bool:
-        return (eop_0 is not None and eop_0 == eop_1) or self.eq_analysis.equivalent(op_0, op_1)
-
-    def _peepholer(self):
-        while True:
-            change = False
-            for bb in self.function.get_basic_blocks():
-                for inst in bb.instructions:
-                    change |= self._handle_inst_peephole(inst)
-
-            if not change:
-                break
-
-    def _create_rules(self):
-        def update(
-            opcode: str, *args: IROperand | int
-        ) -> Callable[[IRInstruction, list[IROperand]], None]:
-            def inner(inst: IRInstruction, _: list[IROperand]):
-                inst.opcode = opcode
-                inst.operands = [
-                    arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args
-                ]
-
-            return inner
-
-        def store(*args: IROperand | int) -> Callable[[IRInstruction, list[IROperand]], None]:
-            return update("store", *args)
-
-        def get_op(index: int) -> Callable[[IRInstruction, list[IROperand]], IROperand]:
-            def inner(inst: IRInstruction, ops: list[IROperand]):
-                return ops[index]
-
-            return inner
-
-        def store_op(index: int) -> Callable[[IRInstruction, list[IROperand]], None]:
-            def inner(inst: IRInstruction, ops: list[IROperand]):
-                inst.opcode = "store"
-                inst.operands = [ops[index]]
-
-            return inner
-
-        def add(opcode: str, *args: IROperand | int) -> Callable[[IRInstruction], IRVariable]:
-            def inner(inst: IRInstruction):
-                index = inst.parent.instructions.index(inst)
-                var = inst.parent.parent.get_next_variable()
-                operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
-                new_inst = IRInstruction(opcode, operands, output=var)
-                inst.parent.insert_instruction(new_inst, index)
-                self.dfg.add_output(var, new_inst)
-                self.dfg.add_use(var, inst)
-                return var
-
-            return inner
-
-        def new_rules_eops(*eops: int | None, unsigned_force: bool | None = None) -> list[RuleType]:
-            rules = []
-
-            def check(eop: int | None) -> RuleType:
-                def inner(_: IROperand, e: IRLiteral | None, unsigned: bool):
-                    if unsigned_force is not None:
-                        unsigned = unsigned_force
-                    return e is not None and _evm_int(e, unsigned) == eop
-
-                return inner
-
-            for eop in eops:
-                if eop is not None:
-                    rules.append(check(eop))
-                else:
-                    rules.append(lambda _a, _b, _c: True)
-            return rules
-
-        def opset(opcodes: set[str]) -> Callable[[IRInstruction], bool]:
-            def inner(inst: IRInstruction) -> bool:
-                return inst.opcode in opcodes
-
-            return inner
-
-        def chain(*fns) -> TransformType:
-            def inner(inst: IRInstruction, ops: list[IROperand]):
-                tmp_op = None
-                for fn in fns:
-                    if tmp_op is None:
-                        tmp_op = fn(inst, ops)
-                    else:
-                        tmp_op = fn(tmp_op)(inst, ops)
-
-            return inner
-
-        self.rules = [
-            Rule(opset({"shl", "shr", "sar"}), new_rules_eops(None, 0), store_op(0)),
-            Rule(opset({"add", "sub", "xor", "or"}), new_rules_eops(0, None), store_op(1)),
-            Rule(
-                opset({"mul", "div", "sdiv", "mod", "smod", "and"}),
-                new_rules_eops(0, None),
-                store(0),
-            ),
-            Rule(opset({"mul", "div", "sdiv"}), new_rules_eops(1, None), store_op(1)),
-            # -1 - x == ~x (definition of two's complement)
-            Rule(
-                opset({"sub"}),
-                new_rules_eops(None, -1, unsigned_force=SIGNED),
-                chain(get_op(0), cur(update, "not")),
-            ),
-            # n ** 0 == 1 (forall n)
-            # 1 ** n == 1
-            Rule(opset({"exp"}), new_rules_eops(0, None), store(1)),
-            Rule(opset({"exp"}), new_rules_eops(None, 1), store(1)),
-            # 0 ** n == (1 if n == 0 else 0)
-            Rule(opset({"exp"}), new_rules_eops(None, 0), chain(get_op(0), cur(update, "iszero"))),
-            # n ** 1 == n
-            Rule(opset({"exp"}), new_rules_eops(1, None), store_op(1)),
-            Rule(opset({"eq"}), new_rules_eops(0, None), chain(get_op(1), cur(update, "iszero"))),
-            Rule(opset({"eq"}), new_rules_eops(None, 0), chain(get_op(0), cur(update, "iszero"))),
-        ]
-
-    def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
-        def update(opcode: str, *args: IROperand | int) -> bool:
-            inst.opcode = opcode
-            inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
-            return True
-
-        def store(*args: IROperand | int) -> bool:
-            return update("store", *args)
-
-        def add(opcode: str, *args: IROperand | int) -> IRVariable:
-            index = inst.parent.instructions.index(inst)
-            var = inst.parent.parent.get_next_variable()
-            operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
-            new_inst = IRInstruction(opcode, operands, output=var)
-            inst.parent.insert_instruction(new_inst, index)
-            self.dfg.add_output(var, new_inst)
-            self.dfg.add_use(var, inst)
-            return var
-
-        if inst.output is None:
-            return False
-
-        if len(inst.operands) < 1:
-            return False
-
-        opcode = inst.opcode
-        op_0 = inst.operands[0]
-        eop_0 = self.eval_op(inst.operands[0])
-
-        if False and opcode == "iszero" and _evm_int(eop_0) is not None:
-            val = _evm_int(eop_0)
-            assert val is not None, "Cannot be none"
-            val = int(val == 0)
-            return store(val)
-
-        if len(inst.operands) != 2:
-            return False
-
-        op_1 = inst.operands[1]
-        eop_1 = self.eval_op(inst.operands[1])
-
-        if (
-            opcode == "add"
-            and isinstance(eop_0, IRLiteral)
-            and isinstance(inst.operands[1], IRLabel)
-        ):
-            inst.opcode = "offset"
-            return True
-        return False
-
-        operands = inst.operands
-        if inst.is_commutative and eop_1 is not None:
-            eop_0, eop_1 = eop_1, eop_0
-            op_0, op_1 = op_1, op_0
-            operands = [operands[1], operands[0]]
-
-        fn, _, unsigned = arith.get(inst.opcode, (lambda x, _: x, "x", False))
-
-        if isinstance(eop_0, IRLiteral) and isinstance(eop_1, IRLiteral) and opcode in arith:
-            assert isinstance(eop_0.value, int), "must be int"
-            assert isinstance(eop_1.value, int), "must be int"
-            a = _evm_int(eop_0, unsigned)
-            b = _evm_int(eop_1, unsigned)
-            res = fn(b, a)
-            res = _wrap256(res, unsigned)
-            if res is not None and _check_num(res):
-                inst.opcode = "store"
-                inst.operands = [IRLiteral(res)]
-                return True
-
-        eval_ops = [self.eval_op(op) for op in operands]
-
-        for rule in self.rules:
-            if rule.check(inst, operands, eval_ops, unsigned):
-                rule.trasform(inst, operands)
-                return True
-
-        if opcode in {"sub", "xor", "ne"} and self.static_eq(op_0, op_1, eop_0, eop_1):
-            # (x - x) == (x ^ x) == (x != x) == 0
-            return store(0)
-
-        if opcode in STRICT_COMPARISON_OPS and self.static_eq(op_0, op_1, eop_0, eop_1):
-            # (x < x) == (x > x) == 0
-            return store(0)
-
-        if opcode in {"eq"} | UNSTRICT_COMPARISON_OPS and self.static_eq(op_0, op_1, eop_0, eop_1):
-            # (x == x) == (x >= x) == (x <= x) == 1
-            return store(1)
-
-        if opcode in {"mod", "smod"} and eop_0 == IRLiteral(1):
-            return store(0)
-
-        if opcode in {"and", "or", "xor"} and _evm_int(eop_0, SIGNED) == -1:
-            assert unsigned == UNSIGNED, "must be unsigned"
-            if opcode == "and":
-                # -1 & x == x
-                return store(op_1)
-
-            if opcode == "xor":
-                # -1 ^ x == ~x
-                return update("not", op_1)
-
-            if opcode == "or":
-                # -1 | x == -1
-                val = _evm_int(IRLiteral(-1), unsigned)
-                assert val is not None
-                return store(val)
-
-            raise CompilerPanic("unreachable")  # pragma: nocover
-
-        val = _evm_int(eop_0)
-        if (
-            opcode in {"mod", "div", "mul"}
-            and isinstance(eop_0, IRLiteral)
-            and val is not None
-            and is_power_of_two(val)
-        ):
-            val_0 = _evm_int(eop_0)
-            assert isinstance(val_0, int)
-            assert unsigned == UNSIGNED, "something's not right."
-            # shave two gas off mod/div/mul for powers of two
-            # x % 2**n == x & (2**n - 1)
-            if opcode == "mod":
-                return update("and", val_0 - 1, op_1)
-
-            if opcode == "div":
-                # x / 2**n == x >> n
-                # recall shr/shl have unintuitive arg order
-                return update("shr", op_1, int_log2(val_0))
-
-            # note: no rule for sdiv since it rounds differently from sar
-            if opcode == "mul":
-                # x * 2**n == x << n
-                return update("shl", op_1, int_log2(val_0))
-
-            raise CompilerPanic("unreachable")  # pragma: no cover
-
-        if opcode == "eq" and self.eq_analysis.equivalent(op_0, op_1):
-            return store(1)
-
-        assert isinstance(inst.output, IRVariable), "must be variable"
-        uses = self.dfg.get_uses(inst.output)
-        is_truthy = all(i.opcode in ("assert", "iszero") for i in uses)
-
-        if is_truthy:
-            if opcode == "eq":
-                assert unsigned == UNSIGNED, "must be unsigned"
-                # (eq x y) has the same truthyness as (iszero (xor x y))
-                # it also has the same truthyness as (iszero (sub x y)),
-                # but xor is slightly easier to optimize because of being
-                # commutative.
-                # note that (xor (-1) x) has its own rule
-                tmp = add("xor", op_0, op_1)
-
-                return update("iszero", tmp)
-
-            # TODO can we do this?
-            # if val == "div":
-            #     return finalize("gt", ["iszero", args])
-
-            if opcode == "or" and isinstance(eop_0, IRLiteral) and eop_0 != 0:
-                # (x | y != 0) for any (y != 0)
-                return store(1)
-
-        if opcode in COMPARISON_OPS:
-            prefer_strict = not is_truthy
-            if isinstance(eop_1, IRLiteral):  # _is_int(args[0]):
-                opcode = _flip_comparison_op(opcode)
-                inst.opcode = opcode
-                eop_0, eop_1 = eop_1, eop_0
-                op_0, op_1 = op_1, op_0
-                inst.operands[0], inst.operands[1] = op_0, op_1
-
-            is_gt = "g" in opcode
-
-            # local version of _evm_int which defaults to the current binop's signedness
-            def _int(x):
-                return _evm_int(x, unsigned=unsigned)
-
-            lo, hi = int_bounds(bits=256, signed=not unsigned)
-
-            # for comparison operators, we have three special boundary cases:
-            # almost always, never and almost never.
-            # almost_always is always true for the non-strict ("ge" and co)
-            # comparators. for strict comparators ("gt" and co), almost_always
-            # is true except for one case. never is never true for the strict
-            # comparators. never is almost always false for the non-strict
-            # comparators, except for one case. and almost_never is almost
-            # never true (except one case) for the strict comparators.
-            if is_gt:
-                almost_always, never = lo, hi
-                almost_never = hi - 1
-            else:
-                almost_always, never = hi, lo
-                almost_never = lo + 1
-
-            if _int(eop_0) == never:
-                # e.g. gt x MAX_UINT256, slt x MIN_INT256
-                return store(0)
-
-            if _int(eop_0) == almost_never:
-                # (lt x 1), (gt x (MAX_UINT256 - 1)), (slt x (MIN_INT256 + 1))
-                return update("eq", op_1, never)
-
-            # rewrites. in positions where iszero is preferred, (gt x 5) => (ge x 6)
-            if not prefer_strict and _int(eop_0) == almost_always:
-                # e.g. gt x 0, slt x MAX_INT256
-                tmp = add("eq", op_0, op_1)
-                return update("iszero", tmp)
-
-            # special cases that are not covered by others:
-
-            if opcode == "gt" and eop_0 == 0:
-                # improve codesize (not gas), and maybe trigger
-                # downstream optimizations
-                tmp = add("iszero", op_1)
-                return update("iszero", tmp)
-        return False
-
     def run_pass(self):
         dfg = self.analyses_cache.request_analysis(DFGAnalysis)
         assert isinstance(dfg, DFGAnalysis)
         self.dfg = dfg
 
         self.eq_analysis = self.analyses_cache.request_analysis(VarEquivalenceAnalysis)
-        self._create_rules()
 
-        self._peepholer()
         self._optimize_iszero_chains()
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 408a64c154..08b9da1506 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -402,7 +402,6 @@ def _algebraic_opt(self) -> bool:
         return full_change
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
-        # print(inst)
         def update(opcode: str, *args: IROperand | int) -> bool:
             if inst.opcode == opcode:
                 return False
@@ -476,7 +475,6 @@ def op_eq(idx_a: int, idx_b: int) -> bool:
             val = oper([get_lit(i) for i in range(len(operands))])
             return store(val)
 
-        # return False
         if inst.opcode == "iszero" and is_lit(0):
             lit = get_lit(0).value
             val = int(lit == 0)

From 96554602f743df3ff30141714de45f08d3776ecc Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 10:07:18 +0200
Subject: [PATCH 30/39] lint + cleanup

---
 vyper/venom/passes/algebraic_optimization.py | 8 ++------
 vyper/venom/passes/sccp/sccp.py              | 1 -
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/vyper/venom/passes/algebraic_optimization.py b/vyper/venom/passes/algebraic_optimization.py
index e22b643a8f..fb66aaafda 100644
--- a/vyper/venom/passes/algebraic_optimization.py
+++ b/vyper/venom/passes/algebraic_optimization.py
@@ -1,14 +1,10 @@
-import operator
-from collections.abc import Callable
-from functools import partial as cur
-
-from vyper.exceptions import CompilerPanic
 from vyper.venom.analysis.dfg import DFGAnalysis
 from vyper.venom.analysis.equivalent_vars import VarEquivalenceAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
-from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand, IRVariable
+from vyper.venom.basicblock import IRInstruction, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
+
 class AlgebraicOptimizationPass(IRPass):
     """
     This pass reduces algebraic evaluatable expressions.
diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 08b9da1506..992ab8e6d0 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -100,7 +100,6 @@ def run_pass(self):
                 break
             self.analyses_cache.invalidate_analysis(DFGAnalysis)
 
-
         if self.cfg_dirty:
             self.analyses_cache.force_analysis(CFGAnalysis)
             self._fix_phi_nodes()

From 4b0ec3b8f5e97fa617c9e6eb2609021344859057 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 10:16:50 +0200
Subject: [PATCH 31/39] moved test for offsets from algebraic optimizer to sccp
 test

---
 .../venom/test_algebraic_optimizer.py         | 51 -------------------
 tests/unit/compiler/venom/test_sccp.py        | 51 +++++++++++++++++++
 2 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/tests/unit/compiler/venom/test_algebraic_optimizer.py b/tests/unit/compiler/venom/test_algebraic_optimizer.py
index 00ccb0684a..d7bfd634dc 100644
--- a/tests/unit/compiler/venom/test_algebraic_optimizer.py
+++ b/tests/unit/compiler/venom/test_algebraic_optimizer.py
@@ -128,57 +128,6 @@ def test_interleaved_case(interleave_point):
         assert bb.instructions[-1].operands[0] == op3
 
 
-def test_offsets():
-    ctx = IRContext()
-    fn = ctx.create_function("_global")
-
-    bb = fn.get_basic_block()
-
-    br1 = IRBasicBlock(IRLabel("then"), fn)
-    fn.append_basic_block(br1)
-    br2 = IRBasicBlock(IRLabel("else"), fn)
-    fn.append_basic_block(br2)
-
-    p1 = bb.append_instruction("param")
-    op1 = bb.append_instruction("store", 32)
-    op2 = bb.append_instruction("add", 0, IRLabel("mem"))
-    op3 = bb.append_instruction("store", 64)
-    bb.append_instruction("dloadbytes", op1, op2, op3)
-    op5 = bb.append_instruction("mload", op3)
-    op6 = bb.append_instruction("iszero", op5)
-    bb.append_instruction("jnz", op6, br1.label, br2.label)
-
-    op01 = br1.append_instruction("store", 32)
-    op02 = br1.append_instruction("add", 0, IRLabel("mem"))
-    op03 = br1.append_instruction("store", 64)
-    br1.append_instruction("dloadbytes", op01, op02, op03)
-    op05 = br1.append_instruction("mload", op03)
-    op06 = br1.append_instruction("iszero", op05)
-    br1.append_instruction("return", p1, op06)
-
-    op11 = br2.append_instruction("store", 32)
-    op12 = br2.append_instruction("add", 0, IRLabel("mem"))
-    op13 = br2.append_instruction("store", 64)
-    br2.append_instruction("dloadbytes", op11, op12, op13)
-    op15 = br2.append_instruction("mload", op13)
-    op16 = br2.append_instruction("iszero", op15)
-    br2.append_instruction("return", p1, op16)
-
-    ac = IRAnalysesCache(fn)
-    MakeSSA(ac, fn).run_pass()
-    AlgebraicOptimizationPass(ac, fn).run_pass()
-    RemoveUnusedVariablesPass(ac, fn).run_pass()
-
-    offset_count = 0
-    for bb in fn.get_basic_blocks():
-        for instruction in bb.instructions:
-            assert instruction.opcode != "add"
-            if instruction.opcode == "offset":
-                offset_count += 1
-
-    assert offset_count == 3
-
-
 # Test the case of https://github.com/vyperlang/vyper/issues/4288
 def test_ssa_after_algebraic_optimization():
     code = """
diff --git a/tests/unit/compiler/venom/test_sccp.py b/tests/unit/compiler/venom/test_sccp.py
index 1b88ff1682..727a7fbc95 100644
--- a/tests/unit/compiler/venom/test_sccp.py
+++ b/tests/unit/compiler/venom/test_sccp.py
@@ -246,3 +246,54 @@ def test_phi_reduction_after_unreachable_block():
     assert join.instructions[0].operands == [op1]
 
     assert join.instructions[1].opcode == "stop"
+
+
+def test_sccp_offsets_opt():
+    ctx = IRContext()
+    fn = ctx.create_function("_global")
+
+    bb = fn.get_basic_block()
+
+    br1 = IRBasicBlock(IRLabel("then"), fn)
+    fn.append_basic_block(br1)
+    br2 = IRBasicBlock(IRLabel("else"), fn)
+    fn.append_basic_block(br2)
+
+    p1 = bb.append_instruction("param")
+    op1 = bb.append_instruction("store", 32)
+    op2 = bb.append_instruction("add", 0, IRLabel("mem"))
+    op3 = bb.append_instruction("store", 64)
+    bb.append_instruction("dloadbytes", op1, op2, op3)
+    op5 = bb.append_instruction("mload", op3)
+    op6 = bb.append_instruction("iszero", op5)
+    bb.append_instruction("jnz", op6, br1.label, br2.label)
+
+    op01 = br1.append_instruction("store", 32)
+    op02 = br1.append_instruction("add", 0, IRLabel("mem"))
+    op03 = br1.append_instruction("store", 64)
+    br1.append_instruction("dloadbytes", op01, op02, op03)
+    op05 = br1.append_instruction("mload", op03)
+    op06 = br1.append_instruction("iszero", op05)
+    br1.append_instruction("return", p1, op06)
+
+    op11 = br2.append_instruction("store", 32)
+    op12 = br2.append_instruction("add", 0, IRLabel("mem"))
+    op13 = br2.append_instruction("store", 64)
+    br2.append_instruction("dloadbytes", op11, op12, op13)
+    op15 = br2.append_instruction("mload", op13)
+    op16 = br2.append_instruction("iszero", op15)
+    br2.append_instruction("return", p1, op16)
+
+    ac = IRAnalysesCache(fn)
+    MakeSSA(ac, fn).run_pass()
+    SCCP(ac, fn).run_pass()
+    # RemoveUnusedVariablesPass(ac, fn).run_pass()
+
+    offset_count = 0
+    for bb in fn.get_basic_blocks():
+        for instruction in bb.instructions:
+            assert instruction.opcode != "add"
+            if instruction.opcode == "offset":
+                offset_count += 1
+
+    assert offset_count == 3

From 8989fd905d6b29f7b149bb6a860d025cad98fd4c Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 11:23:13 +0200
Subject: [PATCH 32/39] added jnz to truthy

---
 vyper/venom/passes/sccp/sccp.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 992ab8e6d0..204c74f047 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -550,7 +550,7 @@ def op_eq(idx_a: int, idx_b: int) -> bool:
 
         assert isinstance(inst.output, IRVariable), "must be variable"
         uses = self._get_uses(inst.output)
-        is_truthy = all(i.opcode in ("assert", "iszero") for i in uses)
+        is_truthy = all(i.opcode in ("assert", "iszero", "jnz") for i in uses)
 
         if is_truthy:
             if inst.opcode == "eq":

From 9603690b49bae380cdbf33c9c95c38398db88603 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 11:46:49 +0200
Subject: [PATCH 33/39] uses calc on fly

---
 vyper/venom/passes/sccp/sccp.py | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 204c74f047..df32d7fa52 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -83,15 +83,15 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
         self.lattice = {}
         self.work_list: list[WorkListItem] = []
         self.cfg_dirty = False
+        self.uses = dict()
 
     def run_pass(self):
         self.fn = self.function
         self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
+        self._compute_uses()
         while True:
             # TODO compute uses and sccp only once
             # and then modify them on the fly
-            self.uses = dict()
-            self._compute_uses()
             self.lattice = {}
             self.work_list: list[WorkListItem] = []
             self._calculate_sccp(self.fn.entry)
@@ -330,6 +330,8 @@ def _replace_constants(self, inst: IRInstruction):
                     target = inst.operands[2]
                 else:
                     target = inst.operands[1]
+                if isinstance(inst.operands[0], IRVariable):
+                    self._get_uses(inst.operands[0]).remove(inst)
                 inst.opcode = "jmp"
                 inst.operands = [target]
 
@@ -404,8 +406,17 @@ def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
             if inst.opcode == opcode:
                 return False
+
+            for op in inst.operands:
+                if isinstance(op, IRVariable):
+                    self._get_uses(op).remove(inst)
             inst.opcode = opcode
             inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
+
+            for op in inst.operands:
+                if isinstance(op, IRVariable):
+                    self._get_uses(op).add(inst)
+
             return True
 
         def store(*args: IROperand | int) -> bool:

From 7bf4667c97d52f398d10b9026080b71f4b5c2235 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 13:07:29 +0200
Subject: [PATCH 34/39] uses calc on fly fix

---
 vyper/venom/passes/sccp/sccp.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index df32d7fa52..a84a49c210 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -93,6 +93,8 @@ def run_pass(self):
             # TODO compute uses and sccp only once
             # and then modify them on the fly
             self.lattice = {}
+            #self.uses = dict()
+            #self._compute_uses()
             self.work_list: list[WorkListItem] = []
             self._calculate_sccp(self.fn.entry)
             self._propagate_constants()
@@ -409,7 +411,9 @@ def update(opcode: str, *args: IROperand | int) -> bool:
 
             for op in inst.operands:
                 if isinstance(op, IRVariable):
-                    self._get_uses(op).remove(inst)
+                    uses = self._get_uses(op)
+                    if inst in uses:
+                        uses.remove(inst)
             inst.opcode = opcode
             inst.operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
 
@@ -428,6 +432,9 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
             new_inst = IRInstruction(opcode, operands, output=var)
             inst.parent.insert_instruction(new_inst, index)
+            for op in new_inst.operands:
+                if isinstance(op, IRVariable):
+                    self._get_uses(op).add(new_inst)
             # self.dfg.add_output(var, new_inst)
             # self.dfg.add_use(var, inst)
             self._get_uses(var).add(inst)

From 22df05298612bfd5b476641a406c552158c946ef Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Thu, 24 Oct 2024 14:22:56 +0200
Subject: [PATCH 35/39] sccp reduced recalc

---
 tests/unit/compiler/venom/test_sccp.py |  4 ++--
 vyper/venom/passes/sccp/sccp.py        | 14 +++++++++++---
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/tests/unit/compiler/venom/test_sccp.py b/tests/unit/compiler/venom/test_sccp.py
index 727a7fbc95..d27a9967a0 100644
--- a/tests/unit/compiler/venom/test_sccp.py
+++ b/tests/unit/compiler/venom/test_sccp.py
@@ -213,8 +213,8 @@ def test_cont_phi_const_case():
     assert sccp.lattice[IRVariable("%3")].value == 64
     assert sccp.lattice[IRVariable("%4")].value == 96
     assert sccp.lattice[IRVariable("%5", version=1)].value == 106
-    assert sccp.lattice[IRVariable("%5", version=2)] == LatticeEnum.TOP
-    assert sccp.lattice[IRVariable("%5")].value == 106
+    assert sccp.lattice[IRVariable("%5", version=2)].value == 97
+    assert sccp.lattice[IRVariable("%5")] == LatticeEnum.BOTTOM
 
 
 def test_phi_reduction_after_unreachable_block():
diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index a84a49c210..4eea731738 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -89,14 +89,17 @@ def run_pass(self):
         self.fn = self.function
         self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
         self._compute_uses()
+        self.recalc_sccp = True
         while True:
             # TODO compute uses and sccp only once
             # and then modify them on the fly
-            self.lattice = {}
             #self.uses = dict()
             #self._compute_uses()
-            self.work_list: list[WorkListItem] = []
-            self._calculate_sccp(self.fn.entry)
+            if self.recalc_sccp:
+                self.recalc_sccp = False
+                self.lattice = {}
+                self.work_list: list[WorkListItem] = []
+                self._calculate_sccp(self.fn.entry)
             self._propagate_constants()
             if not self._algebraic_opt():
                 break
@@ -438,6 +441,7 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             # self.dfg.add_output(var, new_inst)
             # self.dfg.add_use(var, inst)
             self._get_uses(var).add(inst)
+            self._set_lattice(var, LatticeEnum.BOTTOM)
             return var
 
         operands = inst.operands
@@ -612,15 +616,18 @@ def op_eq(idx_a: int, idx_b: int) -> bool:
                 almost_never = lo + 1
 
             if is_lit(0) and get_lit(0).value == never:
+                self.recalc_sccp = True
                 # e.g. gt x MAX_UINT256, slt x MIN_INT256
                 return store(0)
 
             if is_lit(0) and get_lit(0).value == almost_never:
+                self.recalc_sccp = True
                 # (lt x 1), (gt x (MAX_UINT256 - 1)), (slt x (MIN_INT256 + 1))
                 return update("eq", operands[1], never)
 
             # rewrites. in positions where iszero is preferred, (gt x 5) => (ge x 6)
             if not prefer_strict and is_lit(0) and get_lit(0).value == almost_always:
+                self.recalc_sccp = True
                 # e.g. gt x 0, slt x MAX_INT256
                 tmp = add("eq", *operands)
                 return update("iszero", tmp)
@@ -628,6 +635,7 @@ def op_eq(idx_a: int, idx_b: int) -> bool:
             # special cases that are not covered by others:
 
             if opcode == "gt" and is_lit(0) and get_lit(0) == 0:
+                self.recalc_sccp = True
                 # improve codesize (not gas), and maybe trigger
                 # downstream optimizations
                 tmp = add("iszero", operands[1])

From 53d412273eb4c8f9e6d4e064b54de0816bf06e73 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Fri, 25 Oct 2024 11:16:22 +0200
Subject: [PATCH 36/39] used dfg instead of the different uses computation

---
 vyper/venom/analysis/dfg.py     | 18 ++++++++++--------
 vyper/venom/passes/sccp/sccp.py | 29 +++++------------------------
 2 files changed, 15 insertions(+), 32 deletions(-)

diff --git a/vyper/venom/analysis/dfg.py b/vyper/venom/analysis/dfg.py
index 7cea4b3e00..45ecd8c829 100644
--- a/vyper/venom/analysis/dfg.py
+++ b/vyper/venom/analysis/dfg.py
@@ -1,5 +1,6 @@
 from typing import Optional
 
+from vyper.utils import OrderedSet
 from vyper.venom.analysis.analysis import IRAnalysesCache, IRAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRInstruction, IRVariable
@@ -7,7 +8,7 @@
 
 
 class DFGAnalysis(IRAnalysis):
-    _dfg_inputs: dict[IRVariable, list[IRInstruction]]
+    _dfg_inputs: dict[IRVariable, OrderedSet[IRInstruction]]
     _dfg_outputs: dict[IRVariable, IRInstruction]
 
     def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
@@ -16,23 +17,23 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
         self._dfg_outputs = dict()
 
     # return uses of a given variable
-    def get_uses(self, op: IRVariable) -> list[IRInstruction]:
-        return self._dfg_inputs.get(op, [])
+    def get_uses(self, op: IRVariable) -> OrderedSet[IRInstruction]:
+        return self._dfg_inputs.get(op, OrderedSet())
 
     # the instruction which produces this variable.
     def get_producing_instruction(self, op: IRVariable) -> Optional[IRInstruction]:
         return self._dfg_outputs.get(op)
 
     def add_use(self, op: IRVariable, inst: IRInstruction):
-        uses = self._dfg_inputs.setdefault(op, [])
-        uses.append(inst)
+        uses = self._dfg_inputs.setdefault(op, OrderedSet())
+        uses.add(inst)
 
     def add_output(self, op: IRVariable, inst: IRInstruction):
         assert op not in self._dfg_outputs
         self._dfg_outputs[op] = inst
 
     def remove_use(self, op: IRVariable, inst: IRInstruction):
-        uses = self._dfg_inputs.get(op, [])
+        uses: OrderedSet[IRInstruction] = self._dfg_inputs.get(op, OrderedSet())
         uses.remove(inst)
 
     @property
@@ -52,10 +53,11 @@ def analyze(self):
                 res = inst.get_outputs()
 
                 for op in operands:
-                    inputs = self._dfg_inputs.setdefault(op, [])
-                    inputs.append(inst)
+                    inputs = self._dfg_inputs.setdefault(op, OrderedSet())
+                    inputs.add(inst)
 
                 for op in res:  # type: ignore
+                    assert isinstance(op, IRVariable)
                     self._dfg_outputs[op] = inst
 
     def as_graph(self) -> str:
diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 4eea731738..f507196d1b 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -71,7 +71,7 @@ class SCCP(IRPass):
 
     fn: IRFunction
     dom: DominatorTreeAnalysis
-    uses: dict[IRVariable, OrderedSet[IRInstruction]]
+    dfg: DFGAnalysis
     lattice: Lattice
     work_list: list[WorkListItem]
     cfg_in_exec: dict[IRBasicBlock, OrderedSet[IRBasicBlock]]
@@ -83,18 +83,15 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
         self.lattice = {}
         self.work_list: list[WorkListItem] = []
         self.cfg_dirty = False
-        self.uses = dict()
 
     def run_pass(self):
         self.fn = self.function
         self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
-        self._compute_uses()
+        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
         self.recalc_sccp = True
         while True:
             # TODO compute uses and sccp only once
             # and then modify them on the fly
-            #self.uses = dict()
-            #self._compute_uses()
             if self.recalc_sccp:
                 self.recalc_sccp = False
                 self.lattice = {}
@@ -103,7 +100,6 @@ def run_pass(self):
             self._propagate_constants()
             if not self._algebraic_opt():
                 break
-            self.analyses_cache.invalidate_analysis(DFGAnalysis)
 
         if self.cfg_dirty:
             self.analyses_cache.force_analysis(CFGAnalysis)
@@ -126,7 +122,7 @@ def _calculate_sccp(self, entry: IRBasicBlock):
         self.work_list.append(FlowWorkItem(dummy, entry))
 
         # Initialize the lattice with TOP values for all variables
-        for v in self.uses.keys():
+        for v in self.dfg._dfg_outputs:
             self.lattice[v] = LatticeEnum.TOP
 
         # Iterate over the work list until it is empty
@@ -295,21 +291,8 @@ def _add_ssa_work_items(self, inst: IRInstruction):
         for target_inst in self._get_uses(inst.output):  # type: ignore
             self.work_list.append(SSAWorkListItem(target_inst))
 
-    def _compute_uses(self):
-        """
-        This method computes the uses for each variable in the IR.
-        It iterates over the dominator tree and collects all the
-        instructions that use each variable.
-        """
-        self.uses = {}
-        for bb in self.dom.dfs_walk:
-            for var, insts in bb.get_uses().items():
-                self._get_uses(var).update(insts)
-
-    def _get_uses(self, var: IRVariable):
-        if var not in self.uses:
-            self.uses[var] = OrderedSet()
-        return self.uses[var]
+    def _get_uses(self, var: IRVariable) -> OrderedSet:
+        return self.dfg.get_uses(var)
 
     def _propagate_constants(self):
         """
@@ -438,8 +421,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
             for op in new_inst.operands:
                 if isinstance(op, IRVariable):
                     self._get_uses(op).add(new_inst)
-            # self.dfg.add_output(var, new_inst)
-            # self.dfg.add_use(var, inst)
             self._get_uses(var).add(inst)
             self._set_lattice(var, LatticeEnum.BOTTOM)
             return var

From 137cb1e67ce69edfa7069a194d7424cbdae50016 Mon Sep 17 00:00:00 2001
From: Hodan <plodeada@fit.cvut.cz>
Date: Mon, 28 Oct 2024 20:35:50 +0100
Subject: [PATCH 37/39] dfg calculation on fly and assert weird behaviour

---
 vyper/venom/passes/sccp/sccp.py | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 48c4783379..9ceca94274 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -86,17 +86,15 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
 
     def run_pass(self):
         self.fn = self.function
-        self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)
-        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
+        self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis) # type: ignore
+        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis) # type: ignore
         self.recalc_sccp = True
+        self.lattice = {}
+        self.work_list: list[WorkListItem] = []
+        self._calculate_sccp(self.fn.entry)
         while True:
             # TODO compute uses and sccp only once
             # and then modify them on the fly
-            if self.recalc_sccp:
-                self.recalc_sccp = False
-                self.lattice = {}
-                self.work_list: list[WorkListItem] = []
-                self._calculate_sccp(self.fn.entry)
             self._propagate_constants()
             if not self._algebraic_opt():
                 break
@@ -105,7 +103,7 @@ def run_pass(self):
             self.analyses_cache.force_analysis(CFGAnalysis)
             self._fix_phi_nodes()
 
-        self.analyses_cache.invalidate_analysis(DFGAnalysis)
+        #self.analyses_cache.invalidate_analysis(DFGAnalysis)
 
     def _calculate_sccp(self, entry: IRBasicBlock):
         """
@@ -394,6 +392,7 @@ def _algebraic_opt(self) -> bool:
 
     def _handle_inst_peephole(self, inst: IRInstruction) -> bool:
         def update(opcode: str, *args: IROperand | int) -> bool:
+            assert opcode != "phi"
             if inst.opcode == opcode:
                 return False
 
@@ -409,12 +408,15 @@ def update(opcode: str, *args: IROperand | int) -> bool:
                 if isinstance(op, IRVariable):
                     self._get_uses(op).add(inst)
 
+            self._visit_expr(inst)
+        
             return True
 
         def store(*args: IROperand | int) -> bool:
             return update("store", *args)
 
         def add(opcode: str, *args: IROperand | int) -> IRVariable:
+            assert opcode != "phi"
             index = inst.parent.instructions.index(inst)
             var = inst.parent.parent.get_next_variable()
             operands = [arg if isinstance(arg, IROperand) else IRLiteral(arg) for arg in args]
@@ -424,7 +426,8 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                 if isinstance(op, IRVariable):
                     self._get_uses(op).add(new_inst)
             self._get_uses(var).add(inst)
-            self._set_lattice(var, LatticeEnum.BOTTOM)
+            self._visit_expr(new_inst)
+            #self._set_lattice(var, LatticeEnum.BOTTOM)
             return var
 
         operands = inst.operands

From 1e0aa69f137a3c83f92220ee834ffe18a6b2fcd3 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Tue, 29 Oct 2024 09:32:36 +0100
Subject: [PATCH 38/39] sccp static assert fix

---
 vyper/venom/passes/sccp/sccp.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 9ceca94274..0d7a6f26db 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -300,6 +300,7 @@ def _propagate_constants(self):
         with their actual values. It also replaces conditional jumps
         with unconditional jumps if the condition is a constant value.
         """
+        self.function._compute_reachability()
         for bb in self.dom.dfs_walk:
             for inst in bb.instructions:
                 self._replace_constants(inst)
@@ -331,7 +332,7 @@ def _replace_constants(self, inst: IRInstruction):
             if isinstance(lat, IRLiteral):
                 if lat.value > 0:
                     inst.opcode = "nop"
-                else:
+                elif inst.parent.is_reachable:
                     raise StaticAssertionException(
                         f"assertion found to fail at compile time ({inst.error_msg}).",
                         inst.get_ast_source(),

From b99ea0e00d2a4162aa2a0f0b7e563a11d3e09f80 Mon Sep 17 00:00:00 2001
From: plodeada <plodeada@fit.cvut.cz>
Date: Tue, 29 Oct 2024 09:42:37 +0100
Subject: [PATCH 39/39] lint and comments

---
 vyper/venom/passes/sccp/sccp.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/vyper/venom/passes/sccp/sccp.py b/vyper/venom/passes/sccp/sccp.py
index 0d7a6f26db..234b1d44eb 100644
--- a/vyper/venom/passes/sccp/sccp.py
+++ b/vyper/venom/passes/sccp/sccp.py
@@ -86,8 +86,8 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
 
     def run_pass(self):
         self.fn = self.function
-        self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis) # type: ignore
-        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis) # type: ignore
+        self.dom = self.analyses_cache.request_analysis(DominatorTreeAnalysis)  # type: ignore
+        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)  # type: ignore
         self.recalc_sccp = True
         self.lattice = {}
         self.work_list: list[WorkListItem] = []
@@ -103,8 +103,6 @@ def run_pass(self):
             self.analyses_cache.force_analysis(CFGAnalysis)
             self._fix_phi_nodes()
 
-        #self.analyses_cache.invalidate_analysis(DFGAnalysis)
-
     def _calculate_sccp(self, entry: IRBasicBlock):
         """
         This method is the main entry point for the SCCP algorithm. It
@@ -300,6 +298,11 @@ def _propagate_constants(self):
         with their actual values. It also replaces conditional jumps
         with unconditional jumps if the condition is a constant value.
         """
+        # the reachability is needed because of the
+        # unreachable assert that would be statically
+        # found to be false, but we still assume that
+        # the unreachable basic block will be handled
+        # with all other aspects in sccp test
         self.function._compute_reachability()
         for bb in self.dom.dfs_walk:
             for inst in bb.instructions:
@@ -410,7 +413,7 @@ def update(opcode: str, *args: IROperand | int) -> bool:
                     self._get_uses(op).add(inst)
 
             self._visit_expr(inst)
-        
+
             return True
 
         def store(*args: IROperand | int) -> bool:
@@ -428,7 +431,6 @@ def add(opcode: str, *args: IROperand | int) -> IRVariable:
                     self._get_uses(op).add(new_inst)
             self._get_uses(var).add(inst)
             self._visit_expr(new_inst)
-            #self._set_lattice(var, LatticeEnum.BOTTOM)
             return var
 
         operands = inst.operands