angr 9.2.117__py3-none-win_amd64.whl → 9.2.119__py3-none-win_amd64.whl

angr/analyses/decompiler/peephole_optimizations/bswap.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const, Expression, Convert
 from ailment.statement import Call
 
@@ -100,32 +101,38 @@ class Bswap(PeepholeOptimizationExprBase):
         return None
 
     def _match_inner(self, or_first: BinaryOp, or_second: BinaryOp) -> tuple[bool, Expression | None]:
-        if isinstance(or_first.operands[1], Const) and or_first.operands[1].value == 0xFF00FF00:
-            if isinstance(or_second.operands[1], Const) and or_second.operands[1].value == 0x00FF00FF:
-                inner_first = or_first.operands[0]
-                inner_second = or_second.operands[0]
-                if (
+        if (
+            isinstance(or_first.operands[1], Const)
+            and or_first.operands[1].value == 0xFF00FF00
+            and isinstance(or_second.operands[1], Const)
+            and or_second.operands[1].value == 0x00FF00FF
+        ):
+            inner_first = or_first.operands[0]
+            inner_second = or_second.operands[0]
+            if (
+                (
                     isinstance(inner_first, BinaryOp)
                     and inner_first.op == "Shl"
                     and isinstance(inner_first.operands[1], Const)
                     and inner_first.operands[1].value == 8
-                ):
+                )
+                and (
+                    isinstance(inner_second, BinaryOp)
+                    and inner_second.op == "Shr"
+                    and isinstance(inner_second.operands[1], Const)
+                    and inner_second.operands[1].value == 8
+                )
+                and isinstance(inner_first.operands[0], Convert)
+            ):
+                conv: Convert = inner_first.operands[0]
+                if conv.from_bits == 16 and conv.to_bits == 32:
+                    the_expr_1 = conv.operand
                     if (
-                        isinstance(inner_second, BinaryOp)
-                        and inner_second.op == "Shr"
-                        and isinstance(inner_second.operands[1], Const)
-                        and inner_second.operands[1].value == 8
+                        isinstance(inner_second.operands[0], Convert)
+                        and inner_second.operands[0].from_bits == 16
+                        and inner_second.operands[0].to_bits == 32
                     ):
-                        if isinstance(inner_first.operands[0], Convert):
-                            conv: Convert = inner_first.operands[0]
-                            if conv.from_bits == 16 and conv.to_bits == 32:
-                                the_expr_1 = conv.operand
-                                if (
-                                    isinstance(inner_second.operands[0], Convert)
-                                    and inner_second.operands[0].from_bits == 16
-                                    and inner_second.operands[0].to_bits == 32
-                                ):
-                                    the_expr_2 = inner_second.operands[0].operand
-                                    if the_expr_1.likes(the_expr_2):
-                                        return True, the_expr_1
+                        the_expr_2 = inner_second.operands[0].operand
+                        if the_expr_1.likes(the_expr_2):
+                            return True, the_expr_1
         return False, None

angr/analyses/decompiler/peephole_optimizations/cmpord_rewriter.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.statement import ConditionalJump
 from ailment.expression import BinaryOp, Const
 
@@ -14,7 +15,7 @@ class CmpORDRewriter(PeepholeOptimizationStmtBase):
     NAME = "CmpORD rewriter"
     stmt_classes = (ConditionalJump,)
 
-    def optimize(self, stmt: ConditionalJump, stmt_idx: int = None, block=None, **kwargs):
+    def optimize(self, stmt: ConditionalJump, stmt_idx: int | None = None, block=None, **kwargs):
         # example:
         # 05 | 0x4011d4 | if ((((gpr9<4> CmpORD 0x0<32>) & 0x2<32>) != 0x0<32>)) { Goto ... } else { Goto ... }
         # or
@@ -59,7 +60,7 @@ class CmpORDRewriter(PeepholeOptimizationStmtBase):
 
         # generate the new comparison
         new_cond = BinaryOp(stmt.condition.idx, cmp_op, real_cmp.operands[::], real_cmp.signed, **real_cmp.tags)
