angr 9.2.116__py3-none-win_amd64.whl → 9.2.118__py3-none-win_amd64.whl

angr/analyses/decompiler/optimization_passes/stack_canary_simplifier.py

@@ -1,3 +1,5 @@
+# pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 from collections import defaultdict
 import logging
 
@@ -55,14 +57,14 @@ class StackCanarySimplifier(OptimizationPass):
         first_block, stmt_idx = init_stmt
         canary_init_stmt = first_block.statements[stmt_idx]
         # where is the stack canary stored?
-        if not isinstance(canary_init_stmt.addr, ailment.Expr.StackBaseOffset):
+        if not (isinstance(canary_init_stmt.dst, ailment.Expr.VirtualVariable) and canary_init_stmt.dst.was_stack):
             _l.debug(
-                "Unsupported canary storing location %s. Expects an ailment.Expr.StackBaseOffset.",
+                "Unsupported canary storing location %s. Expects a stack VirtualVariable.",
                 canary_init_stmt.addr,
             )
             return
 
-        store_offset = canary_init_stmt.addr.offset
+        store_offset = canary_init_stmt.dst.stack_offset
         if not isinstance(store_offset, int):
             _l.debug("Unsupported canary storing offset %s. Expects an int.", store_offset)
 
@@ -143,10 +145,7 @@ class StackCanarySimplifier(OptimizationPass):
                 if len(succs) != 2:
                     _l.debug("Expect 2 successors. Found %d.", len(succs))
                     continue
-                if stack_chk_fail_caller is succs[0]:
-                    ret_node = succs[1]
-                else:
-                    ret_node = succs[0]
+                ret_node = succs[1] if stack_chk_fail_caller is succs[0] else succs[0]
                 nodes_to_process.append((pred, canary_check_stmt_idx, stack_chk_fail_caller, ret_node))
 
             # Awesome. Now patch this function.
@@ -192,18 +191,25 @@ class StackCanarySimplifier(OptimizationPass):
 
             for idx, stmt in enumerate(first_block.statements):
                 if (
-                    isinstance(stmt, ailment.Stmt.Store)
-                    and isinstance(stmt.addr, ailment.Expr.StackBaseOffset)
-                    and isinstance(stmt.data, ailment.Expr.Load)
-                    and self._is_add(stmt.data.addr)
+                    isinstance(stmt, ailment.Stmt.Assignment)
+                    and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                    and stmt.dst.was_stack
+                    and isinstance(stmt.dst.stack_offset, int)
+                    and isinstance(stmt.src, ailment.Expr.Load)
+                    and self._is_add(stmt.src.addr)
                 ):
                     # Check addr: must be fs+0x28
-                    op0, op1 = stmt.data.addr.operands
-                    if isinstance(op1, ailment.Expr.Register):
+                    op0, op1 = stmt.src.addr.operands
+                    if isinstance(op1, ailment.Expr.VirtualVariable) and op1.was_reg:
                         op0, op1 = op1, op0
-                    if isinstance(op0, ailment.Expr.Register) and isinstance(op1, ailment.Expr.Const):
-                        if op0.reg_offset == self.project.arch.get_register_offset("fs") and op1.value == 0x28:
-                            return first_block, idx
+                    if (
+                        isinstance(op0, ailment.Expr.VirtualVariable)
+                        and op0.was_reg
+                        and isinstance(op1, ailment.Expr.Const)
+                        and op0.reg_offset == self.project.arch.get_register_offset("fs")
+                        and op1.value == 0x28
+                    ):
+                        return first_block, idx
 
             succs = list(self._graph.successors(first_block))
             if len(succs) == 1:
@@ -235,6 +241,19 @@ class StackCanarySimplifier(OptimizationPass):
                 if isinstance(expr0, ailment.Expr.BinaryOp) and expr0.op == "Xor":
                     # a ^ b
                     op0, op1 = expr0.operands
