sonolus.py 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

sonolus/backend/excepthook.py

@@ -16,6 +16,10 @@ def is_compiler_internal(tb: TracebackType):
     )
 
 
+def is_traceback_root(tb: TracebackType | None) -> bool:
+    return tb.tb_frame.f_locals.get("_traceback_root_", False) or tb.tb_frame.f_globals.get("_traceback_root_", False)
+
+
 def filter_traceback(tb: TracebackType | None) -> TracebackType | None:
     if tb is None:
         return None
@@ -25,6 +29,17 @@ def filter_traceback(tb: TracebackType | None) -> TracebackType | None:
     return tb
 
 
+def truncate_traceback(tb: TracebackType | None) -> TracebackType | None:
+    if tb is None:
+        return None
+    if is_compiler_internal(tb):
+        return truncate_traceback(tb.tb_next)
+    if is_traceback_root(tb):
+        return tb
+    else:
+        return truncate_traceback(tb.tb_next)
+
+
 def excepthook(exc, value, tb):
     import traceback
 
@@ -33,5 +48,20 @@ def excepthook(exc, value, tb):
     traceback.print_exception(exc, value, tb)
 
 
+def print_simple_traceback(exc, value, tb):
+    import traceback
+
+    if should_filter_traceback(tb):
+        tb = filter_traceback(tb)
+        truncated = truncate_traceback(tb)
+        tb = truncated if truncated is not None else tb
+        cause = value.__cause__
+        value.__cause__ = None
+        traceback.print_exception(exc, value, tb)
+        value.__cause__ = cause
+    else:
+        traceback.print_exception(exc, value, tb)
+
+
 def install_excepthook():
     sys.excepthook = excepthook

sonolus/backend/finalize.py

@@ -13,7 +13,9 @@ def cfg_to_engine_node(entry: BasicBlock):
     for block in block_indexes:
         statements = []
         statements.extend(ir_to_engine_node(stmt) for stmt in block.statements)
-        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
+        outgoing = {
+            edge.cond: edge.dst for edge in sorted(block.outgoing, key=lambda edge: (edge.cond is None, edge.cond))
+        }
         match outgoing:
             case {**other} if not other:
                 statements.append(ConstantNode(value=len(block_indexes)))
@@ -30,6 +32,18 @@ def cfg_to_engine_node(entry: BasicBlock):
                         ],
                     )
                 )
+            case {None: default_branch, **other} if len(other) == 1:
+                cond, cond_branch = next(iter(other.items()))
+                statements.append(
+                    FunctionNode(
+                        func=Op.If,
+                        args=[
+                            ir_to_engine_node(IRPureInstr(Op.Equal, args=[block.test, IRConst(cond)])),
+                            ConstantNode(value=block_indexes[cond_branch]),
+                            ConstantNode(value=block_indexes[default_branch]),
+                        ],
+                    )
+                )
             case dict() as targets:
                 args = [ir_to_engine_node(block.test)]
                 default = len(block_indexes)

sonolus/backend/ops.py

@@ -2,6 +2,10 @@ from enum import StrEnum
 
 
 class Op(StrEnum):
+    side_effects: bool
+    pure: bool
+    control_flow: bool
+
     def __new__(cls, name: str, side_effects: bool, pure: bool, control_flow: bool):
         obj = str.__new__(cls, name)
         obj._value_ = name

sonolus/backend/optimize/allocate.py

@@ -1,7 +1,7 @@
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_preorder
 from sonolus.backend.optimize.liveness import LivenessAnalysis, get_live
-from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig
 from sonolus.backend.place import BlockPlace, TempBlock
 
 TEMP_SIZE = 4096
@@ -10,7 +10,7 @@ TEMP_SIZE = 4096
 class AllocateBasic(CompilerPass):
     """Allocate temporary memory for temporary variables without considering lifetimes."""
 
-    def run(self, entry: BasicBlock):
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         offsets = {}
         index = 0
 