-        new_stmt = ConditionalJump(
+        return ConditionalJump(
             stmt.idx,
             new_cond,
             stmt.true_target,
@@ -68,5 +69,3 @@ class CmpORDRewriter(PeepholeOptimizationStmtBase):
             stmt.false_target_idx,
             **stmt.tags,
         )
-
-        return new_stmt

angr/analyses/decompiler/peephole_optimizations/coalesce_adjacent_shrs.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from ailment.expression import BinaryOp, Const, Convert
+
+from .base import PeepholeOptimizationExprBase
+
+
+class CoalesceAdjacentShiftRights(PeepholeOptimizationExprBase):
+    """
+    Coalesce adjacent SHR/SAR operations if possible.
+    """
+
+    __slots__ = ()
+
+    NAME = "Coalesce adjacent shr/sars"
+    expr_classes = (BinaryOp,)
+
+    def optimize(self, expr: BinaryOp, **kwargs):
+        # this peephole optimization is probably incorrect...
+
+        if expr.op in {"Sar", "Shr"} and isinstance(expr.operands[1], Const):
+            inner = expr.operands[0]
+            convert = None
+            if isinstance(inner, Convert) and inner.from_bits > inner.to_bits:
+                convert = inner
+                inner = convert.operand
+
+            if isinstance(inner, BinaryOp) and inner.op == "Shr" and isinstance(inner.operands[1], Const):
+                # merge them
+                new_shift = inner.operands[1].value + expr.operands[1].value
+                r = BinaryOp(
+                    expr.idx, expr.op, [inner.operands[0], Const(None, None, new_shift, 8)], expr.signed, **expr.tags
+                )
+                if convert is not None:
+                    return Convert(
+                        convert.idx, convert.from_bits, convert.to_bits, convert.is_signed, r, **convert.tags
+                    )
+                return r
+
+        return None

angr/analyses/decompiler/peephole_optimizations/coalesce_same_cascading_ifs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.statement import ConditionalJump
 from ailment.expression import ITE
 
@@ -10,7 +11,7 @@ class CoalesceSameCascadingIfs(PeepholeOptimizationStmtBase):
     NAME = "Coalescing cascading If constructs"
     stmt_classes = (ConditionalJump,)
 
-    def optimize(self, stmt: ConditionalJump, stmt_idx: int = None, block=None, **kwargs):
+    def optimize(self, stmt: ConditionalJump, stmt_idx: int | None = None, block=None, **kwargs):
         cond = stmt.condition
 
         # if (cond) {ITE(cond, true_branch, false_branch)} else {} ==> if (cond) {true_branch} else {}

angr/analyses/decompiler/peephole_optimizations/const_mull_a_shift.py

@@ -1,4 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 
 from ailment.expression import Convert, BinaryOp, Const
 
@@ -20,7 +21,7 @@ class ConstMullAShift(PeepholeOptimizationExprBase):
 
         if isinstance(expr, Convert):
             if expr.from_bits == 64 and expr.to_bits == 32:
-                r = self.optimize_binaryop(expr)
+                r = self.optimize_binaryop(expr.operand)
 
         elif isinstance(expr, BinaryOp):
             r = self.optimize_binaryop(expr)
@@ -35,16 +36,23 @@ class ConstMullAShift(PeepholeOptimizationExprBase):
         if isinstance(expr, BinaryOp) and expr.op == "Shr" and isinstance(expr.operands[1], Const):
             # (N * a) >> M  ==>  a / N1
             inner = expr.operands[0]
-            if isinstance(inner, BinaryOp) and inner.op == "Mull" and isinstance(inner.operands[0], Const):
-                C = inner.operands[0].value
-                X = inner.operands[1]
-                V = expr.operands[1].value
-                ndigits = 5 if V == 32 else 6
-                divisor = self._check_divisor(pow(2, V), C, ndigits)
-                if divisor is not None:
-                    new_const = Const(None, None, divisor, X.bits)
-                    new_div = BinaryOp(inner.idx, "Div", [X, new_const], inner.signed, **inner.tags)
-                    return new_div
+            if isinstance(inner, BinaryOp) and inner.op in {"Mull", "Mul"} and not inner.signed:
+                if isinstance(inner.operands[0], Const) and not isinstance(inner.operands[1], Const):
+                    C = inner.operands[0].value
+                    X = inner.operands[1]
+                elif isinstance(inner.operands[1], Const) and not isinstance(inner.operands[0], Const):
+                    C = inner.operands[1].value
+                    X = inner.operands[0]
+                else:
+                    C = X = None
+
+                if C is not None and X is not None:
+                    V = expr.operands[1].value
+                    ndigits = 5 if V == 32 else 6
+                    divisor = self._check_divisor(pow(2, V), C, ndigits)
+                    if divisor is not None:
+                        new_const = Const(None, None, divisor, X.bits)
+                        return BinaryOp(inner.idx, "Div", [X, new_const], inner.signed, **inner.tags)
 
         elif isinstance(expr, BinaryOp) and expr.op in {"Add", "Sub"}:
             expr0, expr1 = expr.operands
@@ -63,24 +71,81 @@ class ConstMullAShift(PeepholeOptimizationExprBase):
                 ):
                     a0 = expr0.operands[0].operands[0]
                     a1 = expr1.operands[0]
