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

angr/analyses/decompiler/structuring/sailr.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 
 import networkx
@@ -15,7 +16,7 @@ class SAILRStructurer(PhoenixStructurer):
 
     At a high-level, SAILR does three things different from the traditional Phoenix schema-based algorithm:
     1. It recursively structures the graph, rather than doing it in a single pass. This allows decisions to be made
-        based on the currrent state of what the decompilation would look like.
+        based on the current state of what the decompilation would look like.
     2. It performs deoptimizations targeting specific optimizations that introduces gotos and mis-structured code.
         It can only do this because of the recursive nature of the algorithm.
     3. It uses a more advanced heuristic for virtualizing edges, which is implemented in this class.
@@ -41,8 +42,8 @@ class SAILRStructurer(PhoenixStructurer):
 
         # TODO: the graph we have here is not an accurate graph and can have no "entry node". We need a better graph.
         try:
-            entry_node = [node for node in graph.nodes if graph.in_degree(node) == 0][0]
-        except IndexError:
+            entry_node = next(node for node in graph.nodes if graph.in_degree(node) == 0)
+        except StopIteration:
             entry_node = None
 
         best_edges = edges
@@ -104,7 +105,7 @@ class SAILRStructurer(PhoenixStructurer):
 
                 if len(best_edges) == 1:
                     return best_edges
-                elif not best_edges:
+                if not best_edges:
                     best_edges = candidate_edges
 
         # if we have another tie, or we never used improved heuristics, then we do the default ordering.

angr/analyses/decompiler/structuring/structurer_base.py

@@ -1,5 +1,6 @@
 # pylint:disable=unused-argument
-from typing import Optional, Any, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 from collections import defaultdict, OrderedDict
 import logging
 
@@ -11,7 +12,7 @@ import claripy
 from ... import Analysis
 from ..condition_processor import ConditionProcessor
 from ..sequence_walker import SequenceWalker
-from ..utils import extract_jump_targets, insert_node, remove_last_statement
+from ..utils import extract_jump_targets, insert_node, remove_last_statement, has_nonlabel_nonphi_statements
 from .structurer_nodes import (
     MultiNode,
     SequenceNode,
@@ -49,12 +50,12 @@ class StructurerBase(Analysis):
         region,
         parent_map=None,
         condition_processor=None,
-        func: Optional["Function"] = None,
+        func: Function | None = None,
         case_entry_to_switch_head: dict[int, int] | None = None,
         parent_region=None,
         **kwargs,
     ):
-        self._region: "GraphRegion" = region
+        self._region: GraphRegion = region
         self._parent_map = parent_map
         self.function = func
         self._case_entry_to_switch_head = case_entry_to_switch_head