+                    if isinstance(op0, ailment.Expr.VirtualVariable) and op0.was_reg:
+                        # maybe op0 holds the value of another stack variable, like the following:
+                        #
+                        # 00 | 0x404e75 | LABEL_404e75:
+                        # 01 | 0x404e75 | vvar_62{reg 16} = vvar_79{stack -64}
+                        # 02 | 0x404e7a | vvar_66{reg 16} = (vvar_62{reg 16} ^ Load(addr=(0x28<64> + vvar_31{reg 208}),
+                        #                 size=8, endness=Iend_LE))
+                        # 03 | 0x404e83 | if (((vvar_62{reg 16} ^ Load(addr=(0x28<64> + vvar_31{reg 208}), size=8,
+                        #                 endness=Iend_LE)) == 0x0<64>)) { Goto ... } else { Goto ... }
+                        op0_v = self._get_vvar_value(block, op0.varid)
+                        if isinstance(op0_v, ailment.Expr.VirtualVariable) and op0_v.was_stack:
+                            op0 = op0_v
+
                     if not (
                         self._is_stack_canary_load_expr(op0, self.project.arch.bits, canary_value_stack_offset)
                         and self._is_random_number_load_expr(op1, self.project.arch.get_register_offset("fs"))
@@ -278,11 +297,11 @@ class StackCanarySimplifier(OptimizationPass):
 
     @staticmethod
     def _is_stack_canary_load_expr(expr, bits: int, canary_value_stack_offset: int) -> bool:
-        if not (isinstance(expr, ailment.Expr.Load) and isinstance(expr.addr, ailment.Expr.StackBaseOffset)):
-            return False
-        if s2u(expr.addr.offset, bits) != s2u(canary_value_stack_offset, bits):
+        if not (
+            isinstance(expr, ailment.Expr.VirtualVariable) and expr.was_stack and isinstance(expr.stack_offset, int)
+        ):
             return False
-        return True
+        return s2u(expr.stack_offset, bits) == s2u(canary_value_stack_offset, bits)
 
     @staticmethod
     def _is_random_number_load_expr(expr, fs_reg_offset: int) -> bool:
@@ -292,6 +311,18 @@ class StackCanarySimplifier(OptimizationPass):
             and expr.addr.op == "Add"
             and isinstance(expr.addr.operands[0], ailment.Expr.Const)
             and expr.addr.operands[0].value == 0x28
-            and isinstance(expr.addr.operands[1], ailment.Expr.Register)
+            and isinstance(expr.addr.operands[1], ailment.Expr.VirtualVariable)
+            and expr.addr.operands[1].was_reg
             and expr.addr.operands[1].reg_offset == fs_reg_offset
         )
+
+    @staticmethod
+    def _get_vvar_value(block: ailment.Block, vvar_id: int) -> ailment.Expression | None:
+        for stmt in block.statements:
+            if (
+                isinstance(stmt, ailment.Stmt.Assignment)
+                and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                and stmt.dst.varid == vvar_id
+            ):
+                return stmt.src
+        return None

angr/analyses/decompiler/optimization_passes/switch_default_case_duplicator.py

@@ -1,4 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 from itertools import count
 import logging
 
@@ -55,7 +56,7 @@ class SwitchDefaultCaseDuplicator(OptimizationPass):
         for node_addr in jump_node_addrs:
             node = self._func.get_node(node_addr)
             if self._func.graph.in_degree[node] == 1:
-                pred = list(self._func.graph.predecessors(node))[0]
+                pred = next(iter(self._func.graph.predecessors(node)))
                 if self._func.graph.out_degree[pred] == 2:
                     default_case_node = next(
                         iter(nn for nn in self._func.graph.successors(pred) if nn.addr != node_addr)
@@ -84,7 +85,7 @@ class SwitchDefaultCaseDuplicator(OptimizationPass):
             }
             if unexpected_pred_addrs:
                 default_case_block = self._get_block(default_addr)
-                default_case_succ_block = list(self._graph.successors(default_case_block))[0]
+                default_case_succ_block = next(iter(self._graph.successors(default_case_block)))
 
                 jump_nodes = self._get_blocks(jump_node_addr)
                 jump_node_descedents = set()

