feat[venom]: basic check

tests/unit/compiler/venom/test_venom_parser.py

@@ -0,0 +1,70 @@
+from tests.venom_utils import parse_from_basic_block
+from vyper.venom.check_venom import VenomSemanticErrorType, check_venom
+
+
+def test_venom_parser():
+    code = """
+    main:
+        %1 = 1
+        ret %1
+    """
+
+    ctx = parse_from_basic_block(code)
+    errors = check_venom(ctx)
+
+    assert errors == []
+
+
+def test_venom_parser_not_terminated():
+    code = """
+    bb0:
+        %1 = 1
+    bb1:
+        jmp @bb0
+    bb2:
+        stop
+    bb3:
+        calldataload 10, 20, 30
+    """
+
+    ctx = parse_from_basic_block(code)
+    errors = check_venom(ctx)
+
+    all(e.error_type == VenomSemanticErrorType.NotTerminatedBasicBlock for e in errors)
+    assert len(errors) == 2
+    assert list(e.metadata.label.name for e in errors) == ["bb0", "bb3"]
+
+
+def test_venom_parser_nonexistant_var():
+    code = """
+    main:
+        ret %1
+    """
+
+    ctx = parse_from_basic_block(code)
+    errors = check_venom(ctx)
+
+    assert len(errors) == 1
+
+
+def test_venom_parser_nonexistant_var2():
+    code = """
+    main:
+        %par = param
+        %1 = 1
+        jnz %par, @br1, @br2
+    br1:
+        %2 = 2
+        jmp @join
+    br2:
+        %3 = 3
+        jmp @join
+    join:
+        ret %1, %2, %3
+    """
+
+    ctx = parse_from_basic_block(code)
+    errors = check_venom(ctx)
+
+    assert len(errors) == 2
+    assert {e.metadata.name for e in errors} == {"%2", "%3"}

vyper/venom/__init__.py

@@ -5,7 +5,9 @@
 
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.settings import OptimizationLevel, Settings
+from vyper.exceptions import CompilerPanic
 from vyper.venom.analysis.analysis import IRAnalysesCache
+from vyper.venom.check_venom import check_venom_fn
 from vyper.venom.context import IRContext
 from vyper.venom.function import IRFunction
 from vyper.venom.ir_node_to_venom import ir_node_to_venom
@@ -54,6 +56,12 @@
     FloatAllocas(ac, fn).run_pass()
 
     SimplifyCFGPass(ac, fn).run_pass()
+
+    errors = check_venom_fn(fn)
+    if errors != []:  # pragma: nocover
+        print(errors)
+        raise CompilerPanic("venom sematic errors" + str(errors))
+
     MakeSSA(ac, fn).run_pass()
     # run algebraic opts before mem2var to reduce some pointer arithmetic
     AlgebraicOptimizationPass(ac, fn).run_pass()
@@ -87,7 +95,7 @@
 
     StoreExpansionPass(ac, fn).run_pass()
 
-    if optimize == OptimizationLevel.CODESIZE:
+    if optimize == OptimizationLevel.CODESIZE:https://www.youtube.com/watch?v=KuhCoUfMWx0
         ReduceLiteralsCodesize(ac, fn).run_pass()
 
     DFTPass(ac, fn).run_pass()

vyper/venom/check_venom.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from vyper.exceptions import CompilerPanic
+from vyper.venom.analysis import IRAnalysesCache, LivenessAnalysis
+from vyper.venom.basicblock import IRBasicBlock
+from vyper.venom.context import IRContext
+from vyper.venom.function import IRFunction
+
+
+class VenomSemanticErrorType(Enum):
+    NotTerminatedBasicBlock = 1
+    NotDefinedVar = 2
+
+    def __repr__(self) -> str:
+        if self == VenomSemanticErrorType.NotTerminatedBasicBlock:
+            return "basic block does not terminate"
+        elif self == VenomSemanticErrorType.NotDefinedVar:
+            return "var not defined"
+        else:
+            raise CompilerPanic("unknown venom semantic error")
+
+
+@dataclass
+class VenomSemanticError:
+    error_type: VenomSemanticErrorType
+    metadata: Any
+
+
+def check_venom_fn(fn: IRFunction) -> list[VenomSemanticError]:
+    errors = []
+
+    # check that all the bbs are terminated
+    for bb in fn.get_basic_blocks():
+        if not bb.is_terminated:
+            errors.append(VenomSemanticError(VenomSemanticErrorType.NotTerminatedBasicBlock, bb))
+
+    if errors != []:
+        return errors
+
+    ac = IRAnalysesCache(fn)
+    ac.request_analysis(LivenessAnalysis)
+    for bb in fn.get_basic_blocks():
+        e = _handle_incorect_liveness(bb)
+        errors.extend(e)
+    return errors
+
+
+def check_venom(context: IRContext) -> list[VenomSemanticError]:
+    errors: list[VenomSemanticError] = []
+
+    for fn in context.functions.values():
+        errors.extend(check_venom_fn(fn))
+
+    return errors
+
+
+def _handle_incorect_liveness(bb: IRBasicBlock) -> list[VenomSemanticError]:
+    errors = []
+    defined_here = set()
+    for inst in bb.instructions:
+        if inst.output is not None:
+            defined_here.add(inst.output)
+
+    before_live = set().union(*(in_bb.out_vars for in_bb in bb.cfg_in))
+
+    undef_vars = bb.instructions[-1].liveness.difference(before_live.union(defined_here))
+
+    for var in undef_vars:
+        errors.append(VenomSemanticError(VenomSemanticErrorType.NotDefinedVar, var))
+    return errors