angr 9.2.117__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/analyses/decompiler/dephication/graph_vvar_mapping.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+import logging
+from collections import defaultdict
+
+from ailment.block import Block
+from ailment.expression import Phi, VirtualVariable
+from ailment.statement import Assignment, Jump, ConditionalJump, Label
+
+from angr.analyses import Analysis
+from angr.analyses.s_reaching_definitions import SRDAModel
+from angr.knowledge_plugins.functions import Function
+from angr.analyses import register_analysis
+from angr.utils.ssa import is_phi_assignment
+
+l = logging.getLogger(name=__name__)
+
+
+class GraphDephicationVVarMapping(Analysis):  # pylint:disable=abstract-method
+    """
+    GraphDephicationVVarMapping collects information from an AIL graph regarding how virtual variables should be mapped
+    to each other in order to remove phi variables. This mapping will later be used to transform a partial-SSA form of
+    AIL graph to a conventional AIL graph.
+
+    This class largely implements "Translating Out of Static Single Assignment Form" by Sreedhar et al.
+    """
+
+    def __init__(
+        self,
+        func: Function | str,
+        ail_graph,
+        entry=None,
+        vvar_id_start: int = 0,
+    ):
+        """
+        :param func:                            The subject of the analysis: a function, or a single basic block
+        :param ail_graph:                       The AIL graph to transform.
+        """
+
+        if isinstance(func, str):
+            self._function = self.kb.functions[func]
+        else:
+            self._function = func
+        self._graph = ail_graph
+        self._entry = (
+            entry
+            if entry is not None
+            else next(iter(bb for bb in self._graph if bb.addr == self._function.addr and bb.idx is None))
+        )
+        self._vvar_defloc = {}
+        self.vvar_id_start = vvar_id_start
+        self._stmts_to_prepend = defaultdict(list)
+
+        self.vvar_to_vvar_mapping = None
+        self._rd: SRDAModel = self.project.analyses.SReachingDefinitions(
+            subject=self._function, func_graph=self._graph
+        ).model
+        self._blocks: dict[tuple[int, int | None], Block] = {(block.addr, block.idx): block for block in self._graph}
+
+        self._analyze()
+
+    def _analyze(self):
+        self.vvar_to_vvar_mapping = self._collect_and_remap()
+
+    def _collect_and_remap(self) -> dict[int, int]:
+        # collect phi assignments
+        phi_to_srcvarid = self._collect_phi_assignments()
+
+        # initialize phi_congruence_class
+        phi_congruence_class: dict[int, set[int]] = {}
+        for phi_varid in phi_to_srcvarid:
+            phi_congruence_class[phi_varid] = {phi_varid}
+        for src_and_varids in phi_to_srcvarid.values():
+            for _, varid in src_and_varids:
+                phi_congruence_class[varid] = {varid}
+
+        # compute liveness
+        liveness = self.project.analyses.SLiveness(self._function, func_graph=self._graph, entry=self._entry)
+
+        live_ins = liveness.model.live_ins
+        live_outs = liveness.model.live_outs
+        interference = liveness.interference_graph()
+
+        unresolved_neighbor_map = defaultdict(set)
+
+        # check for interferences
+        for phi_id, src_and_varids in phi_to_srcvarid.items():
+            candidate_vvar_set: set[int] = set()
+            src_and_varids = list(src_and_varids)
+
+            for i in range(-1, len(src_and_varids)):
+                for j in range(i + 1, len(src_and_varids)):
+                    if i == -1:
+                        src1 = self._vvar_defloc[phi_id][0]
+                        var1 = phi_id
+                    else:
+                        src1, var1 = src_and_varids[i]
+                    src2, var2 = src_and_varids[j]
+
+                    if var1 == var2:
+                        continue
+
+                    if interference.has_edge(var1, var2):
+                        intersection_1 = phi_congruence_class[var1].intersection(live_outs[src1])
+                        intersection_2 = phi_congruence_class[var2].intersection(live_outs[src2])
+                        if intersection_1 and not intersection_2:
+                            # case 1
+                            candidate_vvar_set.add(var1)
+                        elif not intersection_1 and intersection_2:
+                            # case 2
+                            candidate_vvar_set.add(var2)
+                        elif intersection_1 and intersection_2:
+                            # case 3
+                            candidate_vvar_set.add(var1)
+                            candidate_vvar_set.add(var2)
+                        else:
+                            # case 4
+                            unresolved_neighbor_map[var1].add(var2)
+                            unresolved_neighbor_map[var2].add(var1)
+
+            # process unresolved_neighbor_map in a decreasing order of the number of neighbors
+            while unresolved_neighbor_map:
+                varid, neighbors = max(unresolved_neighbor_map.items(), key=lambda x: len(x[1]))
+                del unresolved_neighbor_map[varid]
+
+                candidate_vvar_set.add(varid)
+
+                for neighbor in neighbors:
+                    if neighbor in unresolved_neighbor_map:
+                        unresolved_neighbor_map[neighbor].discard(varid)
+                        if not unresolved_neighbor_map[neighbor]:
+                            del unresolved_neighbor_map[neighbor]
+
+            # insert copies of variables as needed
+            for varid in candidate_vvar_set:
+                insertion_type, new_vvar_ids = self._insert_vvar_copy(varid, phi_id)
+
+                if insertion_type == 0:
+                    for src, old_vvar_id, new_vvar_id in new_vvar_ids:
+                        phi_congruence_class[new_vvar_id] = {new_vvar_id}
+                        live_outs[src].add(new_vvar_id)
+
+                        src_block = self._blocks[(src[0], src[1])]
+                        for succ in self._graph.successors(src_block):
+                            succ_key = succ.addr, succ.idx
+                            if old_vvar_id not in live_ins[succ_key] and not self._used_in_phi(
+                                succ, src_block, old_vvar_id
+                            ):
+                                live_outs[src].discard(old_vvar_id)
+
+                        # update interference graph
+                        for vvar_id in live_outs[src]:
+                            interference.add_edge(new_vvar_id, vvar_id)
+
+                else:  # insertion_type == 1
+                    phi_block_loc, old_phi_varid, new_phi_varid = next(iter(new_vvar_ids))
+
+                    phi_congruence_class[new_phi_varid] = {new_phi_varid}
+
+                    live_ins[phi_block_loc].discard(old_phi_varid)
+                    live_ins[phi_block_loc].add(new_phi_varid)
+
+                    # update interference graph
+                    for vvar_id in live_ins[phi_block_loc]:
+                        interference.add_edge(new_phi_varid, vvar_id)
+
+            # update phi_congruence_class
+            (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_id]
+            phi_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
+            phi_stmt = phi_block.statements[phidef_stmt_idx]
+
+            new_class = phi_congruence_class[phi_stmt.dst.varid]
+            for _, vvar in phi_stmt.src.src_and_vvars:
+                if vvar is not None:
+                    new_class |= phi_congruence_class[vvar.varid]
+                    phi_congruence_class[vvar.varid] = new_class
+
+        # append statements that were recorded for prepending
+        for block, stmts in self._stmts_to_prepend.items():
+            for stmt in stmts:
+                self._prepend_stmt(block, stmt)
+
+        # remove congruence classes with only one element
+        for phi_varid in list(phi_congruence_class):
+            if len(phi_congruence_class[phi_varid]) == 1:
+                del phi_congruence_class[phi_varid]
+
+        mapping: dict[int, int] = {}
+        for phi_varid, congruence_class in phi_congruence_class.items():
+            for varid in congruence_class:
+                mapping[varid] = phi_varid
+
+        return mapping
+
+    def _insert_vvar_copy(self, varid: int, phi_varid: int) -> tuple[int, set]:
+        (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_varid]
+        if varid != phi_varid:
+            # it's one of the source vvars
+
+            phi_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
+            phi_stmt = phi_block.statements[phidef_stmt_idx]
+
+            new_vvar_ids = set()
+
+            for src, vvar in list(phi_stmt.src.src_and_vvars):
+                if vvar is None or vvar.varid != varid:
+                    continue
+
+                new_vvar_id = self.vvar_id_start
+                self.vvar_id_start += 1
+
+                vvar = self._rd.varid_to_vvar[varid]
+                src_block_addr, src_block_idx = src
+
+                the_block = self._blocks[(src_block_addr, src_block_idx)]
+                ins_addr = the_block.addr + the_block.original_size - 1
+                new_vvar = VirtualVariable(
+                    None, new_vvar_id, vvar.bits, vvar.category, oident=vvar.oident, ins_addr=ins_addr
+                )
+                assignment = Assignment(None, new_vvar, vvar, ins_addr=ins_addr)
+
+                self._append_stmt(the_block, assignment)
+
+                # update the phi statement
+                replaced_vvars: set[int] = set()
+                for _, phi_used_vvar in list(phi_stmt.src.src_and_vvars):
+                    if phi_used_vvar is not None and phi_used_vvar.varid == varid and varid not in replaced_vvars:
+                        replaced, phi_stmt = phi_stmt.replace(phi_used_vvar, new_vvar)
+                        assert replaced
+                        replaced_vvars.add(varid)
+                phi_block.statements[phidef_stmt_idx] = phi_stmt
+
+                new_vvar_ids.add((src, varid, new_vvar_id))
+
+            return 0, new_vvar_ids
+
+        # it's the phi assignment destination vvar
+
+        new_vvar_id = self.vvar_id_start
+        self.vvar_id_start += 1
+
+        phi_vvar = self._rd.varid_to_vvar[phi_varid]
+        phi_block_addr, phi_block_idx = self._vvar_defloc[phi_varid][0]
+        the_block = self._blocks[(phi_block_addr, phi_block_idx)]
+        ins_addr = the_block.addr
+        new_vvar = VirtualVariable(
+            None, new_vvar_id, phi_vvar.bits, phi_vvar.category, oident=phi_vvar.oident, ins_addr=ins_addr
+        )
+        assignment = Assignment(None, phi_vvar, new_vvar, ins_addr=ins_addr)
+
+        phi_stmt = the_block.statements[phidef_stmt_idx]
+        replaced, phi_stmt = phi_stmt.replace(phi_vvar, new_vvar)
+        the_block.statements[phidef_stmt_idx] = phi_stmt
+
+        self._record_stmt_for_prepending(the_block, assignment)
+
+        return 1, {((phi_block_addr, phi_block_idx), phi_varid, new_vvar_id)}
+
+    @staticmethod
+    def _append_stmt(block, stmt):
+        if block.statements and isinstance(block.statements[-1], (Jump, ConditionalJump)):
+            block.statements.insert(len(block.statements) - 1, stmt)
+        else:
+            block.statements.append(stmt)
+
+    def _record_stmt_for_prepending(self, block, stmt):
+        self._stmts_to_prepend[block].append(stmt)
+
+    @staticmethod
+    def _prepend_stmt(block, stmt):
+        # TODO: This insertion breaks the assumption that all phi statements appear before any assignments. We must
+        # TODO: fix the assumption elsewhere in the code base.
+        first_nonlabel_idx = len(block.statements)
+        for i, s in enumerate(block.statements):
+            if not isinstance(s, Label):
+                first_nonlabel_idx = i
+                break
+        block.statements.insert(first_nonlabel_idx, stmt)
+
+    @staticmethod
+    def _used_in_phi(dst_block, src_block, vvar_id: int) -> bool:
+        src = src_block.addr, src_block.idx
+        for stmt in dst_block.statements:
+            if isinstance(stmt, Label):
+                continue
+            r, _ = is_phi_assignment(stmt)
+            if r:
+                for src_, vvar in stmt.src.src_and_vvars:
+                    if src_ == src and vvar is not None and vvar.varid == vvar_id:
+                        return True
+            else:
+                # early exit
+                return False
+        return False
+
+    def _collect_phi_assignments(self) -> dict[int, set[tuple[tuple[int, int], int]]]:
+        g = self._graph
+        phi_to_src = defaultdict(set)
+
+        for block in g:
+            for stmt_idx, stmt in enumerate(block.statements):
+                if isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable):
+                    if isinstance(stmt.src, Phi):
+                        for src, vvar in stmt.src.src_and_vvars:
+                            if vvar is None:
+                                l.debug("Invalid vvar None found in %r.src.src_and_vvars.", stmt)
+                            else:
+                                phi_to_src[stmt.dst.varid].add((src, vvar.varid))
+                    self._vvar_defloc[stmt.dst.varid] = (block.addr, block.idx), stmt_idx
+
+        return phi_to_src
+
+
+register_analysis(GraphDephicationVVarMapping, "GraphDephicationVVarMapping")