@@ -62,7 +62,7 @@ class Allocate(CompilerPass):
     def requires(self) -> set[CompilerPass]:
         return {LivenessAnalysis()}
 
-    def run(self, entry: BasicBlock):
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         mapping = self.get_mapping(entry)
         for block in traverse_cfg_preorder(entry):
             updated_statements = [self.update_stmt(statement, mapping) for statement in block.statements]
@@ -114,7 +114,7 @@ class Allocate(CompilerPass):
         interference = self.get_interference(entry)
         offsets: dict[TempBlock, int] = {}
 
-        for block, others in sorted(interference.items(), key=lambda x: -x[0].size):
+        for block, others in sorted(interference.items(), key=lambda x: (-x[0].size, x[0].name)):
             size = block.size
             offset = 0
             for other in sorted(others, key=lambda x: offsets.get(x, 0) + x.size):
@@ -152,7 +152,7 @@ class AllocateFast(Allocate):
         offsets: dict[TempBlock, int] = dict.fromkeys(interference, 0)
         end_offsets: dict[TempBlock, int] = dict.fromkeys(interference, 0)
 
-        for block, others in interference.items():
+        for block, others in sorted(interference.items(), key=lambda x: (-x[0].size, x[0].name)):
             size = block.size
             offset = max((end_offsets[other] for other in others), default=0)
             if offset + size > TEMP_SIZE:

sonolus/backend/optimize/constant_evaluation.py

@@ -2,13 +2,14 @@
 import functools
 import math
 import operator
+from collections import defaultdict
 from typing import ClassVar
 
 import sonolus.script.internal.math_impls as smath
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet, IRStmt
 from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import BasicBlock, FlowEdge, traverse_cfg_preorder
-from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig
 from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
 
 
@@ -24,7 +25,11 @@ UNDEF = Undefined()
 NAC = NotAConstant()
 
 
-type Value = float | Undefined | NotAConstant
+type Value = float | set[float] | Undefined | NotAConstant
+
+
+def is_constant(value: Value) -> bool:
+    return isinstance(value, (int, float))
 
 
 class SparseConditionalConstantPropagation(CompilerPass):
@@ -61,24 +66,31 @@ class SparseConditionalConstantPropagation(CompilerPass):
         Op.Arccos,
         Op.Arctan,
         Op.Arctan2,
+        Op.Max,
+        Op.Min,
     }
 
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         ssa_edges: dict[SSAPlace, set[SSAPlace | BasicBlock]] = {}
         executable_edges: set[FlowEdge] = set()
 
         # BasicBlock key means the block's test
-        values: dict[SSAPlace | BasicBlock, Value] = {SSAPlace("err", 0): UNDEF}
+        values: dict[SSAPlace | BasicBlock, Value] = defaultdict(lambda: UNDEF)
         defs: dict[SSAPlace | BasicBlock, IRStmt | dict[FlowEdge, SSAPlace]] = {}
         places_to_blocks: dict[SSAPlace, BasicBlock] = {}
         reachable_blocks: set[BasicBlock] = set()
 
         for block in traverse_cfg_preorder(entry):
-            incoming_by_src = {edge.src: edge for edge in block.incoming}
+            incoming_by_src = {}
+            for edge in block.incoming:
+                incoming_by_src.setdefault(edge.src, []).append(edge)
             for p, args in block.phis.items():
                 if not isinstance(p, SSAPlace):
-                    continue
-                defs[p] = {incoming_by_src[b]: v for b, v in args.items()}
+                    raise TypeError(f"Unexpected phi place: {p}")
+                defs[p] = {}
+                for b, v in args.items():
+                    for incoming in incoming_by_src.get(b, []):
+                        defs[p][incoming] = v
                 values[p] = UNDEF
                 for arg in args.values():
                     ssa_edges.setdefault(arg, set()).add(p)
@@ -95,13 +107,25 @@ class SparseConditionalConstantPropagation(CompilerPass):
                 ssa_edges.setdefault(dep, set()).add(block)
 
         def visit_phi(p):