-                    if a0 == a1:
-                        # (a * x >> M1) +/- (a >> M2)  ==>  a / N
-                        C = expr0.operands[0].operands[1].value
-                        X = a0
-                        V = expr0.operands[1].value
-                        ndigits = 5 if V == 32 else 6
-                        divisor = self._check_divisor(pow(2, V), C, ndigits)
-                        if divisor is not None:
-                            new_const = Const(None, None, divisor, X.bits)
-                            new_div = BinaryOp(
-                                expr0.operands[0].idx,
-                                "Div",
-                                [X, new_const],
-                                expr0.operands[0].signed,
-                                **expr0.operands[0].tags,
-                            )
-                            # we cannot drop the convert in this case
-                            return new_div
+                elif (
+                    isinstance(expr1.operands[0], BinaryOp)
+                    and expr1.operands[0].op in {"Mull", "Mul"}
+                    and isinstance(expr1.operands[0].operands[1], Const)
+                ):
+                    a1 = expr0.operands[0].operands[0]
+                    a0 = expr1.operands[0]
+                else:
+                    a0, a1 = None, None
+                if a0 is not None and a1 is not None and a0.likes(a1):
+                    # (a * x >> M1) +/- (a >> M2)  ==>  a / N
+                    C = expr0.operands[0].operands[1].value
+                    X = a0
+                    V = expr0.operands[1].value
+                    ndigits = 5 if V == 32 else 6
+                    divisor = self._check_divisor(pow(2, V), C, ndigits)
+                    if divisor is not None:
+                        new_const = Const(None, None, divisor, X.bits)
+                        # we cannot drop the convert in this case
+                        return BinaryOp(
+                            expr0.operands[0].idx,
+                            "Div",
+                            [X, new_const],
+                            expr0.operands[0].signed,
+                            **expr0.operands[0].tags,
+                        )
+
+            # with Convert in consideration
+            if (
+                isinstance(expr0, BinaryOp)
+                and expr0.op in {"Shr", "Sar"}
+                and isinstance(expr0.operands[1], Const)
+                and expr0.operands[1].value == 0x3F
+                and isinstance(expr1, BinaryOp)
+                and expr1.op in {"Shr", "Sar"}
+                and isinstance(expr1.operands[1], Const)
+                and expr1.operands[1].value == 0x20
+            ):
+                expr0_operand = expr0.operands[0]
+                expr1_operand = expr1.operands[0]
+                if (
+                    isinstance(expr0_operand, BinaryOp)
+                    and expr0_operand.op in {"Mull", "Mul"}
+                    and expr0_operand.signed
+                    and isinstance(expr0_operand.operands[1], Const)
+                ):
+                    a0 = expr0_operand.operands[0]
+                    a1 = expr1_operand.operands[0]
+                elif (
+                    isinstance(expr1_operand, BinaryOp)
+                    and expr1_operand.op in {"Mull", "Mul"}
+                    and expr1_operand.signed
+                    and isinstance(expr1_operand.operands[1], Const)
+                ):
+                    a0 = expr1_operand.operands[0]
+                    a1 = expr0_operand.operands[0]
+                else:
+                    a0, a1 = None, None
+
+                if a0 is not None and a1 is not None and a0.likes(a1):
+                    # (a * x >> 0x3f) +/- (a * x >> 0x20)  ==>  a / N
+                    C = expr0_operand.operands[1].value
+                    X = a0
+                    V = 32
+                    ndigits = 5 if V == 32 else 6
+                    divisor = self._check_divisor(pow(2, V), C, ndigits)
+                    if divisor is not None:
+                        new_const = Const(None, None, divisor, X.bits)
+                        return BinaryOp(
+                            expr0_operand.idx,
+                            "Div",
+                            [X, new_const],
+                            expr0_operand.signed,
+                            **expr0_operand.tags,
+                        )
 
         return None
 