angr/analyses/decompiler/dephication/rewriting_engine.py

@@ -0,0 +1,247 @@
+# pylint:disable=unused-argument,no-self-use
+from __future__ import annotations
+import logging
+
+from ailment.block import Block
+from ailment.statement import Statement, Assignment, Store, Call, Return, ConditionalJump
+from ailment.expression import (
+    Register,
+    VirtualVariable,
+    Load,
+    Const,
+    BinaryOp,
+    Phi,
+    Convert,
+    StackBaseOffset,
+    ITE,
+)
+
+from angr.engines.light import SimEngineLight, SimEngineLightAILMixin
+
+
+_l = logging.getLogger(__name__)
+
+
+class SimEngineDephiRewriting(
+    SimEngineLightAILMixin,
+    SimEngineLight,
+):
+    """
+    This engine rewrites every block to insert phi variables and replaces every used variable with their versioned
+    copies at each use location.
+    """
+
+    state: None
+
+    def __init__(
+        self,
+        arch,
+        vvar_to_vvar: dict[int, int],
+    ):
+        super().__init__()
+
+        self.arch = arch
+        self.vvar_to_vvar = vvar_to_vvar
+        self.out_block = None
+
+    def append_statement(self, stmt: Statement) -> None:
+        if self.out_block is None:
+            self.out_block = Block(self.block.addr, self.block.original_size, statements=[], idx=self.block.idx)
+        self.out_block.statements.append(stmt)
+
+    #
+    # Handlers
+    #
+
+    def _handle_Stmt(self, stmt: Statement):
+        new_stmt = super()._handle_Stmt(stmt)
+        if new_stmt is not None:
+            if type(new_stmt) is tuple:
+                for s in new_stmt:
+                    self.append_statement(s)
+            else:
+                self.append_statement(new_stmt)
+        else:
+            self.append_statement(stmt)
+
+    def _handle_Assignment(self, stmt: Assignment) -> Assignment | tuple[Assignment, ...] | None:
+        new_src = self._expr(stmt.src)
+        new_dst = None
+
+        if isinstance(stmt.dst, VirtualVariable) and stmt.dst.varid in self.vvar_to_vvar:
+            new_varid = self.vvar_to_vvar[stmt.dst.varid]
+            new_dst = VirtualVariable(
+                stmt.dst.idx,
+                new_varid,
+                stmt.dst.bits,
+                stmt.dst.category,
+                oident=stmt.dst.oident,
+                variable=stmt.dst.variable,
+                variable_offset=stmt.dst.variable_offset,
+                **stmt.dst.tags,
+            )
+
+        if new_dst is not None or new_src is not None:
+            return Assignment(
+                stmt.idx,
+                stmt.dst if new_dst is None else new_dst,
+                stmt.src if new_src is None else new_src,
+                **stmt.tags,
+            )
+        return None
+
+    def _handle_Store(self, stmt: Store) -> Store | None:
+        new_addr = self._expr(stmt.addr)
+        new_data = self._expr(stmt.data)
+
+        if new_addr is not None or new_data is not None:
+            return Store(
+                stmt.idx,
+                stmt.addr if new_addr is None else new_addr,
+                stmt.data if new_data is None else new_data,
+                stmt.size,
+                stmt.endness,
+                variable=stmt.variable,
+                guard=stmt.guard,
+                **stmt.tags,
+            )
+
+        return None
+
+    def _handle_ConditionalJump(self, stmt: ConditionalJump) -> ConditionalJump | None:
+        new_cond = self._expr(stmt.condition)
+        new_true_target = self._expr(stmt.true_target) if stmt.true_target is not None else None
+        new_false_target = self._expr(stmt.false_target) if stmt.false_target is not None else None
+
+        if new_cond is not None or new_true_target is not None or new_false_target is not None:
+            return ConditionalJump(
+                stmt.idx,
+                stmt.condition if new_cond is None else new_cond,
+                stmt.true_target if new_true_target is None else new_true_target,
+                stmt.false_target if new_false_target is None else new_false_target,
+                true_target_idx=stmt.true_target_idx,
+                false_target_idx=stmt.false_target_idx,
+                **stmt.tags,
+            )
+        return None
+
+    def _handle_Call(self, stmt: Call) -> Call | None:
+        new_target = self._expr(stmt.target) if stmt.target is not None else None
+        new_ret_expr = self._expr(stmt.ret_expr) if stmt.ret_expr is not None else None
+        new_fp_ret_expr = self._expr(stmt.fp_ret_expr) if stmt.fp_ret_expr is not None else None
+
+        if new_target is not None or new_ret_expr is not None or new_fp_ret_expr is not None:
+            return Call(
+                stmt.idx,
+                stmt.target if new_target is None else new_target,
+                calling_convention=stmt.calling_convention,
+                prototype=stmt.prototype,
+                args=stmt.args,
+                ret_expr=stmt.ret_expr if new_ret_expr is None else new_ret_expr,
+                fp_ret_expr=stmt.fp_ret_expr if new_fp_ret_expr is None else new_fp_ret_expr,
+                **stmt.tags,
+            )
+        return None
+
+    def _handle_Register(self, expr: Register) -> None:
+        return None
+
+    def _handle_Load(self, expr: Load) -> Load | None:
+        new_addr = self._expr(expr.addr)
+        if new_addr is not None:
+            return Load(expr.idx, new_addr, expr.size, expr.endness, guard=expr.guard, alt=expr.alt, **expr.tags)
+        return None
+
+    def _handle_Convert(self, expr: Convert) -> Convert | None:
+        new_operand = self._expr(expr.operand)
+        if new_operand is not None:
+            return Convert(
+                expr.idx,
+                expr.from_bits,
+                expr.to_bits,
+                expr.is_signed,
+                new_operand,
+                from_type=expr.from_type,
+                to_type=expr.to_type,
+                rounding_mode=expr.rounding_mode,
+                **expr.tags,
+            )
+        return None
+
+    def _handle_Const(self, expr: Const) -> None:
+        return None
+
+    def _handle_Phi(self, expr: Phi) -> None:
+        return None
+
+    def _handle_VirtualVariable(self, expr: VirtualVariable) -> VirtualVariable | None:
+        if expr.varid in self.vvar_to_vvar:
+            return VirtualVariable(
+                expr.idx,
+                self.vvar_to_vvar[expr.varid],
+                expr.bits,
+                expr.category,
+                oident=expr.oident,
+                variable=expr.variable,
+                variable_offset=expr.variable_offset,
+                **expr.tags,
+            )
+        return None
+
+    def _handle_Return(self, expr: Return) -> Return | None:
+        if expr.ret_exprs is None:
+            new_ret_exprs = None
+        else:
+            updated = False
+            new_ret_exprs = []
+            for r in expr.ret_exprs:
+                new_r = self._expr(r)
+                if new_r is not None:
+                    updated = True
+                new_ret_exprs.append(new_r if new_r is not None else None)
+            if not updated:
+                new_ret_exprs = None
+
+        if new_ret_exprs:
+            return Return(expr.idx, new_ret_exprs, **expr.tags)
+        return None
+
+    def _handle_BinaryOp(self, expr: BinaryOp) -> BinaryOp | None:
+        new_op0 = self._expr(expr.operands[0])
+        new_op1 = self._expr(expr.operands[1])
+
+        if new_op0 is not None or new_op1 is not None:
+            return BinaryOp(
+                expr.idx,
+                expr.op,
+                [
+                    expr.operands[0] if new_op0 is None else new_op0,
+                    expr.operands[1] if new_op1 is None else new_op1,
+                ],
+                expr.signed,
+                bits=expr.bits,
+                floating_point=expr.floating_point,
+                rounding_mode=expr.rounding_mode,
+                from_bits=expr.from_bits,
+                to_bits=expr.to_bits,
+                **expr.tags,
+            )
+        return None
+
+    def _handle_ITE(self, expr: ITE) -> ITE | None:
+        new_cond = self._expr(expr.cond)
+        new_iftrue = self._expr(expr.iftrue)
+        new_iffalse = self._expr(expr.iffalse)
+
+        if new_cond is not None or new_iftrue is not None or new_iffalse is not None:
+            return ITE(
+                expr.idx,
+                expr.cond if new_cond is None else new_cond,
+                expr.iftrue if new_iftrue is None else new_iftrue,
+                expr.iffalse if new_iffalse is None else new_iffalse,
+                **expr.tags,
+            )
+        return None
+
+    def _handle_StackBaseOffset(self, expr: StackBaseOffset) -> None:
+        return None