angr/analyses/decompiler/optimization_passes/win_stack_canary_simplifier.py

@@ -1,4 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 from collections import defaultdict
 import logging
 
@@ -174,7 +175,8 @@ class WinStackCanarySimplifier(OptimizationPass):
             # or if we are unlucky and the load and the xor are two different statements
             if (
                 isinstance(stmt, ailment.Stmt.Assignment)
-                and isinstance(stmt.dst, ailment.Expr.Register)
+                and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                and stmt.dst.was_reg
                 and isinstance(stmt.src, ailment.Expr.Load)
                 and isinstance(stmt.src.addr, ailment.Expr.Const)
             ):
@@ -185,10 +187,12 @@ class WinStackCanarySimplifier(OptimizationPass):
             if load_stmt_idx is not None and idx == load_stmt_idx + 1:
                 if (
                     isinstance(stmt, ailment.Stmt.Assignment)
-                    and isinstance(stmt.dst, ailment.Expr.Register)
+                    and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                    and stmt.dst.was_reg
                     and isinstance(stmt.src, ailment.Expr.BinaryOp)
                     and stmt.src.op == "Xor"
-                    and isinstance(stmt.src.operands[0], ailment.Expr.Register)
+                    and isinstance(stmt.src.operands[0], ailment.Expr.VirtualVariable)
+                    and stmt.src.operands[0].was_reg
                     and stmt.src.operands[0].reg_offset == load_reg
                     and isinstance(stmt.src.operands[1], ailment.Expr.StackBaseOffset)
                 ):
@@ -200,59 +204,66 @@ class WinStackCanarySimplifier(OptimizationPass):
                 if (
                     isinstance(stmt, ailment.Stmt.Store)
                     and isinstance(stmt.addr, ailment.Expr.StackBaseOffset)
-                    and isinstance(stmt.data, ailment.Expr.Register)
+                    and isinstance(stmt.data, ailment.Expr.VirtualVariable)
+                    and stmt.data.was_reg
                     and stmt.data.reg_offset == xored_reg
                 ):
                     return first_block, [load_stmt_idx, xor_stmt_idx, idx]
-                else:
-                    break
+                break
 
         return None
 
-    @staticmethod
-    def _find_amd64_canary_storing_stmt(block, canary_value_stack_offset):
+    def _find_amd64_canary_storing_stmt(self, block, canary_value_stack_offset):
         load_stmt_idx = None
 
         for idx, stmt in enumerate(block.statements):
             # when we are lucky, we have one instruction
             if (
-                isinstance(stmt, ailment.Stmt.Assignment)
-                and isinstance(stmt.dst, ailment.Expr.Register)
-                and stmt.dst.reg_name == "rcx"
+                (
+                    isinstance(stmt, ailment.Stmt.Assignment)
+                    and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                    and stmt.dst.was_reg
+                    and stmt.dst.reg_offset == self.project.arch.registers["rcx"][0]
+                )
+                and isinstance(stmt.src, ailment.Expr.BinaryOp)
+                and stmt.src.op == "Xor"
             ):
-                if isinstance(stmt.src, ailment.Expr.BinaryOp) and stmt.src.op == "Xor":
-                    op0, op1 = stmt.src.operands
-                    if (
-                        isinstance(op0, ailment.Expr.Load)
-                        and isinstance(op0.addr, ailment.Expr.StackBaseOffset)
-                        and op0.addr.offset == canary_value_stack_offset
-                    ):
-                        if isinstance(op1, ailment.Expr.StackBaseOffset):
-                            # found it
-                            return idx
+                op0, op1 = stmt.src.operands
+                if (
+                    isinstance(op0, ailment.Expr.Load)
+                    and isinstance(op0.addr, ailment.Expr.StackBaseOffset)
+                    and op0.addr.offset == canary_value_stack_offset
+                ) and isinstance(op1, ailment.Expr.StackBaseOffset):
+                    # found it
+                    return idx
             # or when we are unlucky, we have two instructions...
             if (
                 isinstance(stmt, ailment.Stmt.Assignment)
-                and isinstance(stmt.dst, ailment.Expr.Register)
-                and stmt.dst.reg_name == "rcx"
+                and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                and stmt.dst.reg_offset == self.project.arch.registers["rcx"][0]
                 and isinstance(stmt.src, ailment.Expr.Load)
                 and isinstance(stmt.src.addr, ailment.Expr.StackBaseOffset)
                 and stmt.src.addr.offset == canary_value_stack_offset
             ):
                 load_stmt_idx = idx