-            arg_values = [values[v] if b in executable_edges else UNDEF for b, v in defs[p].items()]
+            arg_values = [values[v] if e in executable_edges else UNDEF for e, v in defs[p].items()]
             distinct_defined_arg_values = {arg for arg in arg_values if arg is not UNDEF}
             value = values[p]
             if len(distinct_defined_arg_values) == 1:
                 new_value = distinct_defined_arg_values.pop()
             elif len(distinct_defined_arg_values) > 1:
-                new_value = NAC
+                if any(arg is NAC for arg in distinct_defined_arg_values):
+                    new_value = NAC
+                else:
+                    new_values = set()
+                    for arg in distinct_defined_arg_values:
+                        if isinstance(arg, frozenset):
+                            new_values.update(arg)
+                        else:
+                            new_values.add(arg)
+                    if len(new_values) == 1:
+                        new_value = next(iter(new_values))
+                    else:
+                        new_value = frozenset(new_values)
             else:
                 new_value = UNDEF
             if new_value != value:
@@ -137,11 +161,22 @@ class SparseConditionalConstantPropagation(CompilerPass):
                         if new_test_value is NAC:
                             flow_worklist.update(block.outgoing)
                             reachable_blocks.update(e.dst for e in block.outgoing)
-                        else:
-                            taken_edge = next(
-                                (edge for edge in block.outgoing if edge.cond == new_test_value), None
-                            ) or next((edge for edge in block.outgoing if edge.cond is None), None)
-                            if taken_edge:
+                        elif block.outgoing:
+                            outgoing_by_cond = {edge.cond: edge for edge in block.outgoing}
+                            if is_constant(new_test_value):
+                                taken_edge = outgoing_by_cond.get(new_test_value, outgoing_by_cond.get(None))
+                                if taken_edge is None:
+                                    raise ValueError("Unexpected missing edge")
+                                taken_edges = {taken_edge}
+                            else:
+                                taken_edges = set()
+                                for v in new_test_value:
+                                    taken_edge = outgoing_by_cond.get(v, outgoing_by_cond.get(None))
+                                    if taken_edge:
+                                        taken_edges.add(taken_edge)
+                                    else:
+                                        raise ValueError("Unexpected missing edge")
+                            for taken_edge in taken_edges:
                                 flow_worklist.add(taken_edge)
                                 reachable_blocks.add(taken_edge.dst)
                     elif len(block.outgoing) == 1 and next(iter(block.outgoing)).cond is None:
@@ -164,10 +199,21 @@ class SparseConditionalConstantPropagation(CompilerPass):
                             flow_worklist.update(p.outgoing)
                             reachable_blocks.update(e.dst for e in p.outgoing)
                         else:
-                            taken_edge = next(
-                                (edge for edge in p.outgoing if edge.cond == new_test_value), None
-                            ) or next((edge for edge in p.outgoing if edge.cond is None), None)
-                            if taken_edge:
+                            outgoing_by_cond = {edge.cond: edge for edge in p.outgoing}
+                            if is_constant(new_test_value):
+                                taken_edge = outgoing_by_cond.get(new_test_value, outgoing_by_cond.get(None))
+                                if taken_edge is None:
+                                    raise ValueError("Unexpected missing edge")
+                                taken_edges = {taken_edge}
+                            else:
+                                taken_edges = set()
+                                for v in new_test_value:
+                                    taken_edge = outgoing_by_cond.get(v, outgoing_by_cond.get(None))
+                                    if taken_edge:
+                                        taken_edges.add(taken_edge)
+                                    else:
+                                        raise ValueError("Unexpected missing edge")
+                            for taken_edge in taken_edges:
                                 flow_worklist.add(taken_edge)
                                 reachable_blocks.add(taken_edge.dst)
                 else:
@@ -183,6 +229,59 @@ class SparseConditionalConstantPropagation(CompilerPass):
         for block in traverse_cfg_preorder(entry):
             block.statements = [self.substitute_constants(stmt, values) for stmt in block.statements]
             block.test = self.substitute_constants(block.test, values)
