sonolus.py 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

sonolus/backend/optimize/dominance.py

@@ -0,0 +1,96 @@
+from sonolus.backend.optimize.flow import (
+    BasicBlock,
+    traverse_cfg_reverse_postorder,
+)
+from sonolus.backend.optimize.passes import CompilerPass
+
+
+class DominanceFrontiers(CompilerPass):
+    def destroys(self) -> set[CompilerPass] | None:
+        return set()
+
+    def run(self, entry: BasicBlock) -> BasicBlock:
+        blocks = list(traverse_cfg_reverse_postorder(entry))
+
+        self.number_blocks(blocks)
+        self.initialize_idoms(blocks, entry)
+        self.compute_idoms(blocks)
+        self.build_dominator_tree(blocks)
+        self.compute_dominance_frontiers(blocks)
+
+        return entry
+
+    def number_blocks(self, blocks: list[BasicBlock]):
+        """Assign a unique number to each block based on reverse post-order."""
+        for idx, block in enumerate(blocks):
+            block.num = idx
+
+    def initialize_idoms(self, blocks: list[BasicBlock], entry_block: BasicBlock):
+        """Initialize immediate dominators for each block."""
+        for block in blocks:
+            block.idom = None
+        entry_block.idom = entry_block
+
+    def compute_idoms(self, blocks: list[BasicBlock]):
+        """Iteratively compute the immediate dominators of each block."""
+        changed = True
+        while changed:
+            changed = False
+            for b in blocks[1:]:  # Skip the entry block
+                new_idom = None
+                for edge in b.incoming:
+                    p = edge.src
+                    if p.idom is not None:
+                        if new_idom is None:
+                            new_idom = p
+                        else:
+                            new_idom = self.intersect(p, new_idom)
+                if b.idom != new_idom:
+                    b.idom = new_idom
+                    changed = True
+
+    def build_dominator_tree(self, blocks: list[BasicBlock]):
+        """Construct the dominator tree using the immediate dominators."""
+        for block in blocks:
+            block.dom_children = []
+
+        for block in blocks:
+            if block.idom != block:
+                block.idom.dom_children.append(block)
+
+    def compute_dominance_frontiers(self, blocks: list[BasicBlock]):
+        """Compute the dominance frontiers for all blocks."""
+        for block in blocks:
+            block.df = set()
+
+        for b in blocks:
+            if len(b.incoming) >= 2:
+                for edge in b.incoming:
+                    p = edge.src
+                    runner = p
+                    while runner != b.idom:
+                        runner.df.add(b)
+                        runner = runner.idom
+
+    def intersect(self, b1: BasicBlock, b2: BasicBlock) -> BasicBlock:
+        """Helper function to find the closest common dominator of two blocks."""
+        while b1 != b2:
+            while b1.num > b2.num:
+                b1 = b1.idom
+            while b2.num > b1.num:
+                b2 = b2.idom
+        return b1
+
+    def __eq__(self, other):
+        return isinstance(other, DominanceFrontiers)
+
+    def __hash__(self):
+        return hash(DominanceFrontiers)
+
+
+def get_df(block: BasicBlock) -> set[BasicBlock]:
+    return block.df
+
+
+def get_dom_children(block: BasicBlock) -> list[BasicBlock]:
+    return block.dom_children

sonolus/backend/{flow.py → optimize/flow.py}

