angr 9.2.102__py3-none-manylinux2014_x86_64.whl → 9.2.104__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/decompilation_options.py

@@ -1,5 +1,5 @@
 # decompilation options
-from typing import Optional, List, Callable
+from collections.abc import Callable
 from collections import defaultdict
 
 from .structuring import structurer_class_from_name
@@ -22,8 +22,8 @@ class DecompilationOption:
         category="General",
         default_value=None,
         clears_cache=True,
-        candidate_values: Optional[List] = None,
-        convert: Optional[Callable] = None,
+        candidate_values: list | None = None,
+        convert: Callable | None = None,
     ):
         self.NAME = name
         self.DESCRIPTION = description
@@ -267,7 +267,7 @@ for o in options:
 #
 
 
-def get_structurer_option() -> Optional[DecompilationOption]:
+def get_structurer_option() -> DecompilationOption | None:
     for opt in options:
         if opt.cls == "recursive_structurer" and opt.param == "structurer_cls":
             return opt

angr/analyses/decompiler/decompiler.py

@@ -1,7 +1,8 @@
 # pylint:disable=unused-import
 import logging
 from collections import defaultdict
-from typing import List, Tuple, Optional, Iterable, Union, Type, Set, Dict, Any, TYPE_CHECKING
+from typing import Optional, Union, Any, TYPE_CHECKING
+from collections.abc import Iterable
 
 import networkx
 from cle import SymbolType
@@ -33,7 +34,7 @@ if TYPE_CHECKING:
 l = logging.getLogger(name=__name__)
 
 _PEEPHOLE_OPTIMIZATIONS_TYPE = Optional[
-    Iterable[Union[Type["PeepholeOptimizationStmtBase"], Type["PeepholeOptimizationExprBase"]]]
+    Iterable[Union[type["PeepholeOptimizationStmtBase"], type["PeepholeOptimizationExprBase"]]]
 ]
 
 
@@ -47,14 +48,14 @@ class Decompiler(Analysis):
 
     def __init__(
         self,
-        func: Union[Function, str, int],
-        cfg: Optional[Union["CFGFast", "CFGModel"]] = None,
+        func: Function | str | int,
+        cfg: Union["CFGFast", "CFGModel"] | None = None,
         options=None,
         optimization_passes=None,
         sp_tracker_track_memory=True,
         variable_kb=None,
         peephole_optimizations: _PEEPHOLE_OPTIMIZATIONS_TYPE = None,
-        vars_must_struct: Optional[Set[str]] = None,
+        vars_must_struct: set[str] | None = None,
         flavor="pseudocode",
         expr_comments=None,
         stmt_comments=None,
@@ -62,6 +63,7 @@ class Decompiler(Analysis):
         binop_operators=None,
         decompile=True,
         regen_clinic=True,
+        inline_functions=frozenset(),
         update_memory_data: bool = True,
         generate_code: bool = True,
     ):
@@ -87,14 +89,15 @@ class Decompiler(Analysis):
         self._regen_clinic = regen_clinic
         self._update_memory_data = update_memory_data
         self._generate_code = generate_code
+        self._inline_functions = inline_functions
 
         self.clinic = None  # mostly for debugging purposes
         self.codegen: Optional["CStructuredCodeGenerator"] = None
-        self.cache: Optional[DecompilationCache] = None
+        self.cache: DecompilationCache | None = None
         self.options_by_class = None
         self.seq_node: Optional["SequenceNode"] = None
-        self.unoptimized_ail_graph: Optional[networkx.DiGraph] = None
-        self.ail_graph: Optional[networkx.DiGraph] = None
+        self.unoptimized_ail_graph: networkx.DiGraph | None = None
+        self.ail_graph: networkx.DiGraph | None = None
 
         if decompile:
             self._decompile()
@@ -171,6 +174,7 @@ class Decompiler(Analysis):
                 must_struct=self._vars_must_struct,
                 cache=cache,
                 progress_callback=progress_callback,
+                inline_functions=self._inline_functions,
                 **self.options_to_params(self.options_by_class["clinic"]),
             )
         else:
@@ -295,8 +299,8 @@ class Decompiler(Analysis):
         :param reaching_defenitions: ReachingDefenitionAnalysis
         :return:            The possibly new AIL DiGraph and RegionIdentifier
         """
-        addr_and_idx_to_blocks: Dict[Tuple[int, Optional[int]], ailment.Block] = {}
-        addr_to_blocks: Dict[int, Set[ailment.Block]] = defaultdict(set)
+        addr_and_idx_to_blocks: dict[tuple[int, int | None], ailment.Block] = {}
+        addr_to_blocks: dict[int, set[ailment.Block]] = defaultdict(set)
 
         # update blocks_map to allow node_addr to node lookup
         def _updatedict_handler(node):
@@ -346,8 +350,8 @@ class Decompiler(Analysis):
         :param reaching_defenitions: ReachingDefenitionAnalysis
         :return:            The possibly new AIL DiGraph and RegionIdentifier
         """
-        addr_and_idx_to_blocks: Dict[Tuple[int, Optional[int]], ailment.Block] = {}
-        addr_to_blocks: Dict[int, Set[ailment.Block]] = defaultdict(set)
+        addr_and_idx_to_blocks: dict[tuple[int, int | None], ailment.Block] = {}
+        addr_to_blocks: dict[int, set[ailment.Block]] = defaultdict(set)
 
         # update blocks_map to allow node_addr to node lookup
         def _updatedict_handler(node):
@@ -415,7 +419,7 @@ class Decompiler(Analysis):
                     SimMemoryVariable(symbol.rebased_addr, 1, name=symbol.name, ident=ident),
                 )
 
-    def reflow_variable_types(self, type_constraints: Set, func_typevar, var_to_typevar: Dict, codegen):
+    def reflow_variable_types(self, type_constraints: set, func_typevar, var_to_typevar: dict, codegen):
         """
         Re-run type inference on an existing variable recovery result, then rerun codegen to generate new results.
 
@@ -485,7 +489,7 @@ class Decompiler(Analysis):
         return codegen
 
     def find_data_references_and_update_memory_data(self, seq_node: "SequenceNode"):
-        const_values: Set[int] = set()
+        const_values: set[int] = set()
 
         def _handle_Const(expr_idx: int, expr: ailment.Expr.Const, *args, **kwargs):  # pylint:disable=unused-argument
             const_values.add(expr.value)
@@ -520,7 +524,7 @@ class Decompiler(Analysis):
         )
 
     @staticmethod
-    def options_to_params(options: List[Tuple[DecompilationOption, Any]]) -> Dict[str, Any]:
+    def options_to_params(options: list[tuple[DecompilationOption, Any]]) -> dict[str, Any]:
         """
         Convert decompilation options to a dict of params.
 

angr/analyses/decompiler/expression_counters.py

@@ -1,4 +1,5 @@
-from typing import Optional, Any, DefaultDict, Tuple, Union, Iterable, Set, TYPE_CHECKING
+from typing import Any, DefaultDict, TYPE_CHECKING
+from collections.abc import Iterable
 from collections import defaultdict
 
 from ailment.expression import Expression, Register
@@ -22,7 +23,7 @@ class SingleExpressionCounter(AILBlockWalkerBase):
         self.walk_statement(stmt)
 
     def _handle_expr(
-        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Optional[Statement], block: Optional[Block]
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
     ) -> Any:
         if expr == self.subexpr:
             self.count += 1
@@ -34,9 +35,9 @@ class RegisterExpressionCounter(AILBlockWalkerBase):
     Count the occurrence of all register expressions in expr
     """
 
-    def __init__(self, expr_or_stmt: Union[Expression, Statement]):
+    def __init__(self, expr_or_stmt: Expression | Statement):
         super().__init__()
-        self.counts: DefaultDict[Tuple[int, int], int] = defaultdict(int)
+        self.counts: DefaultDict[tuple[int, int], int] = defaultdict(int)
         if isinstance(expr_or_stmt, Expression):
             self.walk_expression(expr_or_stmt)
         elif isinstance(expr_or_stmt, Statement):
@@ -44,7 +45,7 @@ class RegisterExpressionCounter(AILBlockWalkerBase):
         else:
             raise TypeError(f"Unsupported argument type {type(expr_or_stmt)}")
 
-    def _handle_Register(self, expr_idx: int, expr: Register, stmt_idx: int, stmt: Statement, block: Optional[Block]):
+    def _handle_Register(self, expr_idx: int, expr: Register, stmt_idx: int, stmt: Statement, block: Block | None):
         self.counts[expr.reg_offset, expr.size] += 1
 
 
@@ -53,10 +54,10 @@ class OperatorCounter(AILBlockWalkerBase):
     Count the occurrence of a given expression operator.
     """
 