-            if load_stmt_idx is not None and idx == load_stmt_idx + 1:
-                if (
+            if (
+                load_stmt_idx is not None
+                and idx >= load_stmt_idx + 1
+                and (
                     isinstance(stmt, ailment.Stmt.Assignment)
-                    and isinstance(stmt.dst, ailment.Expr.Register)
+                    and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                    and stmt.dst.was_reg
                     and isinstance(stmt.src, ailment.Expr.BinaryOp)
                     and stmt.src.op == "Xor"
-                ):
-                    if (
-                        isinstance(stmt.src.operands[0], ailment.Expr.Register)
-                        and stmt.src.operands[0].reg_name == "rcx"
-                        and isinstance(stmt.src.operands[1], ailment.Expr.StackBaseOffset)
-                    ):
-                        return idx
+                )
+                and (
+                    isinstance(stmt.src.operands[0], ailment.Expr.VirtualVariable)
+                    and stmt.src.operands[0].was_reg
+                    and stmt.src.operands[0].reg_offset == self.project.arch.registers["rcx"][0]
+                    and isinstance(stmt.src.operands[1], ailment.Expr.StackBaseOffset)
+                )
+            ):
+                return idx
         return None
 
     @staticmethod
@@ -273,9 +284,9 @@ class WinStackCanarySimplifier(OptimizationPass):
                 const_target = stmt.target.value
                 if const_target in self.kb.functions:
                     func = self.kb.functions.function(addr=const_target)
-                    if func.name == "_security_check_cookie":
-                        return idx
-                    elif is_function_security_check_cookie(func, self.project, self._security_cookie_addr):
+                    if func.name == "_security_check_cookie" or is_function_security_check_cookie(
+                        func, self.project, self._security_cookie_addr
+                    ):
                         return idx
 
         return None

angr/analyses/decompiler/optimization_passes/x86_gcc_getpc_simplifier.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 import logging
 
@@ -15,7 +16,7 @@ class X86GccGetPcSimplifier(OptimizationPass):
 
     ARCHES = ["X86"]
     PLATFORMS = ["linux"]
-    STAGE = OptimizationPassStage.AFTER_SINGLE_BLOCK_SIMPLIFICATION
+    STAGE = OptimizationPassStage.BEFORE_SSA_LEVEL0_TRANSFORMATION
     NAME = "Simplify getpc()"
     DESCRIPTION = __doc__.strip()
 

angr/analyses/decompiler/peephole_optimizations/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import List, Type
 
 from .a_div_const_add_a_mul_n_div_const import ADivConstAddAMulNDivConst
@@ -44,6 +45,7 @@ from .inlined_strcpy import InlinedStrcpy
 from .inlined_strcpy_consolidation import InlinedStrcpyConsolidation
 from .inlined_wstrcpy import InlinedWstrcpy
 from .cmpord_rewriter import CmpORDRewriter
+from .coalesce_adjacent_shrs import CoalesceAdjacentShiftRights
 
 from .base import PeepholeOptimizationExprBase, PeepholeOptimizationStmtBase, PeepholeOptimizationMultiStmtBase
 

angr/analyses/decompiler/peephole_optimizations/a_div_const_add_a_mul_n_div_const.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase
@@ -12,27 +13,30 @@ class ADivConstAddAMulNDivConst(PeepholeOptimizationExprBase):
     def optimize(self, expr: BinaryOp, **kwargs):
         if expr.op == "Add" and len(expr.operands) == 2:
             op0, op1 = expr.operands