+            if isinstance(block.test, IRGet) and block.test.place in values:
+                test_value = values[block.test.place]
+                if isinstance(test_value, frozenset):
+                    new_outgoing = set()
+                    outgoing_by_cond = {edge.cond: edge for edge in block.outgoing}
+                    for v in test_value:
+                        if v in outgoing_by_cond:
+                            new_outgoing.add(outgoing_by_cond[v])
+                        elif None in outgoing_by_cond:
+                            new_outgoing.add(outgoing_by_cond[None])
+                        else:
+                            raise ValueError("Unexpected missing edge")
+                    removed_edges = set(block.outgoing) - new_outgoing
+                    for edge in removed_edges:
+                        edge.dst.incoming.remove(edge)
+                    if not any(edge.cond is None for edge in new_outgoing):
+                        default_edge = max(new_outgoing, key=lambda e: e.cond)
+                        default_edge.cond = None
+                    block.outgoing = new_outgoing
+
+        reachable_blocks = set(traverse_cfg_preorder(entry))
+        for block in traverse_cfg_preorder(entry):
+            block.incoming = {edge for edge in block.incoming if edge.src in reachable_blocks}
+            incoming_blocks = {edge.src for edge in block.incoming}
+            for v in block.phis:
+                block.phis[v] = {k: v for k, v in block.phis[v].items() if k in incoming_blocks}
+
+        queue = set(traverse_cfg_preorder(entry))
+        while queue:
+            block = queue.pop()
+            dead_phis = {k for k, v in block.phis.items() if not v}
+            for edge in block.outgoing:
+                for v in edge.dst.phis.values():
+                    if block in v and v[block] in dead_phis:
+                        del v[block]
+                        queue.add(edge.dst)
+            block.phis = {k: v for k, v in block.phis.items() if v}
+
+        for block in traverse_cfg_preorder(entry):
+            block.phis = {
+                k: {b: arg for b, arg in args.items() if values.get(arg, UNDEF) is not UNDEF}
+                for k, args in block.phis.items()
+            }
+            block.statements = [
+                stmt
+                for stmt in block.statements
+                # Note that if this is a set with a side effect, it will never be undef
+                if not (
+                    isinstance(stmt, IRSet)
+                    and isinstance(stmt.place, SSAPlace)
+                    and values.get(stmt.place, UNDEF) is UNDEF
+                )
+            ]
 
         return entry
 
@@ -263,7 +362,7 @@ class SparseConditionalConstantPropagation(CompilerPass):
                     case Op.Multiply:
                         if any(arg == 0 for arg in args):
                             return 0
-                if any(arg is NAC for arg in args):
+                if any(arg is NAC or isinstance(arg, frozenset) for arg in args):
                     return NAC
                 if any(arg is UNDEF for arg in args):
                     return UNDEF
@@ -366,6 +465,12 @@ class SparseConditionalConstantPropagation(CompilerPass):
                     case Op.Arctan2:
                         assert len(args) == 2
                         return math.atan2(args[0], args[1])
+                    case Op.Max:
+                        assert len(args) == 2
+                        return max(args)
+                    case Op.Min:
+                        assert len(args) == 2
+                        return min(args)
             case IRGet(place=SSAPlace() as place):
                 return values[place]
             case IRGet():

sonolus/backend/optimize/copy_coalesce.py

@@ -1,7 +1,7 @@
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_preorder
 from sonolus.backend.optimize.liveness import LivenessAnalysis, get_live
-from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig
 from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
 
 
@@ -9,7 +9,7 @@ class CopyCoalesce(CompilerPass):
     def requires(self) -> set[CompilerPass]:
         return {LivenessAnalysis()}
 
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         mapping = self.get_mapping(entry)
         for block in traverse_cfg_preorder(entry):
             block.statements = [self.apply_to_stmt(stmt, mapping) for stmt in block.statements]
@@ -41,17 +41,20 @@ class CopyCoalesce(CompilerPass):
 
         mapping: dict[TempBlock, set[TempBlock]] = {}
 