-    def __init__(self, operator: Union[str, Iterable[str]], expr_or_stmt: Union[Expression, Statement]):
+    def __init__(self, operator: str | Iterable[str], expr_or_stmt: Expression | Statement):
         super().__init__()
         self.count = 0
-        self.operators: Set[str] = {operator} if isinstance(operator, str) else set(operator)
+        self.operators: set[str] = {operator} if isinstance(operator, str) else set(operator)
         if isinstance(expr_or_stmt, Expression):
             self.walk_expression(expr_or_stmt)
         elif isinstance(expr_or_stmt, Statement):
@@ -64,12 +65,12 @@ class OperatorCounter(AILBlockWalkerBase):
         else:
             raise TypeError(f"Unsupported argument type {type(expr_or_stmt)}")
 
-    def _handle_BinaryOp(self, expr_idx: int, expr: "BinaryOp", stmt_idx: int, stmt: Statement, block: Optional[Block]):
+    def _handle_BinaryOp(self, expr_idx: int, expr: "BinaryOp", stmt_idx: int, stmt: Statement, block: Block | None):
         if expr.op in self.operators:
             self.count += 1
         return super()._handle_BinaryOp(expr_idx, expr, stmt_idx, stmt, block)
 
-    def _handle_UnaryOp(self, expr_idx: int, expr: "UnaryOp", stmt_idx: int, stmt: Statement, block: Optional[Block]):
+    def _handle_UnaryOp(self, expr_idx: int, expr: "UnaryOp", stmt_idx: int, stmt: Statement, block: Block | None):
         if expr.op in self.operators:
             self.count += 1
         return super()._handle_UnaryOp(expr_idx, expr, stmt_idx, stmt, block)

angr/analyses/decompiler/goto_manager.py

@@ -1,5 +1,3 @@
-from typing import Set
-
 import ailment
 
 
@@ -40,7 +38,7 @@ class GotoManager:
 
     def __init__(self, func, gotos=None):
         self.func = func
-        self.gotos: Set[Goto] = gotos or set()
+        self.gotos: set[Goto] = gotos or set()
 
         self._gotos_by_addr = None
 
@@ -50,7 +48,7 @@ class GotoManager:
     def __repr__(self):
         return self.__str__()
 
-    def gotos_in_block(self, block: ailment.Block) -> Set[Goto]:
+    def gotos_in_block(self, block: ailment.Block) -> set[Goto]:
         gotos_found = set()
         for goto in self.gotos:
             if goto.src_addr == block.addr:

angr/analyses/decompiler/graph_region.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Optional, List, Set, Tuple
+from typing import Any
 from collections import defaultdict
 
 import networkx
@@ -37,10 +37,10 @@ class GraphRegion:
         self,
         head,
         graph,
-        successors: Optional[Set],
-        graph_with_successors: Optional[networkx.DiGraph],
+        successors: set | None,
+        graph_with_successors: networkx.DiGraph | None,
         cyclic,
-        full_graph: Optional[networkx.DiGraph],
+        full_graph: networkx.DiGraph | None,
         cyclic_ancestor: bool = False,
     ):
         self.head = head
@@ -61,7 +61,7 @@ class GraphRegion:
         self._replaced_regions = {}
 
     def __repr__(self):
-        addrs: List[int] = []
+        addrs: list[int] = []
         s = ""
         if self.graph is None:
             # only head is available
@@ -197,7 +197,7 @@ class GraphRegion:
         sub_region: "GraphRegion",
         updated_sub_region: "GraphRegion",
         replace_with,