@@ -1,92 +1,122 @@
-import textwrap
-from collections import deque
-from collections.abc import Iterator
-
-from sonolus.backend.ir import IRConst, IRExpr, IRStmt
-
-
-class FlowEdge:
-    src: "BasicBlock"
-    dst: "BasicBlock"
-    cond: IRExpr | None
-
-    def __init__(self, src: "BasicBlock", dst: "BasicBlock", cond: IRExpr | None = None):
-        self.src = src
-        self.dst = dst
-        self.cond = cond
-
-
-class BasicBlock:
-    statements: list[IRStmt]
-    test: IRExpr
-    incoming: set[FlowEdge]
-    outgoing: set[FlowEdge]
-
-    def __init__(
-        self,
-        statements: list[IRStmt] | None = None,
-        test: IRExpr | None = None,
-        incoming: set[FlowEdge] | None = None,
-        outgoing: set[FlowEdge] | None = None,
-    ):
-        self.statements = statements or []
-        self.test = test or IRConst(1)
-        self.incoming = incoming or set()
-        self.outgoing = outgoing or set()
-
-    def connect_to(self, other: "BasicBlock", cond: IRExpr | None = None):
-        edge = FlowEdge(self, other, cond)
-        self.outgoing.add(edge)
-        other.incoming.add(edge)
-
-
-def traverse_cfg_preorder(block: BasicBlock) -> Iterator[BasicBlock]:
-    visited = set()
-    queue = deque([block])
-    while queue:
-        block = queue.popleft()
-        if block in visited:
-            continue
-        visited.add(block)
-        yield block
-        for edge in sorted(block.outgoing, key=lambda e: (e.cond is None, e.cond)):
-            queue.append(edge.dst)
-
-
-def cfg_to_mermaid(entry: BasicBlock):
-    def pre(s: str):
-        return "\"<pre style='text-align: left;'>" + s.replace("\n", "<br/>") + '</pre>"'
-
-    def fmt(nodes):
-        if nodes:
-            return "\n".join(str(n) for n in nodes)
-        else:
-            return "{}"
-
-    block_indexes = {block: i for i, block in enumerate(traverse_cfg_preorder(entry))}
-
-    lines = ["Entry([Entry]) --> 0"]
-    for block in traverse_cfg_preorder(entry):
-        index = block_indexes[block]
-        lines.append(f"{index}[{pre(fmt([f'#{index}', *block.statements]))}]")
-
-        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
-        match outgoing:
-            case {**other} if not other:
-                lines.append(f"{index} --> Exit")
-            case {None: target, **other} if not other:
-                lines.append(f"{index} --> {block_indexes[target]}")
-            case {0: f_branch, None: t_branch, **other} if not other:
-                lines.append(f"{index}_{{{pre(fmt([block.test]))}}}")
-                lines.append(f"{index} --> {index}_")
-                lines.append(f"{index}_ --> |true| {block_indexes[t_branch]}")
-                lines.append(f"{index}_ --> |false| {block_indexes[f_branch]}")
-            case dict() as tgt:
-                lines.append(f"{index}_{{{{{pre(fmt([block.test]))}}}}}")
-                lines.append(f"{index} --> {index}_")
-                for cond, target in tgt.items():
-                    lines.append(f"{index}_ --> |{pre(fmt([cond or "default"]))}| {block_indexes[target]}")
-    lines.append("Exit([Exit])")
-
-    body = textwrap.indent("\n".join(lines), "    ")
-    return f"graph\n{body}"
+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"
+    cond: float | int | 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]]
+    statements: list[IRStmt]
+    test: IRExpr
+    incoming: set[FlowEdge]
+    outgoing: set[FlowEdge]
+
+    def __init__(
+        self,
+        *,
+        phi: dict[SSAPlace, dict[Self, SSAPlace]] | None = None,
+        statements: list[IRStmt] | None = None,
+        test: IRExpr | None = None,
+        incoming: set[FlowEdge] | None = None,
+        outgoing: set[FlowEdge] | None = None,
+    ):
+        self.phis = phi or {}
+        self.statements = statements or []
+        self.test = test or IRConst(0)
+        self.incoming = incoming or set()
+        self.outgoing = outgoing or set()
+
+    def connect_to(self, other: "BasicBlock", cond: int | float | None = None):
+        edge = FlowEdge(self, other, cond)
+        self.outgoing.add(edge)
+        other.incoming.add(edge)
+
+
+def traverse_cfg_preorder(block: BasicBlock) -> Iterator[BasicBlock]:
+    visited = set()
+    queue = deque([block])
+    while queue:
+        block = queue.popleft()
+        if block in visited:
+            continue
+        visited.add(block)
+        yield block
+        for edge in sorted(block.outgoing, key=lambda e: (e.cond is None, e.cond)):
+            queue.append(edge.dst)
+
+
+def traverse_cfg_postorder(block: BasicBlock) -> Iterator[BasicBlock]:
+    visited = set()
+
+    def dfs(current: BasicBlock):
+        if current in visited:
+            return
+        visited.add(current)
+        for edge in sorted(current.outgoing, key=lambda e: (e.cond is None, e.cond)):
+            yield from dfs(edge.dst)
+        yield current
+
+    yield from dfs(block)
+
+
+def traverse_cfg_reverse_postorder(block: BasicBlock) -> Iterator[BasicBlock]:
+    yield from reversed(list(traverse_cfg_postorder(block)))
+
+
+def cfg_to_mermaid(entry: BasicBlock):
+    def pre(s: str):
+        return "\"<pre style='text-align: left;'>" + s.replace("\n", "<br/>") + '</pre>"'
+
+    def fmt(nodes):
+        if nodes:
+            return "\n".join(str(n) for n in nodes)
+        else:
+            return "{}"
+
+    block_indexes = {block: i for i, block in enumerate(traverse_cfg_reverse_postorder(entry))}
+
+    lines = ["Entry([Entry]) --> 0"]
+    for block, index in block_indexes.items():
+        lines.append(f"{index}[{pre(fmt([f'#{index}', *(
+            f"{dst} := phi({", ".join(f"{block_indexes.get(src_block, "<dead>")}: {src_place}"
+                                      for src_block, src_place
+                                      in sorted(phis.items(), key=lambda x: block_indexes.get(x[0])))})"
+            for dst, phis in block.phis.items()
+        ), *block.statements]))}]")
+
+        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
+        match outgoing:
+            case {**other} if not other:
+                lines.append(f"{index} --> Exit")
+            case {None: target, **other} if not other:
+                lines.append(f"{index} --> {block_indexes[target]}")
+            case {0: f_branch, None: t_branch, **other} if not other:
+                lines.append(f"{index}_{{{{{pre(fmt([block.test]))}}}}}")
+                lines.append(f"{index} --> {index}_")
+                lines.append(f"{index}_ --> |true| {block_indexes[t_branch]}")
+                lines.append(f"{index}_ --> |false| {block_indexes[f_branch]}")
+            case dict() as tgt:
+                lines.append(f"{index}_{{{{{pre(fmt([block.test]))}}}}}")
+                lines.append(f"{index} --> {index}_")
+                for cond, target in tgt.items():
+                    lines.append(
+                        f"{index}_ --> |{pre(fmt([cond if cond is not None else "default"]))}| {block_indexes[target]}"
+                    )
+    lines.append("Exit([Exit])")
+
+    body = textwrap.indent("\n".join(lines), "    ")
+    return f"graph\n{body}"