+        copy_pairs = set()
         for target, sources in copies.items():
-            for source in sources:
-                if source in interference.get(target, set()):
-                    continue
-                combined_mapping = mapping.get(target, {target}) | mapping.get(source, {source})
-                combined_interference = interference.get(target, set()) | interference.get(source, set())
-                for place in combined_mapping:
-                    mapping[place] = combined_mapping
-                    interference[place] = combined_interference
-                for place in combined_interference:
-                    interference[place].update(combined_mapping)
+            copy_pairs.update((min(target, source), max(target, source)) for source in sources)
+
+        for target, source in sorted(copy_pairs):
+            if source in interference.get(target, set()):
+                continue
+            combined_mapping = mapping.get(target, {target}) | mapping.get(source, {source})
+            combined_interference = interference.get(target, set()) | interference.get(source, set())
+            for place in combined_mapping:
+                mapping[place] = combined_mapping
+                interference[place] = combined_interference
+            for place in combined_interference:
+                interference[place].update(combined_mapping)
 
         canonical_mapping = {}
         for place, group in mapping.items():

sonolus/backend/optimize/dead_code.py

@@ -1,12 +1,12 @@
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet, IRStmt
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_preorder
 from sonolus.backend.optimize.liveness import HasLiveness, LivenessAnalysis, get_live, get_live_phi_targets
-from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig
 from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
 
 
 class UnreachableCodeElimination(CompilerPass):
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         original_blocks = [*traverse_cfg_preorder(entry)]
         worklist = {entry}
         visited = set()
@@ -29,7 +29,6 @@ class UnreachableCodeElimination(CompilerPass):
                             block.outgoing.remove(edge)
                     if taken_edge:
                         taken_edge.cond = None
-                        block.outgoing.add(taken_edge)
                         worklist.add(taken_edge.dst)
                 case _:
                     worklist.update(edge.dst for edge in block.outgoing)
@@ -38,15 +37,17 @@ class UnreachableCodeElimination(CompilerPass):
                 for edge in block.outgoing:
                     edge.dst.incoming.remove(edge)
             else:
+                incoming_blocks = {edge.src for edge in block.incoming}
                 for args in block.phis.values():
                     for src_block in [*args]:
-                        if src_block not in visited:
+                        if src_block not in visited or src_block not in incoming_blocks:
                             args.pop(src_block)
+                block.phis = {tgt: args for tgt, args in block.phis.items() if args}
         return entry
 
 
 class DeadCodeElimination(CompilerPass):
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         uses = set()
         defs = {}
         for block in traverse_cfg_preorder(entry):
@@ -157,7 +158,7 @@ class AdvancedDeadCodeElimination(CompilerPass):
     def requires(self) -> set[CompilerPass]:
         return {LivenessAnalysis()}
 
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         for block in traverse_cfg_preorder(entry):
             live_stmts = []
             for statement in block.statements:

sonolus/backend/optimize/dominance.py

@@ -2,14 +2,14 @@ from sonolus.backend.optimize.flow import (
     BasicBlock,
     traverse_cfg_reverse_postorder,
 )
-from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig
 
 
 class DominanceFrontiers(CompilerPass):
     def destroys(self) -> set[CompilerPass] | None:
         return set()
 
-    def run(self, entry: BasicBlock) -> BasicBlock:
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         blocks = list(traverse_cfg_reverse_postorder(entry))
 
         self.number_blocks(blocks)

sonolus/backend/optimize/flow.py

@@ -1,25 +1,26 @@
+from __future__ import annotations
+
 import textwrap
 from collections import deque
 from collections.abc import Iterator
-from typing import Self
 
 from sonolus.backend.ir import IRConst, IRExpr, IRStmt
 from sonolus.backend.place import SSAPlace, TempBlock
 
 
 class FlowEdge:
-    src: "BasicBlock"
-    dst: "BasicBlock"
+    src: BasicBlock
+    dst: BasicBlock
     cond: float | int | None
 