-        virtualized_edges: Set[Tuple[Any, Any]],
+        virtualized_edges: set[tuple[Any, Any]],
     ):
         if sub_region not in self.graph:
             l.error("The sub-region to replace must be in the current region. Note that this method is not recursive.")
@@ -299,7 +299,7 @@ class GraphRegion:
             )
 
     @staticmethod
-    def _replace_node_in_graph(graph: networkx.DiGraph, node, replace_with, removed_edges: Set):
+    def _replace_node_in_graph(graph: networkx.DiGraph, node, replace_with, removed_edges: set):
         in_edges = [(src, dst) for src, dst in graph.in_edges(node) if (src, dst) not in removed_edges]
         out_edges = [(src, dst) for src, dst in graph.out_edges(node) if (src, dst) not in removed_edges]
 
@@ -323,8 +323,8 @@ class GraphRegion:
     def _replace_node_in_graph_with_subgraph(
         self,
         graph: networkx.DiGraph,
-        known_successors: Optional[List],
-        reference_full_graph: Optional[networkx.DiGraph],
+        known_successors: list | None,
+        reference_full_graph: networkx.DiGraph | None,
         node,
         sub_graph: networkx.DiGraph,
         sub_graph_head,

angr/analyses/decompiler/jump_target_collector.py

@@ -1,5 +1,4 @@
 # pylint:disable=unused-argument
-from typing import Set, Tuple, Optional
 
 import ailment
 
@@ -13,7 +12,7 @@ class JumpTargetCollector:
 
     def __init__(self, node):
         self.root = node
-        self.jump_targets: Set[Tuple[int, Optional[int]]] = set()
+        self.jump_targets: set[tuple[int, int | None]] = set()
 
         handlers = {
             ailment.Block: self._handle_Block,

angr/analyses/decompiler/optimization_passes/__init__.py

@@ -17,6 +17,7 @@ from .return_duplicator_low import ReturnDuplicatorLow
 from .return_duplicator_high import ReturnDuplicatorHigh
 from .const_derefs import ConstantDereferencesSimplifier
 from .register_save_area_simplifier import RegisterSaveAreaSimplifier
+from .spilled_register_finder import SpilledRegisterFinder
 from .ret_addr_save_simplifier import RetAddrSaveSimplifier
 from .x86_gcc_getpc_simplifier import X86GccGetPcSimplifier
 from .flip_boolean_cmp import FlipBooleanCmp
@@ -25,6 +26,7 @@ from .win_stack_canary_simplifier import WinStackCanarySimplifier
 from .cross_jump_reverter import CrossJumpReverter
 from .code_motion import CodeMotionOptimization
 from .switch_default_case_duplicator import SwitchDefaultCaseDuplicator
+from .deadblock_remover import DeadblockRemover
 from .inlined_string_transformation_simplifier import InlinedStringTransformationSimplifier
 
 # order matters!
@@ -43,6 +45,7 @@ _all_optimization_passes = [
     (ITEExprConverter, True),
     (ExprOpSwapper, True),
     (ReturnDuplicatorHigh, True),
+    (DeadblockRemover, True),
     (SwitchDefaultCaseDuplicator, True),
     (LoweredSwitchSimplifier, False),
     (ReturnDuplicatorLow, True),
@@ -78,9 +81,7 @@ def get_optimization_passes(arch, platform):
     return passes
 
 
-def get_default_optimization_passes(
-    arch: Union[Arch, str], platform: Optional[str], enable_opts=None, disable_opts=None
-):
+def get_default_optimization_passes(arch: Arch | str, platform: str | None, enable_opts=None, disable_opts=None):
     if isinstance(arch, Arch):
         arch = arch.name
 

angr/analyses/decompiler/optimization_passes/code_motion.py

@@ -1,5 +1,4 @@
 import itertools
-from typing import Tuple, List, Optional, Dict
 import logging
 
 from ailment import Block
@@ -79,7 +78,7 @@ class CodeMotionOptimization(OptimizationPass):
 
     @staticmethod
     def update_graph_with_super_edits(
-        original_graph: nx.DiGraph, super_graph: nx.DiGraph, updated_blocks: Dict[Block, Block]
+        original_graph: nx.DiGraph, super_graph: nx.DiGraph, updated_blocks: dict[Block, Block]
     ) -> bool:
         """
         This function updates an graph when doing block edits on a supergraph version of that same graph.
@@ -123,7 +122,7 @@ class CodeMotionOptimization(OptimizationPass):
 
         return False
 
-    def _move_common_code(self, graph) -> Tuple[bool, Optional[Dict[Block, Block]]]:
+    def _move_common_code(self, graph) -> tuple[bool, dict[Block, Block] | None]:
         """
         Does two things at a high level:
         1. rearrange code in blocks to maximize the number of similar statements at the end of the block
@@ -220,7 +219,7 @@ class CodeMotionOptimization(OptimizationPass):
 
     def _make_stmts_end_similar(
         self, b0: Block, b1: Block, up=False, down=False
-    ) -> Tuple[bool, Optional[Block], Optional[Block]]:
+    ) -> tuple[bool, Block | None, Block | None]:
         """
         This algorithm attempts to rearrange two blocks to have the longest common sequence of statements
         at either ends of the blocks. It is flawed in that it currently only attempts to do this rearrangement
@@ -321,7 +320,7 @@ class CodeMotionOptimization(OptimizationPass):
 
     def _maximize_ends(
         self, b0_stmts, b1_stmts, up=False, down=False
-    ) -> Tuple[bool, Tuple[List[Statement], List[Statement]]]:
+    ) -> tuple[bool, tuple[list[Statement], list[Statement]]]:
         self._assert_up_or_down(up, down)
 
         similar_stmt = b0_stmts[0] if up else b0_stmts[-1]
@@ -333,7 +332,7 @@ class CodeMotionOptimization(OptimizationPass):
         success, new_b1_stmts = self._move_to_end(target_stmt, b1_stmts, up=up, down=down)
         return (success and (b1_stmts != new_b1_stmts)), (b0_stmts, new_b1_stmts)
 
-    def _move_to_end(self, stmt, stmts, up=False, down=False) -> Tuple[bool, List[Statement]]:
+    def _move_to_end(self, stmt, stmts, up=False, down=False) -> tuple[bool, list[Statement]]:
         """
         Attempts to move a stmt to either the top or the bottom of stmts.
         It does this by attempting to swap, 1 by 1, in either direction it is targeting.

angr/analyses/decompiler/optimization_passes/const_derefs.py

@@ -1,5 +1,5 @@
 # pylint:disable=unused-argument
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 import logging
 
 from ailment import Block, AILBlockWalker
@@ -20,7 +20,7 @@ class BlockWalker(AILBlockWalker):
     def __init__(self, project: "Project"):
         super().__init__()
         self._project = project
-        self._new_block: Optional[Block] = None  # output
+        self._new_block: Block | None = None  # output
 
     def walk(self, block: Block):
         self._new_block = None
@@ -68,7 +68,7 @@ class BlockWalker(AILBlockWalker):
             return new_stmt
         return None
 
-    def _handle_CallExpr(self, expr_idx: int, expr: Call, stmt_idx: int, stmt: Statement, block: Optional[Block]):
+    def _handle_CallExpr(self, expr_idx: int, expr: Call, stmt_idx: int, stmt: Statement, block: Block | None):
         new_target = self._handle_expr(-1, expr.target, stmt_idx, stmt, block)
 
         new_args = None
@@ -260,6 +260,6 @@ class ConstantDereferencesSimplifier(OptimizationPass):
         walker = AILGraphWalker(self._graph, handler=self._walk_block, replace_nodes=True)
         walker.walk()
 
-    def _walk_block(self, block: Block) -> Optional[Block]:
+    def _walk_block(self, block: Block) -> Block | None:
         new_block = self._block_walker.walk(block)
         return new_block

angr/analyses/decompiler/optimization_passes/deadblock_remover.py

@@ -0,0 +1,73 @@
+# pylint:disable=too-many-boolean-expressions
+import logging
+
+import networkx
+
+import claripy
+
+from ailment.statement import Jump
+from ailment.expression import Const
+from angr.utils.graph import to_acyclic_graph
+from angr.analyses.decompiler.condition_processor import ConditionProcessor
+from .optimization_pass import OptimizationPass, OptimizationPassStage
+
+
+_l = logging.getLogger(name=__name__)
+
+
+class DeadblockRemover(OptimizationPass):
+    """
+    Removes condition-unreachable blocks from the graph.
+    """
+
+    ARCHES = None
+    PLATFORMS = None
+    STAGE = OptimizationPassStage.BEFORE_REGION_IDENTIFICATION
+    NAME = "Remove blocks with unsatisfiable conditions"
+    DESCRIPTION = __doc__.strip()
+
+    def __init__(self, func, **kwargs):
+        super().__init__(func, **kwargs)
+        self.analyze()
+
+    def _check(self):
+        cond_proc = ConditionProcessor(self.project.arch)
+        if networkx.is_directed_acyclic_graph(self._graph):
+            acyclic_graph = self._graph
+        else:
+            acyclic_graph = to_acyclic_graph(self._graph)
+        cond_proc.recover_reaching_conditions(region=None, graph=acyclic_graph)
+
+        if not any(claripy.is_false(c) for c in cond_proc.reaching_conditions.values()):
+            return False, None
+
+        cache = {"cond_proc": cond_proc}
+        return True, cache
+
+    def _analyze(self, cache=None):
+        cond_proc = cache["cond_proc"]
+        to_remove = {
+            blk
+            for blk in self._graph.nodes()
+            if blk.addr != self._func.addr
+            and self._graph.in_degree(blk) == 0
+            or claripy.is_false(cond_proc.reaching_conditions[blk])
+        }
+
+        # fix up predecessors
+        for b in to_remove:
+            for p in self._graph.predecessors(b):
+                if self._graph.out_degree(p) != 2:
+                    continue
+                other_successor = next(s for s in self._graph.successors(p) if s != b)
+                p.statements[-1] = Jump(
+                    None,
+                    Const(None, None, other_successor.addr, self.project.arch.bits),
+                    other_successor.idx,
+                    **p.statements[-1].tags,
+                )
+
+        for n in to_remove:
+            self._graph.remove_node(n)
+
+        self.out_graph = self._graph

angr/analyses/decompiler/optimization_passes/engine_base.py

@@ -209,9 +209,21 @@ class SimplifierAILEngine(
                 return operand_expr.operand
             else:
                 return Expr.Convert(
-                    expr.idx, operand_expr.from_bits, expr.to_bits, expr.is_signed, operand_expr.operand, **expr.tags
+                    expr.idx,
+                    operand_expr.from_bits,
+                    expr.to_bits,
+                    expr.is_signed,
+                    operand_expr.operand,
+                    from_type=operand_expr.from_type,
+                    to_type=expr.to_type,
+                    rounding_mode=expr.rounding_mode,
+                    **expr.tags,
                 )
-        elif type(operand_expr) is Expr.Const:
+        elif (
+            type(operand_expr) is Expr.Const
+            and expr.from_type == Expr.Convert.TYPE_INT
+            and expr.to_type == Expr.Convert.TYPE_INT
+        ):
             # do the conversion right away
             value = operand_expr.value
             mask = (2**expr.to_bits) - 1
@@ -277,5 +289,15 @@ class SimplifierAILEngine(
                         **operand_expr.tags,
                     )
 
-        converted = Expr.Convert(expr.idx, expr.from_bits, expr.to_bits, expr.is_signed, operand_expr, **expr.tags)
+        converted = Expr.Convert(
+            expr.idx,
+            expr.from_bits,
+            expr.to_bits,
+            expr.is_signed,
+            operand_expr,
+            from_type=expr.from_type,
+            to_type=expr.to_type,
+            rounding_mode=expr.rounding_mode,
+            **expr.tags,
+        )
         return converted

angr/analyses/decompiler/optimization_passes/expr_op_swapper.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
+from collections.abc import Callable
 
 from ailment.block import Block as AILBlock
 from ailment.statement import Statement
@@ -23,7 +24,7 @@ class OuterWalker(SequenceWalker):
 
     def __init__(self, desc):
         super().__init__()
-        self.desc: Dict[OpDescriptor, str] = desc
+        self.desc: dict[OpDescriptor, str] = desc
 
     def _handle_Condition(self, node: "ConditionNode", **kwargs):
         for desc, new_op in self.desc.items():
@@ -56,7 +57,7 @@ class OuterWalker(SequenceWalker):
         return super()._handle_ConditionalBreak(node, **kwargs)
 
     @staticmethod
-    def _swap_expr_op(new_op: str, atom: Expression) -> Optional[Expression]:
+    def _swap_expr_op(new_op: str, atom: Expression) -> Expression | None:
         # swap
         new_expr = BinaryOp(
             atom.idx, new_op, (atom.operands[1], atom.operands[0]), atom.signed, bits=atom.bits, **atom.tags
@@ -76,7 +77,7 @@ class ExpressionReplacer(AILBlockWalker):
         self._callback = callback
 
     def _handle_expr(
-        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Optional[Statement], block: Optional[AILBlock]
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: AILBlock | None
     ) -> Any:
         if self._target_expr_predicate(expr):
             new_expr = self._callback(self._block_addr, expr)
@@ -119,7 +120,7 @@ class ExprOpSwapper(SequenceOptimizationPass):
     NAME = "Swap operands of expressions as requested"
     DESCRIPTION = __doc__.strip()
 
-    def __init__(self, func, binop_operators: Optional[Dict[OpDescriptor, str]] = None, **kwargs):
+    def __init__(self, func, binop_operators: dict[OpDescriptor, str] | None = None, **kwargs):
         super().__init__(func, **kwargs)
         self._expr_operators = {} if binop_operators is None else binop_operators
 

angr/analyses/decompiler/optimization_passes/flip_boolean_cmp.py

@@ -1,5 +1,5 @@
 # pylint:disable=arguments-renamed,too-many-boolean-expressions
-from typing import List, Tuple, Any
+from typing import Any
 
 import ailment
 from ailment.expression import Op
@@ -29,7 +29,7 @@ class FlipBooleanWalker(SequenceWalker):
         # Type 2:
         # if (cond) { ... } return;    -->    if (!cond) return; ...
         type1_condition_nodes = [node for node in seq_node.nodes if isinstance(node, ConditionNode) and node.false_node]
-        type2_condition_nodes: List[Tuple[int, ConditionNode, Any]] = []
+        type2_condition_nodes: list[tuple[int, ConditionNode, Any]] = []
 
         if len(seq_node.nodes) >= 2:
             idx = len(seq_node.nodes) - 2

angr/analyses/decompiler/optimization_passes/inlined_string_transformation_simplifier.py

@@ -234,6 +234,9 @@ class InlinedStringTransformationAILEngine(SimEngineLightAILMixin):
     def _handle_Call(self, stmt):
         pass
 
+    def _ail_handle_CallExpr(self, expr):
+        pass
+
 
 class InlineStringTransformationDescriptor:
     """

angr/analyses/decompiler/optimization_passes/ite_expr_converter.py

@@ -59,7 +59,7 @@ class ExpressionReplacer(AILBlockWalker):
         self._callback = callback
 
     def _handle_expr(
-        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Optional[Statement], block: Optional["AILBlock"]
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Optional["AILBlock"]
     ) -> Any:
         if expr == self._target_expr:
             new_expr = self._callback(self._block_addr, stmt_idx, stmt.ins_addr, expr)
@@ -101,7 +101,7 @@ class ITEExprConverter(OptimizationPass):
                         block_walker = ExpressionReplacer(block_addr, expr, self._convert_expr)
                         block_walker.walk(block)
 
-    def _convert_expr(self, block_addr: int, stmt_idx: int, ins_addr: int, atom: Expression) -> Optional[Expression]:
+    def _convert_expr(self, block_addr: int, stmt_idx: int, ins_addr: int, atom: Expression) -> Expression | None:
         rda = self.project.analyses[ReachingDefinitionsAnalysis].prep()(subject=self._func, func_graph=self._graph)
 
         # find the corresponding definition