sonolus/backend/optimize/inlining.py

@@ -0,0 +1,137 @@
+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.passes import CompilerPass
+from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
+
+
+class InlineVars(CompilerPass):
+    def run(self, entry: BasicBlock) -> BasicBlock:
+        use_counts: dict[SSAPlace, int] = {}
+        definitions: dict[SSAPlace, IRStmt] = {}
+
+        for block in traverse_cfg_preorder(entry):
+            for stmt in block.statements:
+                self.count_uses(stmt, use_counts)
+                if isinstance(stmt, IRSet) and isinstance(stmt.place, SSAPlace):
+                    definitions[stmt.place] = stmt.value
+            self.count_uses(block.test, use_counts)
+
+        for p, defn in definitions.items():
+            while True:
+                if isinstance(defn, IRGet) and isinstance(defn.place, SSAPlace) and defn.place in definitions:
+                    inside_defn = definitions[defn.place]
+                    if not self.is_inlinable(inside_defn):
+                        break
+                    defn = inside_defn
+                    continue
+                inlinable_uses = self.get_inlinable_uses(defn, set())
+                subs = {}
+                for inside_p in inlinable_uses:
+                    if inside_p not in definitions:
+                        continue
+                    inside_defn = definitions[inside_p]
+                    if not self.is_inlinable(inside_defn):
+                        continue
+                    if (isinstance(inside_defn, IRGet) and isinstance(inside_defn.place, SSAPlace)) or use_counts[
+                        inside_p
+                    ] == 1:
+                        subs[inside_p] = inside_defn
+                if not subs:
+                    break
+                defn = self.substitute(defn, subs)
+            definitions[p] = defn
+
+        valid = {p for p in definitions if self.is_inlinable(definitions[p]) and use_counts.get(p, 0) <= 1}
+
+        for block in traverse_cfg_preorder(entry):
+            new_statements = []
+            for stmt in [*block.statements, block.test]:
+                inlinable_uses = self.get_inlinable_uses(stmt, set())
+                subs = {}
+                for p in inlinable_uses:
+                    if p not in valid:
+                        continue
+                    definition = definitions[p]
+                    subs[p] = definition
+
+                if subs:
+                    new_statements.append(self.substitute(stmt, subs))
+                else:
+                    new_statements.append(stmt)
+
+            block.statements = new_statements[:-1]
+            block.test = new_statements[-1]
+
+        return entry
+
+    def substitute(self, stmt, subs):
+        match stmt:
+            case IRConst():
+                return stmt
+            case IRInstr(op=op, args=args):
+                return IRInstr(op=op, args=[self.substitute(arg, subs) for arg in args])
+            case IRPureInstr(op=op, args=args):
+                return IRPureInstr(op=op, args=[self.substitute(arg, subs) for arg in args])
+            case IRGet(place=place):
+                if place in subs:
+                    return subs[place]
+                return stmt
+            case IRSet(place=place, value=value):
+                return IRSet(place=place, value=self.substitute(value, subs))
+            case _:
+                raise TypeError(f"Unexpected statement: {stmt}")
+
+    def count_uses(self, stmt, use_counts):
+        match stmt:
+            case IRConst():
+                pass
+            case IRInstr(op=_, args=args) | IRPureInstr(op=_, args=args):
+                for arg in args:
+                    self.count_uses(arg, use_counts)
+            case IRGet(place=place):
+                self.count_uses(place, use_counts)
+            case IRSet(place=place, value=value):
+                if not isinstance(place, SSAPlace):  # We don't want to count the definition itself
+                    self.count_uses(place, use_counts)
+                self.count_uses(value, use_counts)
+            case SSAPlace():
+                use_counts[stmt] = use_counts.get(stmt, 0) + 1
+            case BlockPlace(block=block, index=index, offset=_):
+                self.count_uses(block, use_counts)
+                self.count_uses(index, use_counts)
+            case int() | float():
+                pass
+            case TempBlock():
+                pass
+            case _:
+                raise TypeError(f"Unexpected statement: {stmt}")
+        return use_counts
+
+    def get_inlinable_uses(self, stmt, uses):
+        match stmt:
+            case IRConst():
+                pass
+            case IRInstr(op=_, args=args) | IRPureInstr(op=_, args=args):
+                for arg in args:
+                    self.get_inlinable_uses(arg, uses)
+            case IRGet(place=place):
+                if isinstance(place, SSAPlace):
+                    uses.add(place)
+            case IRSet(place=_, value=value):
+                self.get_inlinable_uses(value, uses)
+            case _:
+                raise TypeError(f"Unexpected statement: {stmt}")
+        return uses
+
+    def is_inlinable(self, stmt):
+        match stmt:
+            case IRConst():
+                return True
+            case IRInstr(op=op, args=args) | IRPureInstr(op=op, args=args):
+                return not op.side_effects and op.pure and all(self.is_inlinable(arg) for arg in args)
+            case IRGet():
+                return isinstance(stmt.place, SSAPlace)
+            case IRSet():
+                return False
+            case _:
+                raise TypeError(f"Unexpected statement: {stmt}")