-    def __init__(self, src: "BasicBlock", dst: "BasicBlock", cond: float | None = None):
+    def __init__(self, src: BasicBlock, dst: BasicBlock, cond: float | None = None):
         self.src = src
         self.dst = dst
         self.cond = cond
 
 
 class BasicBlock:
-    phis: dict[SSAPlace | TempBlock, dict[Self, SSAPlace]]
+    phis: dict[SSAPlace | TempBlock, dict[BasicBlock, SSAPlace]]
     statements: list[IRStmt]
     test: IRExpr
     incoming: set[FlowEdge]
@@ -28,7 +29,7 @@ class BasicBlock:
     def __init__(
         self,
         *,
-        phi: dict[SSAPlace, dict[Self, SSAPlace]] | None = None,
+        phi: dict[SSAPlace, dict[BasicBlock, SSAPlace]] | None = None,
         statements: list[IRStmt] | None = None,
         test: IRExpr | None = None,
         incoming: set[FlowEdge] | None = None,
@@ -40,7 +41,7 @@ class BasicBlock:
         self.incoming = incoming or set()
         self.outgoing = outgoing or set()
 
-    def connect_to(self, other: "BasicBlock", cond: int | float | None = None):
+    def connect_to(self, other: BasicBlock, cond: int | float | None = None):
         edge = FlowEdge(self, other, cond)
         self.outgoing.add(edge)
         other.incoming.add(edge)
@@ -129,7 +130,7 @@ def cfg_to_mermaid(entry: BasicBlock):
             case dict() as tgt:
                 lines.append(f"{index}_{{{{{pre(fmt([block.test]))}}}}}")
                 lines.append(f"{index} --> {index}_")
-                for cond, target in tgt.items():
+                for cond, target in sorted(tgt.items(), key=lambda x: (x[0] is None, x[0])):
                     lines.append(
                         f"{index}_ --> |{pre(fmt([cond if cond is not None else 'default']))}| {block_indexes[target]}"
                     )
@@ -137,3 +138,48 @@ def cfg_to_mermaid(entry: BasicBlock):
 
     body = textwrap.indent("\n".join(lines), "    ")
     return f"graph\n{body}"
+
+
+def cfg_to_text(entry: BasicBlock) -> str:
+    def indent(iterable, prefix="  "):
+        for line in iterable:
+            yield f"{prefix}{line}"
+
+    block_indexes = {block: i for i, block in enumerate(traverse_cfg_reverse_postorder(entry))}
+
+    def format_phis(phis):
+        for dst, phi_srcs in phis.items():
+            srcs = ", ".join(
+                f"{block_indexes.get(src_block, '<dead>')}: {src_place}"
+                for src_block, src_place in sorted(phi_srcs.items(), key=lambda x: block_indexes.get(x[0]))
+            )
+            yield f"{dst} := phi({srcs})\n"
+
+    def format_statements(statements):
+        for stmt in statements:
+            yield f"{stmt}\n"
+
+    def format_outgoing(outgoing_edges, test, indexes):
+        outgoing = {edge.cond: edge.dst for edge in outgoing_edges}
+        match outgoing:
+            case {**other} if not other:
+                yield "goto exit\n"
+            case {None: target, **other} if not other:
+                yield f"goto {indexes[target]}\n"
+            case {0: f_branch, None: t_branch, **other} if not other:
+                yield f"goto {indexes[t_branch]} if {test} else {indexes[f_branch]}\n"
+            case dict() as tgt:
+                yield f"goto when {test}\n"
+                yield from indent(
+                    f"{('default' if cond is None else str(cond))} -> {indexes[target]}\n"
+                    for cond, target in sorted(tgt.items(), key=lambda x: (x[0] is None, x[0]))
+                )
+
+    def format_blocks():
+        for block, index in block_indexes.items():
+            yield f"{index}:\n"
+            yield from indent(format_phis(block.phis))
+            yield from indent(format_statements(block.statements))
+            yield from indent(format_outgoing(block.outgoing, block.test, block_indexes))
+
+    return "".join(format_blocks())