-            if isinstance(op0, BinaryOp) and op0.op == "Div" and isinstance(op0.operands[1], Const):
-                if isinstance(op1, BinaryOp) and op1.op == "Div" and isinstance(op1.operands[1], Const):
-                    if (
-                        isinstance(op1.operands[0], BinaryOp)
-                        and op1.operands[0].op == "Mul"
-                        and isinstance(op1.operands[0].operands[1], Const)
-                    ):
-                        a0 = op0.operands[0]
-                        a1 = op1.operands[0].operands[0]
-                        if a0.likes(a1):
-                            N0 = op0.operands[1]
-                            N1: int = op1.operands[0].operands[1].value
-                            if N0.value == op1.operands[1].value:
-                                mul = BinaryOp(
-                                    op0.idx,
-                                    "Mul",
-                                    [a0, Const(None, None, N1 + 1, expr.bits, **expr.operands[0].operands[1].tags)],
-                                    False,
-                                    **op0.tags,
-                                )
-                                div = BinaryOp(expr.idx, "Div", [mul, N0], False, **expr.tags)
-                                return div
+            if (
+                isinstance(op0, BinaryOp)
+                and op0.op == "Div"
+                and isinstance(op0.operands[1], Const)
+                and isinstance(op1, BinaryOp)
+                and op1.op == "Div"
+                and isinstance(op1.operands[1], Const)
+                and isinstance(op1.operands[0], BinaryOp)
+                and op1.operands[0].op == "Mul"
+                and isinstance(op1.operands[0].operands[1], Const)
+            ):
+                a0 = op0.operands[0]
+                a1 = op1.operands[0].operands[0]
+                if a0.likes(a1):
+                    N0 = op0.operands[1]
+                    N1: int = op1.operands[0].operands[1].value
+                    if N0.value == op1.operands[1].value:
+                        mul = BinaryOp(
+                            op0.idx,
+                            "Mul",
+                            [a0, Const(None, None, N1 + 1, expr.bits, **expr.operands[0].operands[1].tags)],
+                            False,
+                            **op0.tags,
+                        )
+                        return BinaryOp(expr.idx, "Div", [mul, N0], False, **expr.tags)
 
         return None

angr/analyses/decompiler/peephole_optimizations/a_mul_const_div_shr_const.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase
@@ -32,7 +33,6 @@ class AMulConstDivShrConst(PeepholeOptimizationExprBase):
                     False,
                     **inner.tags,
                 )
-                div = BinaryOp(expr.idx, "Div", [mul, N1], False, **expr.tags)
-                return div
+                return BinaryOp(expr.idx, "Div", [mul, N1], False, **expr.tags)
 
         return None

angr/analyses/decompiler/peephole_optimizations/a_shl_const_sub_a.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase

angr/analyses/decompiler/peephole_optimizations/a_sub_a_div.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase
@@ -17,9 +18,8 @@ class ASubADiv(PeepholeOptimizationExprBase):
                 if expr1.operands[0].likes(a):
                     N = expr1.operands[1].value
                     mul = BinaryOp(expr.idx, "Mul", [a, Const(None, None, N - 1, expr.bits)], False, **expr.tags)