@@ -73,14 +74,14 @@ class StructurerBase(Analysis):
         self.result = None
 
     def _analyze(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     #
     # Basic structuring methods
     #
 
     def _structure_sequence(self, seq: SequenceNode):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     #
     # Util methods
@@ -417,7 +418,7 @@ class StructurerBase(Analysis):
                         elif label == "default":
                             parent.default_node.remove_node(node)
                         else:
-                            raise TypeError("Unsupported label %s." % label)
+                            raise TypeError(f"Unsupported label {label}.")
                     else:
                         # previous nodes
                         if stmt_idx > last_nonjump_stmt_idx:
@@ -607,7 +608,7 @@ class StructurerBase(Analysis):
                 new_node = BreakNode(last_stmt.ins_addr, last_stmt.false_target.value)
             else:
                 _l.warning("None of the branches is jumping to outside of the loop")
-                raise Exception()
+                raise Exception
 
         return new_node
 
@@ -620,10 +621,7 @@ class StructurerBase(Analysis):
             i = 0
             while i < len(seq_node.nodes):
                 old_node = seq_node.nodes[i]
-                if type(old_node) is CodeNode:
-                    node = old_node.node
-                else:
-                    node = old_node
+                node = old_node.node if type(old_node) is CodeNode else old_node
                 new_node = None
                 if isinstance(node, ConditionalBreakNode) and new_nodes:
                     prev_node = new_nodes[-1]
@@ -828,9 +826,7 @@ class StructurerBase(Analysis):
         addr = node_0.addr if node_0.addr is not None else node_1.addr
 
         # fix the last block of node_0 and remove useless goto statements
-        if isinstance(node_0, SequenceNode) and node_0.nodes:
-            last_node = node_0.nodes[-1]
-        elif isinstance(node_0, MultiNode) and node_0.nodes:
+        if isinstance(node_0, SequenceNode) and node_0.nodes or isinstance(node_0, MultiNode) and node_0.nodes:
             last_node = node_0.nodes[-1]
         elif isinstance(node_0, ailment.Block):
             last_node = node_0
@@ -868,13 +864,10 @@ class StructurerBase(Analysis):
         if isinstance(node_0, SequenceNode):
             if isinstance(node_1, SequenceNode):
                 return SequenceNode(addr, nodes=node_0.nodes + node_1.nodes)
-            else:
-                return SequenceNode(addr, nodes=node_0.nodes + [node_1])
-        else:
-            if isinstance(node_1, SequenceNode):
-                return SequenceNode(addr, nodes=[node_0] + node_1.nodes)
-            else:
-                return SequenceNode(addr, nodes=[node_0, node_1])
+            return SequenceNode(addr, nodes=[*node_0.nodes, node_1])
+        if isinstance(node_1, SequenceNode):
+            return SequenceNode(addr, nodes=[node_0, *node_1.nodes])
+        return SequenceNode(addr, nodes=[node_0, node_1])
 
     def _update_new_sequences(self, removed_sequences: set[SequenceNode], replaced_sequences: dict[SequenceNode, Any]):
         new_sequences = []
@@ -927,7 +920,7 @@ class StructurerBase(Analysis):
             if parent_node.true_node is old_node:
                 parent_node.true_node = new_node
                 return
-            elif parent_node.false_node is old_node:
+            if parent_node.false_node is old_node:
                 parent_node.false_node = new_node
                 return
         elif isinstance(parent_node, CascadingConditionNode):
@@ -949,3 +942,13 @@ class StructurerBase(Analysis):
             if isinstance(stmt.target, ailment.Expr.Const) and stmt.target.value == addr:
                 return True
         return False
+
+    @staticmethod
+    def has_nonlabel_nonphi_statements(node: BaseNode) -> bool:
+        if isinstance(node, ailment.Block):
+            return has_nonlabel_nonphi_statements(node)
+        if isinstance(node, MultiNode):
+            return any(has_nonlabel_nonphi_statements(b) for b in node.nodes)
+        if isinstance(node, SequenceNode):
+            return any(StructurerBase.has_nonlabel_nonphi_statements(nn) for nn in node.nodes)
+        return False

angr/analyses/decompiler/structuring/structurer_nodes.py

@@ -1,4 +1,5 @@
 # pylint:disable=missing-class-docstring
+from __future__ import annotations
 from typing import Any
 from collections import OrderedDict
 
@@ -28,9 +29,7 @@ class MultiNode:
         self.nodes = []
 
         for node in nodes:
-            if type(node) is MultiNode:
-                self.nodes += node.nodes
-            elif type(node) is GraphRegion:
+            if type(node) is MultiNode or type(node) is GraphRegion:
                 self.nodes += node.nodes
             else:
                 self.nodes.append(node)
@@ -72,13 +71,10 @@ class BaseNode:
 
     @staticmethod
     def test_empty_node(node):
-        # pylint:disable=simplifiable-if-statement
         if type(node) is ailment.Block:
-            if not node.statements:
-                return True
-            # not empty
-            return False
-        elif type(node) is CodeNode:
+            # is it empty?
+            return bool(not node.statements)
+        if type(node) is CodeNode:
             return BaseNode.test_empty_node(node.node)
         # unsupported node type. probably not empty?
         return False
@@ -115,8 +111,7 @@ class SequenceNode(BaseNode):
     def __repr__(self):
         if self.addr is None:
             return "<SequenceNode, %d nodes>" % len(self.nodes)
-        else:
-            return "<SequenceNode %#x, %d nodes>" % (self.addr, len(self.nodes))
+        return "<SequenceNode %#x, %d nodes>" % (self.addr, len(self.nodes))
 
     def add_node(self, node):
         self.nodes.append(node)
@@ -156,16 +151,14 @@ class CodeNode(BaseNode):
         if self.addr is not None:
             if self.idx is not None:
                 return f"<CodeNode {self.addr:#x}.{self.idx}>"
-            return "<CodeNode %#x>" % self.addr
-        else:
-            return "<CodeNode %s>" % repr(self.node)
+            return f"<CodeNode {self.addr:#x}>"
+        return f"<CodeNode {self.node!r}>"
 
     @property
     def addr(self):
         if hasattr(self.node, "addr"):
             return self.node.addr
-        else:
-            return None
+        return None
 
     @property
     def idx(self):
@@ -226,9 +219,8 @@ class ConditionNode(BaseNode):
 
     def __repr__(self):
         if self.addr is not None:
-            return "<ConditionNode %#x>" % self.addr
-        else:
-            return f"<ConditionNode ({self.true_node!r}|{self.false_node!r})>"
+            return f"<ConditionNode {self.addr:#x}>"
+        return f"<ConditionNode ({self.true_node!r}|{self.false_node!r})>"
 
 
 class CascadingConditionNode(BaseNode):
@@ -278,15 +270,13 @@ class LoopNode(BaseNode):
     def addr(self):
         if self._addr is None:
             return self.sequence_node.addr
-        else:
-            return self._addr
+        return self._addr
 
     @property
     def continue_addr(self):
         if self._continue_addr is None:
             return self.addr
-        else:
-            return self._continue_addr
+        return self._continue_addr
 
     @continue_addr.setter
     def continue_addr(self, value):
@@ -404,7 +394,7 @@ class IncompleteSwitchCaseHeadStatement(ailment.statement.Statement):
         return f"SwitchCaseHead: switch {self.switch_variable} with {len(self.case_addrs)} cases"
 
     def __str__(self):
-        return f"switch ({str(self.switch_variable)}): {len(self.case_addrs)} cases"
+        return f"switch ({self.switch_variable!s}): {len(self.case_addrs)} cases"
 
     __hash__ = ailment.statement.TaggedObject.__hash__
 

angr/analyses/decompiler/utils.py

@@ -1,7 +1,8 @@
-# pylint:disable=wrong-import-position,broad-exception-caught,ungrouped-imports
+# pylint:disable=wrong-import-position,broad-exception-caught,ungrouped-imports,import-outside-toplevel
+from __future__ import annotations
 import pathlib
 import copy
-from typing import Any, Union
+from typing import Any
 from collections.abc import Iterable
 import logging
 
@@ -9,7 +10,8 @@ import networkx
 import ailment
 
 import angr
-from .call_counter import AILBlockCallCounter
+from angr.analyses.decompiler.counters.call_counter import AILBlockCallCounter
+from angr.utils.ail import is_phi_assignment
 from .seq_to_blocks import SequenceToBlocks
 
 _l = logging.getLogger(__name__)
@@ -23,12 +25,7 @@ def remove_last_statement(node):
     elif type(node) is ailment.Block:
         stmt = node.statements[-1]
         node.statements = node.statements[:-1]
-    elif type(node) is MultiNode:
-        if node.nodes:
-            stmt = remove_last_statement(node.nodes[-1])
-            if BaseNode.test_empty_node(node.nodes[-1]):
-                node.nodes = node.nodes[:-1]
-    elif type(node) is SequenceNode:
+    elif type(node) is MultiNode or type(node) is SequenceNode:
         if node.nodes:
             stmt = remove_last_statement(node.nodes[-1])
             if BaseNode.test_empty_node(node.nodes[-1]):
@@ -43,7 +40,7 @@ def remove_last_statement(node):
     elif type(node) is LoopNode:
         stmt = remove_last_statement(node.sequence_node)
     else:
-        raise NotImplementedError()
+        raise NotImplementedError
 
     return stmt
 
@@ -59,16 +56,16 @@ def append_statement(node, stmt):
         if node.nodes:
             append_statement(node.nodes[-1], stmt)
         else:
-            raise NotImplementedError()
+            raise NotImplementedError
         return
     if type(node) is SequenceNode:
         if node.nodes:
             append_statement(node.nodes[-1], stmt)
         else:
-            raise NotImplementedError()
+            raise NotImplementedError
         return
 
-    raise NotImplementedError()
+    raise NotImplementedError
 
 
 def replace_last_statement(node, old_stmt, new_stmt):
@@ -94,7 +91,7 @@ def replace_last_statement(node, old_stmt, new_stmt):
             replace_last_statement(node.false_node, old_stmt, new_stmt)
         return
 
-    raise NotImplementedError()
+    raise NotImplementedError
 
 
 def extract_jump_targets(stmt):
@@ -228,7 +225,7 @@ def insert_node(parent, insert_location: str, node, node_idx: int | tuple[int] |
             elif insert_location == "before":
                 new_nodes = [node, parent.default_node]
             else:
-                raise TypeError("Unsupported 'insert_location' value %r." % insert_location)
+                raise TypeError(f"Unsupported 'insert_location' value {insert_location!r}.")
             seq = SequenceNode(new_nodes[0].addr, nodes=new_nodes)
             parent.default_node = seq
         else:
@@ -243,9 +240,9 @@ def insert_node(parent, insert_location: str, node, node_idx: int | tuple[int] |
                 parent.sequence_node = SequenceNode(parent.sequence_node.addr, nodes=[parent.sequence_node])
             insert_node(parent.sequence_node, insert_location, node, node_idx)
         else:
-            raise NotImplementedError()
+            raise NotImplementedError
     else:
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 def _merge_ail_nodes(graph, node_a: ailment.Block, node_b: ailment.Block) -> ailment.Block:
@@ -280,7 +277,7 @@ def _merge_ail_nodes(graph, node_a: ailment.Block, node_b: ailment.Block) -> ail
     return new_node
 
 
-def to_ail_supergraph(transition_graph: networkx.DiGraph) -> networkx.DiGraph:
+def to_ail_supergraph(transition_graph: networkx.DiGraph, allow_fake=False) -> networkx.DiGraph:
     """
     Takes an AIL graph and converts it into a AIL graph that treats calls and redundant jumps
     as parts of a bigger block instead of transitions. Calls to returning functions do not terminate basic blocks.
@@ -299,7 +296,7 @@ def to_ail_supergraph(transition_graph: networkx.DiGraph) -> networkx.DiGraph:
 
             if len(list(transition_graph.successors(src))) == 1 and len(list(transition_graph.predecessors(dst))) == 1:
                 # calls in the middle of blocks OR boring jumps
-                if (type_ == "fake_return") or (src.addr + src.original_size == dst.addr):
+                if (type_ == "fake_return") or (src.addr + src.original_size == dst.addr) or allow_fake:
                     _merge_ail_nodes(transition_graph, src, dst)
                     break
 
@@ -337,7 +334,13 @@ def has_nonlabel_statements(block: ailment.Block) -> bool:
     return block.statements and any(not isinstance(stmt, ailment.Stmt.Label) for stmt in block.statements)
 
 
-def first_nonlabel_statement(block: Union[ailment.Block, "MultiNode"]) -> ailment.Stmt.Statement | None:
+def has_nonlabel_nonphi_statements(block: ailment.Block) -> bool:
+    return block.statements and any(
+        not (isinstance(stmt, ailment.Stmt.Label) or is_phi_assignment(stmt)) for stmt in block.statements
+    )
+
+
+def first_nonlabel_statement(block: ailment.Block | MultiNode) -> ailment.Stmt.Statement | None:
     if isinstance(block, MultiNode):
         for n in block.nodes:
             stmt = first_nonlabel_statement(n)
@@ -351,6 +354,27 @@ def first_nonlabel_statement(block: Union[ailment.Block, "MultiNode"]) -> ailmen
     return None
 
 
+def first_nonlabel_statement_id(block: ailment.Block) -> int | None:
+    for idx, stmt in enumerate(block.statements):
+        if not isinstance(stmt, ailment.Stmt.Label):
+            return idx
+    return len(block.statements)
+
+
+def first_nonlabel_nonphi_statement(block: ailment.Block | MultiNode) -> ailment.Stmt.Statement | None:
+    if isinstance(block, MultiNode):
+        for n in block.nodes:
+            stmt = first_nonlabel_nonphi_statement(n)
+            if stmt is not None:
+                return stmt
+        return None
+
+    for stmt in block.statements:
+        if not (isinstance(stmt, ailment.Stmt.Label) or is_phi_assignment(stmt)):
+            return stmt
+    return None
+
+
 def last_nonlabel_statement(block: ailment.Block) -> ailment.Stmt.Statement | None:
     for stmt in reversed(block.statements):
         if not isinstance(stmt, ailment.Stmt.Label):
@@ -358,18 +382,24 @@ def last_nonlabel_statement(block: ailment.Block) -> ailment.Stmt.Statement | No
     return None
 
 
-def first_nonlabel_node(seq: "SequenceNode") -> Union["BaseNode", ailment.Block] | None:
+def first_nonlabel_node(seq: SequenceNode) -> BaseNode | ailment.Block | None:
     for node in seq.nodes:
-        if isinstance(node, CodeNode):
-            inner_node = node.node
-        else:
-            inner_node = node
+        inner_node = node.node if isinstance(node, CodeNode) else node
         if isinstance(inner_node, ailment.Block) and not has_nonlabel_statements(inner_node):
             continue
         return node
     return None
 
 
+def first_nonlabel_nonphi_node(seq: SequenceNode) -> BaseNode | ailment.Block | None:
+    for node in seq.nodes:
+        inner_node = node.node if isinstance(node, CodeNode) else node
+        if isinstance(inner_node, ailment.Block) and not has_nonlabel_nonphi_statements(inner_node):
+            continue
+        return node
+    return None
+
+
 def remove_labels(graph: networkx.DiGraph):
     new_graph = networkx.DiGraph()
     nodes_map = {}
@@ -378,7 +408,9 @@ def remove_labels(graph: networkx.DiGraph):
         node_copy.statements = [stmt for stmt in node_copy.statements if not isinstance(stmt, ailment.Stmt.Label)]
         nodes_map[node] = node_copy
 
-    new_graph.add_nodes_from(nodes_map.values())
+    for old_node in graph.nodes:
+        new_graph.add_node(nodes_map[old_node])
+
     for src, dst, data in graph.edges(data=True):
         new_graph.add_edge(nodes_map[src], nodes_map[dst], **data)
 
@@ -391,10 +423,12 @@ def add_labels(graph: networkx.DiGraph):
     for node in graph:
         lbl = ailment.Stmt.Label(None, f"LABEL_{node.addr:x}", node.addr, block_idx=node.idx)
         node_copy = node.copy()
-        node_copy.statements = [lbl] + node_copy.statements
+        node_copy.statements = [lbl, *node_copy.statements]
         nodes_map[node] = node_copy
 
-    new_graph.add_nodes_from(nodes_map.values())
+    for old_node in graph.nodes:
+        new_graph.add_node(nodes_map[old_node])
+
     for src, dst in graph.edges:
         new_graph.add_edge(nodes_map[src], nodes_map[dst])
 
@@ -410,7 +444,7 @@ def update_labels(graph: networkx.DiGraph):
 
 
 def structured_node_is_simple_return(
-    node: Union["SequenceNode", "MultiNode"], graph: networkx.DiGraph, use_packed_successors=False
+    node: SequenceNode | MultiNode, graph: networkx.DiGraph, use_packed_successors=False
 ) -> bool:
     """
     Will check if a "simple return" is contained within the node a simple returns looks like this:
@@ -424,7 +458,7 @@ def structured_node_is_simple_return(
     Returns true on any block ending in linear statements and a return.
     """
 
-    def _flatten_structured_node(packed_node: Union["SequenceNode", "MultiNode"]) -> list[ailment.Block]:
+    def _flatten_structured_node(packed_node: SequenceNode | MultiNode) -> list[ailment.Block]:
         if not packed_node or not packed_node.nodes:
             return []
 
@@ -457,7 +491,15 @@ def structured_node_is_simple_return(
     if use_packed_successors:
         last_block = node
 
-    return valid_last_stmt and last_block in graph and not list(graph.successors(last_block))
+    if valid_last_stmt:
+        # note that the block may not be the same block in the AIL graph post dephication. we must find the block again
+        # in the graph.
+        for bb in graph:
+            if bb.addr == last_block.addr and bb.idx == last_block.idx:
+                # found it
+                succs = list(graph.successors(bb))
+                return not succs or succs == [bb]
+    return False
 
 
 def is_statement_terminating(stmt: ailment.statement.Statement, functions) -> bool:
@@ -485,6 +527,11 @@ def peephole_optimize_exprs(block, expr_opts):
     def _handle_expr(
         expr_idx: int, expr: ailment.Expr.Expression, stmt_idx: int, stmt: ailment.Stmt.Statement | None, block
     ) -> ailment.Expr.Expression | None:
+        # process the expr
+        processed = ailment.AILBlockWalker._handle_expr(walker, expr_idx, expr, stmt_idx, stmt, block)
+
+        if processed is not None:
+            expr = processed
         old_expr = expr
 
         redo = True
@@ -500,11 +547,8 @@ def peephole_optimize_exprs(block, expr_opts):
 
         if expr is not old_expr:
             _any_update.v = True
-            # continue to process the expr
-            r = ailment.AILBlockWalker._handle_expr(walker, expr_idx, expr, stmt_idx, stmt, block)
-            return expr if r is None else r
 
-        return ailment.AILBlockWalker._handle_expr(walker, expr_idx, expr, stmt_idx, stmt, block)
+        return expr
 
     # run expression optimizers
     walker = ailment.AILBlockWalker()
@@ -541,9 +585,7 @@ def peephole_optimize_expr(expr, expr_opts):
     # run expression optimizers
     walker = ailment.AILBlockWalker()
     walker._handle_expr = _handle_expr
-    new_expr = walker._handle_expr(0, expr, 0, None, None)
-
-    return new_expr
+    return walker._handle_expr(0, expr, 0, None, None)
 
 
 def copy_graph(graph: networkx.DiGraph):
@@ -645,7 +687,14 @@ def peephole_optimize_multistmts(block, stmt_opts):
     return statements, any_update
 
 
-def decompile_functions(path, functions=None, structurer=None, catch_errors=False) -> str | None:
+def decompile_functions(
+    path,
+    functions: list[int | str] | None = None,
+    structurer: str | None = None,
+    catch_errors: bool = False,
+    show_casts: bool = True,
+    base_address: int | None = None,
+) -> str | None:
     """
     Decompile a binary into a set of functions.
 
@@ -653,29 +702,34 @@ def decompile_functions(path, functions=None, structurer=None, catch_errors=Fals
     :param functions:       The functions to decompile. If None, all functions will be decompiled.
     :param structurer:      The structuring algorithms to use.
     :param catch_errors:    The structuring algorithms to use.
+    :param show_casts:      Whether to show casts in the decompiled output.
+    :param base_address:    The base address of the binary.
     :return:                The decompilation of all functions appended in order.
     """
     # delayed imports to avoid circular imports
     from angr.analyses.decompiler.decompilation_options import PARAM_TO_OPTION
+    from angr.analyses.decompiler.structuring import DEFAULT_STRUCTURER
+
+    structurer = structurer or DEFAULT_STRUCTURER.NAME
 
-    structurer = structurer or "phoenix"
     path = pathlib.Path(path).resolve().absolute()
-    proj = angr.Project(path, auto_load_libs=False)
+    # resolve loader args
+    loader_main_opts_kwargs = {}
+    if base_address is not None:
+        loader_main_opts_kwargs["base_addr"] = base_address
+    proj = angr.Project(path, auto_load_libs=False, main_opts=loader_main_opts_kwargs)
     cfg = proj.analyses.CFG(normalize=True, data_references=True)
     proj.analyses.CompleteCallingConventions(recover_variables=True, analyze_callsites=True)
 
     # collect all functions when None are provided
     if functions is None:
-        functions = list(sorted(cfg.kb.functions))
+        functions = sorted(cfg.kb.functions)
 
     # normalize the functions that could be ints as names
     normalized_functions: list[int | str] = []
     for func in functions:
         try:
-            if isinstance(func, str):
-                normalized_name = int(func, 0)
-            else:
-                normalized_name = func
+            normalized_name = int(func, 0) if isinstance(func, str) else func
         except ValueError:
             normalized_name = func
         normalized_functions.append(normalized_name)
@@ -694,6 +748,7 @@ def decompile_functions(path, functions=None, structurer=None, catch_errors=Fals
     decompilation = ""
     dec_options = [
         (PARAM_TO_OPTION["structurer_cls"], structurer),
+        (PARAM_TO_OPTION["show_casts"], show_casts),
     ]
     for func in functions:
         f = cfg.functions[func]
@@ -740,15 +795,20 @@ def calls_in_graph(graph: networkx.DiGraph) -> int:
     return counter.calls
 
 
-def find_block_by_addr(graph: networkx.DiGraph, addr: int):
+def find_block_by_addr(graph: networkx.DiGraph, addr, insn_addr=False):
     for block in graph.nodes():
-        if block.addr == addr:
-            return block
+        if insn_addr:
+            for stmt in block.statements:
+                if "ins_addr" in stmt.tags and stmt.ins_addr == addr:
+                    return block
+        else:
+            if block.addr == addr:
+                return block
 
-    raise KeyError("The block is not in the graph!")
+    raise ValueError("The block is not in the graph!")
 
 
-def sequence_to_blocks(seq: "BaseNode") -> list[ailment.Block]:
+def sequence_to_blocks(seq: BaseNode) -> list[ailment.Block]:
     """
     Converts a sequence node (BaseNode) to a list of ailment blocks contained in it and all its children.
     """
@@ -758,7 +818,7 @@ def sequence_to_blocks(seq: "BaseNode") -> list[ailment.Block]:
 
 
 def sequence_to_statements(
-    seq: "BaseNode", exclude=(ailment.statement.Jump, ailment.statement.Jump)
+    seq: BaseNode, exclude=(ailment.statement.Jump, ailment.statement.Jump)
 ) -> list[ailment.statement.Statement]:
     """
     Converts a sequence node (BaseNode) to a list of ailment Statements contained in it and all its children.