angr/analyses/decompiler/dephication/seqnode_dephication.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+from collections import defaultdict
+import logging
+from typing import Any
+
+from ailment.block import Block
+from ailment.statement import Assignment
+from ailment.expression import VirtualVariable, Phi
+
+from angr.utils.ail import is_phi_assignment
+from angr.knowledge_plugins.functions import Function
+from angr.analyses import register_analysis
+from angr.analyses.decompiler.structuring.structurer_nodes import SequenceNode
+from angr.analyses.decompiler.sequence_walker import SequenceWalker
+from .dephication_base import DephicationBase
+from .rewriting_engine import SimEngineDephiRewriting
+
+
+l = logging.getLogger(__name__)
+
+
+class PhiAssignmentCollector(SequenceWalker):
+    """
+    PhiAssignmentCollector collects all phi variables and their corresponding source virtual variables in a
+    SequenceNode.
+    """
+
+    def __init__(self, seq_node: SequenceNode):
+        super().__init__(
+            handlers={
+                Block: self._handle_Block,
+            }
+        )
+
+        self.phi_to_src: dict[int, set[int]] = defaultdict(set)
+
+        self.walk(seq_node)
+
+    def _handle_Block(self, block: Block, **kwargs) -> None:  # pylint:disable=unused-argument
+
+        for stmt in block.statements:
+            if isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable) and isinstance(stmt.src, Phi):
+                for _, vvar in stmt.src.src_and_vvars:
+                    if vvar is None:
+                        l.debug("Invalid vvar None found in %r.src.src_and_vvars.", stmt)
+                    else:
+                        self.phi_to_src[stmt.dst.varid].add(vvar.varid)
+
+
+class SeqNodeRewriter(SequenceWalker):
+    """
+    SeqNodeRewriter rewrites a SequenceNode by replacing all phi variables with their corresponding source virtual
+    variables.
+    """
+
+    def __init__(self, seq_node: SequenceNode, vvar_to_vvar: dict[int, int], arch):
+        super().__init__(
+            handlers={
+                Block: self._handle_Block,
+            }
+        )
+
+        self.vvar_to_vvar = vvar_to_vvar
+        self.engine = SimEngineDephiRewriting(arch, self.vvar_to_vvar)
+
+        self.output = self.walk(seq_node)
+        if self.output is None:
+            # nothing is changed during rewriting
+            self.output = seq_node
+
+    def _handle_Block(self, block: Block, **kwargs) -> Block | None:  # pylint:disable=unused-argument
+        self.engine.out_block = None
+        self.engine.process(None, block=block)
+        if self.engine.out_block is not None:
+            out = self.engine.out_block
+            out.statements = [stmt for stmt in out.statements if not is_phi_assignment(stmt)]
+            self.engine.out_block = None
+            return out
+        return None
+
+
+class SeqNodeDephication(DephicationBase):
+    """
+    SeqNodeDephication removes phi expressions from an AIL SeqNode and its children.
+    """
+
+    def __init__(
+        self, func: Function | str, seq_node, vvar_to_vvar_mapping: dict[int, int] | None = None, rewrite: bool = False
+    ):
+        super().__init__(func, vvar_to_vvar_mapping=vvar_to_vvar_mapping, rewrite=rewrite)
+
+        self._seq_node = seq_node
+
+        self._analyze()
+
+    def _collect_phi_assignments(self) -> dict[int, set[int]]:
+        # traverse children of the SequenceNode object and find all phi assignment statements
+        collector = PhiAssignmentCollector(self._seq_node)
+        return collector.phi_to_src
+
+    def _rewrite_container(self) -> Any:
+        rewriter = SeqNodeRewriter(self._seq_node, self.vvar_to_vvar_mapping, self.project.arch)
+        return rewriter.output
+
+
+register_analysis(SeqNodeDephication, "SeqNodeDephication")

angr/analyses/decompiler/empty_node_remover.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,no-self-use
+from __future__ import annotations
 from collections import OrderedDict
 
 import claripy