-                    div = BinaryOp(
+                    return BinaryOp(
                         expr1.idx, "Div", [mul, Const(None, None, N, expr.bits, **expr1.tags)], False, **expr1.tags
                     )
-                    return div
 
         return None

angr/analyses/decompiler/peephole_optimizations/a_sub_a_div_const_mul_const.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const, Convert
 
 from .base import PeepholeOptimizationExprBase

angr/analyses/decompiler/peephole_optimizations/a_sub_a_sub_n.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp
 
 from .base import PeepholeOptimizationExprBase
@@ -11,9 +12,12 @@ class ASubASubN(PeepholeOptimizationExprBase):
 
     def optimize(self, expr: BinaryOp, **kwargs):
         # Sub(A, Sub(A, N)) ==> N
-        if expr.op == "Sub" and isinstance(expr.operands[1], BinaryOp) and expr.operands[1].op == "Sub":
-            if expr.operands[0] == expr.operands[1].operands[0]:
-                new_expr = expr.operands[1].operands[1]
-                return new_expr
+        if (
+            expr.op == "Sub"
+            and isinstance(expr.operands[1], BinaryOp)
+            and expr.operands[1].op == "Sub"
+            and expr.operands[0] == expr.operands[1].operands[0]
+        ):
+            return expr.operands[1].operands[1]
 
         return None

angr/analyses/decompiler/peephole_optimizations/arm_cmpf.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const, Convert
 
 from .base import PeepholeOptimizationExprBase
@@ -72,14 +73,9 @@ class ARMCmpF(PeepholeOptimizationExprBase):
                 if isinstance(irRes, BinaryOp) and irRes.op == "CmpF":
                     # everything matches
                     if bit_mask == 1:
-                        if negate:
-                            # GT
-                            op = "CmpGT"
-                        else:
-                            # LE
-                            op = "CmpLE"
+                        op = "CmpGT" if negate else "CmpLE"
                     else:
-                        raise NotImplementedError()
+                        raise NotImplementedError
                     return BinaryOp(
                         expr.idx,
                         op,
@@ -99,24 +95,26 @@ class ARMCmpF(PeepholeOptimizationExprBase):
             chunk1, chunk2 = expr.operands[1].operands
 
             if (
-                isinstance(chunk0, BinaryOp)
-                and chunk0.op == "Shr"
-                and isinstance(chunk0.operands[1], Const)
-                and chunk0.operands[1].value == 0x1E
-            ):
-                if (
+                (
+                    isinstance(chunk0, BinaryOp)
+                    and chunk0.op == "Shr"
+                    and isinstance(chunk0.operands[1], Const)
+                    and chunk0.operands[1].value == 0x1E
+                )
+                and (
                     isinstance(chunk1, BinaryOp)
                     and chunk1.op == "Shr"
                     and isinstance(chunk1.operands[1], Const)
                     and chunk1.operands[1].value == 0x1F
-                ):
-                    if (
-                        isinstance(chunk2, BinaryOp)
-                        and chunk2.op == "Shr"
-                        and isinstance(chunk2.operands[1], Const)
-                        and chunk2.operands[1].value == 0x1C
-                    ):
-                        return True, chunk0.operands[0], chunk1.operands[0], chunk2.operands[0]
+                )
+                and (
+                    isinstance(chunk2, BinaryOp)
+                    and chunk2.op == "Shr"
+                    and isinstance(chunk2.operands[1], Const)
+                    and chunk2.operands[1].value == 0x1C
+                )
+            ):
+                return True, chunk0.operands[0], chunk1.operands[0], chunk2.operands[0]
         return False, None, None, None
 
     @staticmethod
@@ -129,13 +127,16 @@ class ARMCmpF(PeepholeOptimizationExprBase):
                 # ignore the first operand because it might be optimized away
                 inner = inner.operands[1]
             if (
-                isinstance(inner, BinaryOp)
-                and inner.op == "Shl"
-                and isinstance(inner.operands[1], Const)
-                and inner.operands[1].value == 0x1C
+                (
+                    isinstance(inner, BinaryOp)
+                    and inner.op == "Shl"
+                    and isinstance(inner.operands[1], Const)
+                    and inner.operands[1].value == 0x1C
+                )
+                and isinstance(inner.operands[0], BinaryOp)
+                and inner.operands[0].op == "Sub"
             ):
-                if isinstance(inner.operands[0], BinaryOp) and inner.operands[0].op == "Sub":
-                    return True, inner.operands[0].operands[0], inner.operands[0].operands[1]
+                return True, inner.operands[0].operands[0], inner.operands[0].operands[1]
         return False, None, None
 
     @staticmethod

angr/analyses/decompiler/peephole_optimizations/base.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, UnaryOp, Expression
 from ailment.statement import Statement, Assignment
 from ailment import Block
@@ -28,7 +29,7 @@ class PeepholeOptimizationStmtBase:
         self.kb = kb
         self.func_addr = func_addr
 
-    def optimize(self, stmt, stmt_idx: int = None, block=None, **kwargs):
+    def optimize(self, stmt, stmt_idx: int | None = None, block=None, **kwargs):
         raise NotImplementedError("_optimize() is not implemented.")
 
 
@@ -94,27 +95,23 @@ class PeepholeOptimizationExprBase:
         idx = stmt_idx - 1
         if idx >= 0:
             stmt = block.statements[idx]
-            if isinstance(stmt, Assignment):
-                if stmt.dst.likes(ail_expr):
-                    return stmt.src
+            if isinstance(stmt, Assignment) and stmt.dst.likes(ail_expr):
+                return stmt.src
         return None
 
     @staticmethod
     def is_bool_expr(ail_expr):
-        if isinstance(ail_expr, BinaryOp):
-            if ail_expr.op in {
-                "CmpEQ",
-                "CmpNE",
-                "CmpLT",
-                "CmpLE",
-                "CmpGT",
-                "CmpGE",
-                "CmpLTs",
-                "CmpLEs",
-                "CmpGTs",
-                "CmpGEs",
-            }:
-                return True
-        if isinstance(ail_expr, UnaryOp) and ail_expr.op == "Not":
+        if isinstance(ail_expr, BinaryOp) and ail_expr.op in {
+            "CmpEQ",
+            "CmpNE",
+            "CmpLT",
+            "CmpLE",
+            "CmpGT",
+            "CmpGE",
+            "CmpLTs",
+            "CmpLEs",
+            "CmpGTs",
+            "CmpGEs",
+        }:
             return True
-        return False
+        return bool(isinstance(ail_expr, UnaryOp) and ail_expr.op == "Not")

angr/analyses/decompiler/peephole_optimizations/basepointeroffset_add_n.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, BasePointerOffset, Const
 
 from .base import PeepholeOptimizationExprBase

angr/analyses/decompiler/peephole_optimizations/basepointeroffset_and_mask.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, BasePointerOffset, Const
 
 from .base import PeepholeOptimizationExprBase

angr/analyses/decompiler/peephole_optimizations/bitwise_or_to_logical_or.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase
@@ -28,7 +29,6 @@ class BitwiseOrToLogicalOr(PeepholeOptimizationExprBase):
             new_left = BinaryOp(inner.idx, expr.op, (inner.operands[0], expr.operands[1]), False, bits=1, **inner.tags)
             new_right = BinaryOp(inner.idx, expr.op, (inner.operands[1], expr.operands[1]), False, bits=1, **inner.tags)
             op = "LogicalOr" if expr.op == "CmpNE" else "LogicalAnd"
-            new_expr = BinaryOp(expr.idx, op, (new_left, new_right), False, bits=expr.bits, **expr.tags)
-            return new_expr
+            return BinaryOp(expr.idx, op, (new_left, new_right), False, bits=expr.bits, **expr.tags)
 
         return expr

angr/analyses/decompiler/peephole_optimizations/bool_expr_xor_1.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const, UnaryOp, Convert
 
 from .base import PeepholeOptimizationExprBase
@@ -14,7 +15,7 @@ class BoolExprXor1(PeepholeOptimizationExprBase):
         if expr.op == "Xor" and isinstance(expr.operands[1], Const) and expr.operands[1].value == 1:
             arg0 = expr.operands[0]
             if isinstance(arg0, Convert) and arg0.from_bits == 1 and self.is_bool_expr(arg0.operand):
-                new_expr = Convert(
+                return Convert(
                     None,
                     1,
                     arg0.to_bits,
@@ -22,6 +23,5 @@ class BoolExprXor1(PeepholeOptimizationExprBase):
                     UnaryOp(None, "Not", arg0.operands[0], **expr.tags),
                     **arg0.tags,
                 )
-                return new_expr
 
         return None