angr/analyses/decompiler/peephole_optimizations/constant_derefs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import Load, Const
 from cle.backends import Blob
 

angr/analyses/decompiler/peephole_optimizations/conv_a_sub0_shr_and.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import Convert, BinaryOp, Const
 
 from .base import PeepholeOptimizationExprBase
@@ -12,59 +13,57 @@ class ConvASub0ShrAnd(PeepholeOptimizationExprBase):
     def optimize(self, expr: Convert, **kwargs):
         # Conv(M->1, ((expr) >> N) & 1) => expr < 0
         # Conv(M->1, ((expr - 0) >> N) & 1) => expr < 0
-        if expr.to_bits == 1:
+        if expr.to_bits == 1 and (
+            isinstance(expr.operand, BinaryOp)
+            and expr.operand.op == "And"
+            and isinstance(expr.operand.operands[1], Const)
+            and expr.operand.operands[1].value == 1
+        ):
+            # taking a single bit
+            inner_expr = expr.operand.operands[0]
             if (
-                isinstance(expr.operand, BinaryOp)
-                and expr.operand.op == "And"
-                and isinstance(expr.operand.operands[1], Const)
-                and expr.operand.operands[1].value == 1
+                isinstance(inner_expr, BinaryOp)
+                and inner_expr.op == "Shr"
+                and isinstance(inner_expr.operands[1], Const)
             ):
-                # taking a single bit
-                inner_expr = expr.operand.operands[0]
-                if (
-                    isinstance(inner_expr, BinaryOp)
-                    and inner_expr.op == "Shr"
-                    and isinstance(inner_expr.operands[1], Const)
-                ):
-                    # right-shifting with a constant
-                    shr_amount = inner_expr.operands[1].value
-                    if shr_amount == 7:
-                        # int8_t
-                        to_bits = 8
-                    elif shr_amount == 15:
-                        # int16_t
-                        to_bits = 16
-                    elif shr_amount == 31:
-                        # int32_t
-                        to_bits = 32
-                    elif shr_amount == 63:
-                        # int64_t
-                        to_bits = 64
-                    else:
-                        # unsupported
-                        return None
+                # right-shifting with a constant
+                shr_amount = inner_expr.operands[1].value
+                if shr_amount == 7:
+                    # int8_t
+                    to_bits = 8
+                elif shr_amount == 15:
+                    # int16_t
+                    to_bits = 16
+                elif shr_amount == 31:
+                    # int32_t
+                    to_bits = 32
+                elif shr_amount == 63:
+                    # int64_t
+                    to_bits = 64
+                else:
+                    # unsupported
+                    return None
 
-                    real_expr = inner_expr.operands[0]
+                real_expr = inner_expr.operands[0]
 
-                    if (
-                        isinstance(real_expr, BinaryOp)
-                        and real_expr.op == "Sub"
-                        and isinstance(real_expr.operands[1], Const)
-                        and real_expr.operands[1].value == 0
-                    ):
-                        real_expr = real_expr.operands[0]
+                if (
+                    isinstance(real_expr, BinaryOp)
+                    and real_expr.op == "Sub"
+                    and isinstance(real_expr.operands[1], Const)
+                    and real_expr.operands[1].value == 0
+                ):
+                    real_expr = real_expr.operands[0]
 
-                    cvt = Convert(expr.idx, real_expr.bits, to_bits, False, real_expr, **expr.tags)
-                    cmp = BinaryOp(
-                        None,
-                        "CmpLT",
-                        (
-                            cvt,
-                            Const(None, None, 0, to_bits),
-                        ),
-                        True,
-                        **expr.tags,
-                    )
-                    return cmp
+                cvt = Convert(expr.idx, real_expr.bits, to_bits, False, real_expr, **expr.tags)
+                return BinaryOp(
+                    None,
+                    "CmpLT",
+                    (
+                        cvt,
+                        Const(None, None, 0, to_bits),
+                    ),
+                    True,
+                    **expr.tags,
+                )
 
         return None