sonolus/backend/optimize/liveness.py

@@ -0,0 +1,177 @@
+from collections import deque
+
+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.passes import CompilerPass
+from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
+
+type HasLiveness = SSAPlace | TempBlock
+
+
+class LivenessAnalysis(CompilerPass):
+    def destroys(self) -> set[CompilerPass]:
+        return set()
+
+    def run(self, entry: BasicBlock) -> BasicBlock:
+        self.preprocess(entry)
+        self.process(entry)
+        return entry
+
+    def preprocess(self, entry: BasicBlock):
+        for block in traverse_cfg_preorder(entry):
+            block.live_out = None
+            block.live_in = set()
+            block.live_phi_targets = set()
+            block.array_defs_in = set()
+            block.array_defs_out = None
+            for statement in block.statements:
+                statement.live = set()
+                statement.visited = False
+                statement.uses = self.get_uses(statement, set())
+                statement.defs = self.get_defs(statement)
+                statement.is_array_init = False  # True if this may be the first assignment to an array
+                statement.array_defs = self.get_array_defs(statement)
+            block.test.live = set()
+            block.test.uses = self.get_uses(block.test, set())
+        self.preprocess_arrays(entry)
+
+    def process(self, entry: BasicBlock):
+        queue = deque(self.get_exits(entry))
+        if not queue:
+            raise ValueError("Infinite loop detected")
+        while queue:
+            block = queue.popleft()
+            updated_blocks = self.process_block(block)
+            queue.extend(updated_blocks)
+
+    def preprocess_arrays(self, entry: BasicBlock):
+        queue = {entry}
+        visited = set()
+        while queue:
+            block = queue.pop()
+            array_defs = block.array_defs_in.copy()
+            is_first_visit = block not in visited
+            visited.add(block)
+            for statement in block.statements:
+                if statement.array_defs - array_defs:
+                    statement.is_array_init = True
+                    array_defs.update(statement.array_defs)
+                else:
+                    statement.is_array_init = False
+            if is_first_visit or array_defs != block.array_defs_out:
+                block.array_defs_out = array_defs
+                for edge in block.outgoing:
+                    queue.add(edge.dst)
+                    edge.dst.array_defs_in.update(array_defs)
+
+    def process_block(self, block: BasicBlock) -> list[BasicBlock]:
+        if block.live_out is None:
+            block.live_out = set()
+        live: set[HasLiveness] = {
+            place
+            for place in block.live_out
+            if not (isinstance(place, TempBlock) and place.size > 1 and place not in block.array_defs_out)
+        }
+        block.test.live.update(live)
+        live.update(block.test.uses)
+        for statement in reversed(block.statements):
+            statement.live.update(live)
+            if self.can_skip(statement, live):
+                continue
+            live.difference_update(statement.defs)
+            if statement.is_array_init:
+                live.difference_update(statement.array_defs)
+            live.update(statement.uses)
+        prev_sizes_by_block = {
+            edge.src: len(edge.src.live_out) if edge.src.live_out is not None else -1 for edge in block.incoming
+        }
+        live_phi_targets = set()
+        for target, args in block.phis.items():
+            if target not in live:
+                continue
+            live.remove(target)
+            for src_block, arg in args.items():
+                if src_block.live_out is None:
+                    src_block.live_out = set()
+                src_block.live_out.add(arg)
+            live_phi_targets.add(target)
+        block.live_in = live
+        block.live_phi_targets = live_phi_targets
+        updated_blocks = []
+        for edge in block.incoming:
+            if edge.src.live_out is None:
+                edge.src.live_out = set()
+            edge.src.live_out.update(live)
+            if len(edge.src.live_out) != prev_sizes_by_block[edge.src]:
+                updated_blocks.append(edge.src)
+        return updated_blocks
+
+    def get_uses(
+        self, stmt: IRStmt | BlockPlace | SSAPlace | TempBlock | int, uses: set[HasLiveness]
+    ) -> set[HasLiveness]:
+        match stmt:
+            case IRPureInstr(op=_, args=args) | IRInstr(op=_, args=args):
+                for arg in args:
+                    self.get_uses(arg, uses)
+            case IRGet(place=place):
+                self.get_uses(place, uses)
+            case IRSet(place=place, value=value):
+                if isinstance(place, BlockPlace):
+                    if not isinstance(place.block, TempBlock):
+                        self.get_uses(place.block, uses)
+                    self.get_uses(place.index, uses)
+                self.get_uses(value, uses)
+            case IRConst() | int():
+                pass
+            case BlockPlace(block=block, index=index, offset=_):
+                self.get_uses(block, uses)
+                self.get_uses(index, uses)
+            case SSAPlace() | TempBlock():
+                uses.add(stmt)
+            case _:
+                raise TypeError(f"Unexpected statement type: {type(stmt)}")
+        return uses
+
+    def get_defs(self, stmt: IRStmt | BlockPlace | SSAPlace | TempBlock | int) -> set[HasLiveness]:
+        match stmt:
+            case IRSet(place=place, value=_):
+                match place:
+                    case SSAPlace():
+                        return {place}
+                    case BlockPlace(block=TempBlock() as temp_block, index=_, offset=_) if temp_block.size == 1:
+                        return {temp_block}
+        return set()
+
+    def get_array_defs(self, stmt: IRStmt | BlockPlace | SSAPlace | TempBlock | int) -> set[HasLiveness]:
+        match stmt:
+            case IRSet(place=place, value=_):
+                match place:
+                    case BlockPlace(block=TempBlock() as temp_block, index=_, offset=_) if temp_block.size > 1:
+                        return {temp_block}
+        return set()
+
+    def can_skip(self, stmt: IRStmt, live: set[HasLiveness]) -> bool:
+        match stmt:
+            case IRSet(place=_, value=value):
+                if isinstance(value, IRInstr) and value.op.side_effects:
+                    return False
+                defs = stmt.defs | stmt.array_defs
+                return defs and not (defs & live)
+        return False
+
+    def get_exits(self, entry: BasicBlock) -> list[BasicBlock]:
+        return [block for block in traverse_cfg_preorder(entry) if not block.outgoing]
+
+    def __eq__(self, other):
+        return isinstance(other, LivenessAnalysis)
+
+    def __hash__(self):
+        return hash(LivenessAnalysis)
+
+
+def get_live(stmt: IRStmt) -> set[HasLiveness]:
+    return stmt.live
+
+
+def get_live_phi_targets(block: BasicBlock) -> set[HasLiveness]:
+    return block.live_phi_targets

sonolus/backend/optimize/optimize.py

@@ -0,0 +1,44 @@
+from sonolus.backend.optimize.allocate import Allocate, AllocateBasic
+from sonolus.backend.optimize.constant_evaluation import SparseConditionalConstantPropagation
+from sonolus.backend.optimize.copy_coalesce import CopyCoalesce
+from sonolus.backend.optimize.dead_code import (
+    AdvancedDeadCodeElimination,
+    DeadCodeElimination,
+    UnreachableCodeElimination,
+)
+from sonolus.backend.optimize.flow import BasicBlock
+from sonolus.backend.optimize.inlining import InlineVars
+from sonolus.backend.optimize.passes import run_passes
+from sonolus.backend.optimize.simplify import CoalesceFlow, NormalizeSwitch, RewriteToSwitch
+from sonolus.backend.optimize.ssa import FromSSA, ToSSA
+
+MINIMAL_PASSES = [
+    CoalesceFlow(),
+    UnreachableCodeElimination(),
+    AllocateBasic(),
+]
+
+STANDARD_PASSES = [
+    CoalesceFlow(),
+    UnreachableCodeElimination(),
+    DeadCodeElimination(),
+    ToSSA(),
+    SparseConditionalConstantPropagation(),
+    UnreachableCodeElimination(),
+    DeadCodeElimination(),
+    CoalesceFlow(),
+    InlineVars(),
+    DeadCodeElimination(),
+    RewriteToSwitch(),
+    FromSSA(),
+    CoalesceFlow(),
+    CopyCoalesce(),
+    AdvancedDeadCodeElimination(),
+    CoalesceFlow(),
+    NormalizeSwitch(),
+    Allocate(),
+]
+
+
+def optimize_and_allocate(cfg: BasicBlock):
+    return run_passes(cfg, STANDARD_PASSES)