angr/analyses/decompiler/peephole_optimizations/conv_shl_shr.py

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

angr/analyses/decompiler/peephole_optimizations/eager_eval.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from math import gcd
 
 from ailment.expression import BinaryOp, UnaryOp, Const, Convert, StackBaseOffset
@@ -18,9 +19,9 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
     def optimize(self, expr, **kwargs):
         if isinstance(expr, BinaryOp):
             return self._optimize_binaryop(expr)
-        elif isinstance(expr, Convert):
+        if isinstance(expr, Convert):
             return self._optimize_convert(expr)
-        elif isinstance(expr, UnaryOp):
+        if isinstance(expr, UnaryOp):
             return self._optimize_unaryop(expr)
         return None
 
@@ -29,10 +30,9 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
         if expr.op == "Add":
             if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
                 mask = (1 << expr.bits) - 1
-                new_expr = Const(
+                return Const(
                     expr.idx, None, (expr.operands[0].value + expr.operands[1].value) & mask, expr.bits, **expr.tags
                 )
-                return new_expr
             if isinstance(expr.operands[1], Const) and expr.operands[1].value == 0:
                 return expr.operands[0]
             if (
@@ -51,7 +51,7 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
                         expr.signed,
                         **expr.tags,
                     )
-                elif left.op == "Sub":
+                if left.op == "Sub":
                     return BinaryOp(
                         left.idx,
                         "Add",
@@ -78,10 +78,9 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
         elif expr.op == "Sub":
             if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
                 mask = (1 << expr.bits) - 1
-                new_expr = Const(
+                return Const(
                     expr.idx, None, (expr.operands[0].value - expr.operands[1].value) & mask, expr.bits, **expr.tags
                 )
-                return new_expr
             if (
                 isinstance(expr.operands[1], Const)
                 and isinstance(expr.operands[0], BinaryOp)
@@ -98,7 +97,7 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
                         expr.signed,
                         **expr.tags,
                     )
-                elif left.op == "Sub":
+                if left.op == "Sub":
                     return BinaryOp(
                         left.idx,
                         "Sub",
@@ -114,15 +113,18 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
 
         elif expr.op == "And":
             if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
-                new_expr = Const(
-                    expr.idx, None, (expr.operands[0].value & expr.operands[1].value), expr.bits, **expr.tags
-                )
-                return new_expr
+                return Const(expr.idx, None, (expr.operands[0].value & expr.operands[1].value), expr.bits, **expr.tags)
             if isinstance(expr.operands[1], Const) and expr.operands[1].value == 0:
                 return Const(expr.idx, None, 0, expr.bits, **expr.tags)
 
-        elif expr.op == "Mul" and isinstance(expr.operands[1], Const) and expr.operands[1].value == 1:
-            return expr.operands[0]
+        elif expr.op == "Mul":
+            if isinstance(expr.operands[1], Const) and expr.operands[1].value == 1:
+                return expr.operands[0]
+            if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
+                mask = (1 << expr.bits) - 1
+                return Const(
+                    expr.idx, None, (expr.operands[0].value * expr.operands[1].value) & mask, expr.bits, **expr.tags
+                )
 
         elif (
             expr.op == "Div"
@@ -152,8 +154,7 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
                         bits=expr0.bits,
                         **expr0.tags,
                     )
-                    div = BinaryOp(expr.idx, "Div", (mul, new_const_0), expr.signed, bits=expr.bits, **expr.tags)
-                    return div
+                    return BinaryOp(expr.idx, "Div", (mul, new_const_0), expr.signed, bits=expr.bits, **expr.tags)
 
         elif expr.op in {"Shr", "Sar"} and isinstance(expr.operands[1], Const):
             expr0, expr1 = expr.operands
@@ -162,24 +163,19 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
                 const_a = expr0.operands[1]
                 const_b = expr1
                 const = Const(const_b.idx, None, const_a.value + const_b.value, const_b.bits, **const_b.tags)
-                new_expr = BinaryOp(expr.idx, expr.op, (expr0.operands[0], const), False, bits=expr.bits, **expr.tags)
-                return new_expr
+                return BinaryOp(expr.idx, expr.op, (expr0.operands[0], const), False, bits=expr.bits, **expr.tags)
 
             if isinstance(expr0, BinaryOp) and expr0.op == "Div" and isinstance(expr0.operands[1], Const):
                 # (a / M0) >> M1  ==>  a / (M0 * 2 ** M1)
                 const_m0 = expr0.operands[1]
                 const_m1 = expr1
                 const = Const(const_m0.idx, None, const_m0.value * 2**const_m1.value, const_m0.bits, **const_m0.tags)
-                new_expr = BinaryOp(
-                    expr.idx, "Div", (expr0.operands[0], const), expr.signed, bits=expr.bits, **expr.tags
-                )
-                return new_expr
+                return BinaryOp(expr.idx, "Div", (expr0.operands[0], const), expr.signed, bits=expr.bits, **expr.tags)
 
             if isinstance(expr0, Const):
                 const_a = expr0.value
                 mask = (2**expr0.bits) - 1
-                new_expr = Const(expr0.idx, None, (const_a >> expr1.value) & mask, expr0.bits, **expr0.tags)
-                return new_expr
+                return Const(expr0.idx, None, (const_a >> expr1.value) & mask, expr0.bits, **expr0.tags)
 
             if expr.op == "Shr" and expr.operands[0].bits <= expr.operands[1].value:
                 return Const(expr.idx, None, 0, expr.operands[0].bits, **expr.tags)
@@ -189,8 +185,7 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
             if isinstance(expr0, Const):
                 const_a = expr0.value
                 mask = (2**expr0.bits) - 1
-                new_expr = Const(expr0.idx, None, (const_a << expr1.value) & mask, expr0.bits, **expr0.tags)
-                return new_expr
+                return Const(expr0.idx, None, (const_a << expr1.value) & mask, expr0.bits, **expr0.tags)
 
         elif expr.op == "Or":
             if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
@@ -209,17 +204,29 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
         if expr.op == "Neg" and isinstance(expr.operand, Const):
             const_a = expr.operand.value
             mask = (2**expr.bits) - 1
-            new_expr = Const(expr.idx, None, (~const_a) & mask, expr.bits, **expr.tags)
-            return new_expr
+            return Const(expr.idx, None, (~const_a) & mask, expr.bits, **expr.tags)
 
         return None
 
     @staticmethod
     def _optimize_convert(expr: Convert):
-        if isinstance(expr.operand, Const) and expr.from_type == Convert.TYPE_INT and expr.to_type == Convert.TYPE_INT:
-            if expr.from_bits > expr.to_bits:
-                # truncation
-                mask = (1 << expr.to_bits) - 1
-                v = expr.operand.value & mask
-                return Const(expr.idx, expr.operand.variable, v, expr.to_bits, **expr.operand.tags)
+        if (
+            isinstance(expr.operand, Const)
+            and expr.from_type == Convert.TYPE_INT
+            and expr.to_type == Convert.TYPE_INT
+            and expr.from_bits > expr.to_bits
+        ):
+            # truncation
+            mask = (1 << expr.to_bits) - 1
+            v = expr.operand.value & mask
+            return Const(expr.idx, expr.operand.variable, v, expr.to_bits, **expr.operand.tags)
+        if (
+            isinstance(expr.operand, Const)
+            and expr.from_type == Convert.TYPE_INT
+            and expr.to_type == Convert.TYPE_INT
+            and expr.from_bits <= expr.to_bits
+            and expr.is_signed is False
+        ):
+            # unsigned extension
+            return Const(expr.idx, expr.operand.variable, expr.operand.value, expr.to_bits, **expr.operand.tags)
         return None

angr/analyses/decompiler/peephole_optimizations/extended_byte_and_mask.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import BinaryOp, Const, Convert
 
 from .base import PeepholeOptimizationExprBase
@@ -19,7 +20,7 @@ class ExtendedByteAndMask(PeepholeOptimizationExprBase):
         #
         if expr.op == "And" and isinstance(expr.operands[1], Const):
             mask = expr.operands[1].value
-            to_bits = _MASK_TO_BITS.get(mask, None)
+            to_bits = _MASK_TO_BITS.get(mask)
             if to_bits is None:
                 return None