angr 9.2.103__py3-none-macosx_11_0_arm64.whl

angr/analyses/decompiler/peephole_optimizations/conv_a_sub0_shr_and.py

@@ -0,0 +1,70 @@
+from ailment.expression import Convert, BinaryOp, Const
+
+from .base import PeepholeOptimizationExprBase
+
+
+class ConvASub0ShrAnd(PeepholeOptimizationExprBase):
+    __slots__ = ()
+
+    NAME = "Conv(M->1, (expr >> N) & 1) => expr < 0"
+    expr_classes = (Convert,)  # all expressions are allowed
+
+    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 (
+                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(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
+
+                    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]
+
+                    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
+
+        return None

angr/analyses/decompiler/peephole_optimizations/conv_shl_shr.py

@@ -0,0 +1,51 @@
+from ailment.expression import Convert, BinaryOp, Const
+
+from .base import PeepholeOptimizationExprBase
+
+
+class ConvShlShr(PeepholeOptimizationExprBase):
+    __slots__ = ()
+
+    NAME = "(expr << P) >> Q => (expr & mask) >> R"
+    expr_classes = (BinaryOp,)  # all expressions are allowed
+
+    def optimize(self, expr: BinaryOp, **kwargs):
+        # (Conv(M->N, expr) << P) >> Q  ==>  (Conv(M->N, expr) & bitmask) >> (Q-P), where
+        #       Q >= P, and
+        #       M < N, and
+        #       bitmask = 0b('1' * (N - P))
+        if expr.op == "Shr" and isinstance(expr.operands[1], Const):
+            q = expr.operands[1].value
+            expr_b = expr.operands[0]
+            if isinstance(expr_b, BinaryOp) and expr_b.op == "Shl" and isinstance(expr_b.operands[1], Const):
+                p = expr_b.operands[1].value
+                expr_a = expr_b.operands[0]
+                if q >= p and isinstance(expr_a, Convert) and not expr_a.is_signed:
+                    m = expr_a.from_bits
+                    n = expr_a.to_bits
+                    if m < n and n >= p:
+                        bitmask = (1 << (n - p)) - 1
+                        and_expr = BinaryOp(
+                            None,
+                            "And",
+                            (
+                                Convert(expr_a.idx, m, n, False, expr_a.operand, **expr_a.tags),
+                                Const(None, None, bitmask, n),
+                            ),
+                            False,
+                            variable=None,
+                            variable_offset=None,
+                            **expr.tags,
+                        )
+                        return BinaryOp(
+                            None,
+                            "Shr",
+                            (
+                                and_expr,
+                                Const(None, None, q - p, and_expr.bits),
+                            ),
+                            False,
+                            **expr.tags,
+                        )
+
+        return None

angr/analyses/decompiler/peephole_optimizations/eager_eval.py

@@ -0,0 +1,225 @@
+from math import gcd
+
+from ailment.expression import BinaryOp, UnaryOp, Const, Convert, StackBaseOffset
+
+from .base import PeepholeOptimizationExprBase
+
+
+class EagerEvaluation(PeepholeOptimizationExprBase):
+    """
+    Eagerly evaluates certain types of expressions.
+    """
+
+    __slots__ = ()
+
+    NAME = "Eager expression evaluation"
+    expr_classes = (BinaryOp, UnaryOp, Convert)
+
+    def optimize(self, expr, **kwargs):
+        if isinstance(expr, BinaryOp):
+            return self._optimize_binaryop(expr)
+        elif isinstance(expr, Convert):
+            return self._optimize_convert(expr)
+        elif isinstance(expr, UnaryOp):
+            return self._optimize_unaryop(expr)
+        return None
+
+    @staticmethod
+    def _optimize_binaryop(expr: BinaryOp):
+        if expr.op == "Add":
+            if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
+                mask = (1 << expr.bits) - 1
+                new_expr = 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 (
+                isinstance(expr.operands[1], Const)
+                and isinstance(expr.operands[0], BinaryOp)
+                and isinstance(expr.operands[0].operands[1], Const)
+            ):
+                left = expr.operands[0]
+                inner_expr, const_0 = left.operands
+                const_1 = expr.operands[1]
+                if left.op == "Add":
+                    return BinaryOp(
+                        left.idx,
+                        "Add",
+                        [inner_expr, Const(const_0.idx, None, const_0.value + const_1.value, const_0.bits)],
+                        expr.signed,
+                        **expr.tags,
+                    )
+                elif left.op == "Sub":
+                    return BinaryOp(
+                        left.idx,
+                        "Add",
+                        [inner_expr, Const(const_0.idx, None, const_1.value - const_0.value, const_0.bits)],
+                        expr.signed,
+                        **expr.tags,
+                    )
+            if (
+                isinstance(expr.operands[0], BinaryOp)
+                and expr.operands[0].op == "Mul"
+                and isinstance(expr.operands[0].operands[1], Const)
+                and expr.operands[0].operands[0].likes(expr.operands[1])
+            ):
+                # A * x + x => (A + 1) * x
+                coeff_expr = expr.operands[0].operands[1]
+                new_coeff = coeff_expr.value + 1
+                return BinaryOp(
+                    expr.idx,
+                    "Mul",
+                    [Const(coeff_expr.idx, None, new_coeff, coeff_expr.bits), expr.operands[1]],
+                    expr.signed,
+                    **expr.tags,
+                )
+        elif expr.op == "Sub":
+            if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
+                mask = (1 << expr.bits) - 1
+                new_expr = 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)
+                and isinstance(expr.operands[0].operands[1], Const)
+            ):
+                left = expr.operands[0]
+                inner_expr, const_0 = left.operands
+                const_1 = expr.operands[1]
+                if left.op == "Add":
+                    return BinaryOp(
+                        left.idx,
+                        "Sub",
+                        [inner_expr, Const(const_0.idx, None, const_1.value - const_0.value, const_0.bits)],
+                        expr.signed,
+                        **expr.tags,
+                    )
+                elif left.op == "Sub":
+                    return BinaryOp(
+                        left.idx,
+                        "Sub",
+                        [inner_expr, Const(const_0.idx, None, const_0.value + const_1.value, const_0.bits)],
+                        expr.signed,
+                        **expr.tags,
+                    )
+            if isinstance(expr.operands[0], Const) and expr.operands[0].value == 0:
+                return UnaryOp(expr.idx, "Neg", expr.operands[1], **expr.tags)
+
+            if isinstance(expr.operands[0], StackBaseOffset) and isinstance(expr.operands[1], StackBaseOffset):
+                return Const(expr.idx, None, expr.operands[0].offset - expr.operands[1].offset, expr.bits, **expr.tags)
+
+        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
+            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 == "Div"
+            and isinstance(expr.operands[1], Const)
+            and isinstance(expr.operands[0], BinaryOp)
+            and expr.operands[0].op == "Mul"
+            and isinstance(expr.operands[0].operands[1], Const)
+        ):
+            expr0, const_0 = expr.operands
+            const_1 = expr0.operands[1]
+            if const_0.value != 0 and const_1.value != 0:
+                gcd_ = gcd(const_0.value, const_1.value)
+                if gcd_ != 1:
+                    new_const_1 = Const(
+                        const_1.idx, const_1.variable, const_1.value // gcd_, const_1.bits, **const_1.tags
+                    )
+                    new_const_0 = Const(
+                        const_0.idx, const_0.variable, const_0.value // gcd_, const_0.bits, **const_0.tags
+                    )
+                    mul = BinaryOp(
+                        expr0.idx,
+                        "Mul",
+                        (expr0.operands[0], new_const_1),
+                        expr0.signed,
+                        variable=expr0.variable,
+                        variable_offset=expr0.variable_offset,
+                        bits=expr0.bits,
+                        **expr0.tags,
+                    )
+                    div = BinaryOp(expr.idx, "Div", (mul, new_const_0), expr.signed, bits=expr.bits, **expr.tags)
+                    return div
+
+        elif expr.op in {"Shr", "Sar"} and isinstance(expr.operands[1], Const):
+            expr0, expr1 = expr.operands
+            if isinstance(expr0, BinaryOp) and expr0.op == "Shr" and isinstance(expr0.operands[1], Const):
+                # (a >> M) >> N  ==>  a >> (M + N)
+                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
+
+            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
+
+            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
+
+            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)
+
+        elif expr.op == "Shl" and isinstance(expr.operands[1], Const):
+            expr0, expr1 = expr.operands
+            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
+
+        elif expr.op == "Or":
+            if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):
+                return Const(expr.idx, None, expr.operands[0].value | expr.operands[1].value, expr.bits, **expr.tags)
+            if isinstance(expr.operands[0], Const) and expr.operands[0].value == 0:
+                return expr.operands[1]
+            if isinstance(expr.operands[1], Const) and expr.operands[1].value == 0:
+                return expr.operands[0]
+            if expr.operands[0].likes(expr.operands[1]):
+                return expr.operands[0]
+
+        return None
+
+    @staticmethod
+    def _optimize_unaryop(expr: UnaryOp):
+        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 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)
+        return None

angr/analyses/decompiler/peephole_optimizations/extended_byte_and_mask.py

@@ -0,0 +1,55 @@
+from ailment.expression import BinaryOp, Const, Convert
+
+from .base import PeepholeOptimizationExprBase
+
+_MASK_TO_BITS = {
+    0xFF: 8,
+    0xFFFF: 16,
+    0xFFFF_FFFF: 32,
+}
+
+
+class ExtendedByteAndMask(PeepholeOptimizationExprBase):
+    __slots__ = ()
+
+    NAME = "extended byte & 0xff..ff => extended byte"
+    expr_classes = (BinaryOp,)  # all expressions are allowed
+
+    def optimize(self, expr: BinaryOp, **kwargs):
+        #
+        if expr.op == "And" and isinstance(expr.operands[1], Const):
+            mask = expr.operands[1].value
+            to_bits = _MASK_TO_BITS.get(mask, None)
+            if to_bits is None:
+                return None
+
+            if isinstance(expr.operands[0], Convert):
+                conv: Convert = expr.operands[0]
+                atom = conv.operand
+                if conv.from_bits <= to_bits:
+                    # this masking is useless
+                    return Convert(None, conv.from_bits, expr.bits, conv.is_signed, atom, **conv.tags)
+
+            elif (
+                isinstance(expr.operands[0], BinaryOp)
+                and expr.operands[0].op in {"Shl", "Shr", "Sar"}
+                and isinstance(expr.operands[0].operands[0], Convert)
+            ):
+                binop_expr = expr.operands[0]
+                conv: Convert = expr.operands[0].operands[0]
+                atom = conv.operand
+                if conv.from_bits <= to_bits:
+                    # this masking is useless
+                    # apply the binary operation
+                    atom = BinaryOp(
+                        None,
+                        binop_expr.op,
+                        (atom, binop_expr.operands[1]),
+                        binop_expr.signed,
+                        variable=binop_expr.variable,
+                        variable_offset=binop_expr.variable_offset,
+                        **binop_expr.tags,
+                    )
+                    return Convert(None, conv.from_bits, expr.bits, conv.is_signed, atom, **conv.tags)
+
+        return None

angr/analyses/decompiler/peephole_optimizations/inlined_strcpy.py

@@ -0,0 +1,146 @@
+# pylint:disable=arguments-differ
+import string
+
+from archinfo import Endness
+
+from ailment.expression import Const, StackBaseOffset
+from ailment.statement import Call, Store
+
+from .base import PeepholeOptimizationStmtBase
+
+
+ASCII_PRINTABLES = set(string.printable)
+ASCII_DIGITS = set(string.digits)
+
+
+class InlinedStrcpy(PeepholeOptimizationStmtBase):
+    """
+    Simplifies inlined string copying logic into calls to strcpy.
+    """
+
+    __slots__ = ()
+
+    NAME = "Simplifying inlined strcpy"
+    stmt_classes = (Store,)
+
+    def optimize(self, stmt: Store, stmt_idx: int = None, block=None, **kwargs):
+        if isinstance(stmt.data, Const) and isinstance(stmt.data.value, int):
+            r, s = self.is_integer_likely_a_string(stmt.data.value, stmt.data.size, stmt.endness)
+            if r:
+                # replace it with a call to strncpy
+                str_id = self.kb.custom_strings.allocate(s.encode("ascii"))
+                return Call(
+                    stmt.idx,
+                    "strncpy",
+                    args=[
+                        stmt.addr,
+                        Const(None, None, str_id, stmt.addr.bits, custom_string=True),
+                        Const(None, None, len(s), self.project.arch.bits),
+                    ],
+                    **stmt.tags,
+                )
+
+            # scan forward in the current block to find all consecutive constant stores
+            if block is not None and stmt_idx is not None:
+                all_constant_stores: dict[int, tuple[int, Const | None]] = self.collect_constant_stores(block, stmt_idx)
+                if all_constant_stores:
+                    offsets = sorted(all_constant_stores.keys())
+                    next_offset = min(offsets)
+                    stride = []
+                    for offset in offsets:
+                        if next_offset is not None and offset != next_offset:
+                            next_offset = None
+                            stride = []
+                        stmt_idx_, v = all_constant_stores[offset]
+                        if v is not None:
+                            stride.append((offset, stmt_idx_, v))
+                            next_offset = offset + v.size
+                        else:
+                            next_offset = None
+                            stride = []
+
+                    integer, size = self.stride_to_int(stride)
+                    r, s = self.is_integer_likely_a_string(integer, size, Endness.BE)
+                    if r:
+                        # we remove all involved statements whose statement IDs are greater than the current one
+                        for _, stmt_idx_, _ in reversed(stride):
+                            if stmt_idx_ <= stmt_idx:
+                                continue
+                            block.statements[stmt_idx_] = None
+                        block.statements = [ss for ss in block.statements if ss is not None]
+
+                        str_id = self.kb.custom_strings.allocate(s.encode("ascii"))
+                        return Call(
+                            stmt.idx,
+                            "strncpy",
+                            args=[
+                                stmt.addr,
+                                Const(None, None, str_id, stmt.addr.bits, custom_string=True),
+                                Const(None, None, len(s), self.project.arch.bits),
+                            ],
+                            **stmt.tags,
+                        )
+
+        return None
+
+    @staticmethod
+    def stride_to_int(stride: list[tuple[int, int, Const]]) -> tuple[int, int]:
+        stride = sorted(stride, key=lambda x: x[0])
+        n = 0
+        size = 0
+        for _, _, v in stride:
+            size += v.size
+            n <<= v.bits
+            n |= v.value
+        return n, size
+
+    @staticmethod
+    def collect_constant_stores(block, starting_stmt_idx: int) -> dict[int, tuple[int, Const | None]]:
+        r = {}
+        for idx, stmt in enumerate(block.statements):
+            if idx < starting_stmt_idx:
+                continue
+            if isinstance(stmt, Store) and isinstance(stmt.addr, StackBaseOffset) and isinstance(stmt.addr.offset, int):
+                if isinstance(stmt.data, Const):
+                    r[stmt.addr.offset] = idx, stmt.data
+                else:
+                    r[stmt.addr.offset] = idx, None
+
+        return r
+
+    @staticmethod
+    def is_integer_likely_a_string(v: int, size: int, endness: Endness, min_length: int = 4) -> tuple[bool, str | None]:
+        # we need at least four bytes of printable characters
+
+        chars = []
+        if endness == Endness.LE:
+            while v != 0:
+                byt = v & 0xFF
+                if chr(byt) not in ASCII_PRINTABLES:
+                    return False, None
+                chars.append(chr(byt))
+                v >>= 8
+
+        elif endness == Endness.BE:
+            first_non_zero = False
+            for _ in range(size):
+                byt = v & 0xFF
+                v >>= 8
+                if byt == 0:
+                    if first_non_zero:
+                        return False, None
+                    continue
+                first_non_zero = True  # this is the first non-zero byte
+                if chr(byt) not in ASCII_PRINTABLES:
+                    return False, None
+                chars.append(chr(byt))
+            chars = chars[::-1]
+        else:
+            # unsupported endness
+            return False, None
+
+        if len(chars) >= min_length:
+            if len(chars) <= 4 and all(ch in ASCII_DIGITS for ch in chars):
+                return False, None
+            return True, "".join(chars)
+        return False, None

angr/analyses/decompiler/peephole_optimizations/inlined_strcpy_consolidation.py

@@ -0,0 +1,102 @@
+# pylint:disable=arguments-differ
+
+from ailment.expression import Expression, BinaryOp, Const, Register, StackBaseOffset
+from ailment.statement import Call, Store
+
+from .base import PeepholeOptimizationMultiStmtBase
+from .inlined_strcpy import InlinedStrcpy
+
+
+class InlinedStrcpyConsolidation(PeepholeOptimizationMultiStmtBase):
+    """
+    Consolidate multiple inlined strcpy calls.
+    """
+
+    __slots__ = ()
+
+    NAME = "Consolidate multiple inlined strcpy calls"
+    stmt_classes = ((Call, Call), (Call, Store))
+
+    def optimize(self, stmts: list[Call], **kwargs):
+        last_stmt, stmt = stmts
+        if InlinedStrcpyConsolidation._is_inlined_strcpy(last_stmt):
+            s_last: bytes = self.kb.custom_strings[last_stmt.args[1].value]
+            addr_last = last_stmt.args[0]
+            new_str = None  # will be set if consolidation should happen
+
+            if isinstance(stmt, Call) and InlinedStrcpyConsolidation._is_inlined_strcpy(stmt):
+                # consolidating two calls
+                s_curr: bytes = self.kb.custom_strings[stmt.args[1].value]
+                addr_curr = stmt.args[0]
+                # determine if the two addresses are consecutive
+                delta = self._get_delta(addr_last, addr_curr)
+                if delta is not None and delta == len(s_last):
+                    # consolidate both calls!
+                    new_str = s_last + s_curr
+            elif isinstance(stmt, Store) and isinstance(stmt.data, Const):
+                # consolidating a call and a store, in case the store statement is storing the suffix of a string (but
+                # the suffix is too short to qualify an inlined strcpy optimization)
+                addr_curr = stmt.addr
+                delta = self._get_delta(addr_last, addr_curr)
+                if delta is not None and delta == len(s_last):
+                    if stmt.size == 1 and stmt.data.value == 0:
+                        # it's probably the terminating null byte
+                        r, s = True, "\x00"
+                    else:
+                        r, s = InlinedStrcpy.is_integer_likely_a_string(
+                            stmt.data.value, stmt.size, stmt.endness, min_length=1
+                        )
+                    if r:
+                        new_str = s_last + s.encode("ascii")
+
+            if new_str is not None:
+                if new_str.endswith(b"\x00"):
+                    call_name = "strcpy"
+                    new_str_idx = self.kb.custom_strings.allocate(new_str[:-1])
+                    args = [
+                        last_stmt.args[0],
+                        Const(None, None, new_str_idx, last_stmt.args[0].bits, custom_string=True),
+                    ]
+                else:
+                    call_name = "strncpy"
+                    new_str_idx = self.kb.custom_strings.allocate(new_str)
+                    args = [
+                        last_stmt.args[0],
+                        Const(None, None, new_str_idx, last_stmt.args[0].bits, custom_string=True),
+                        Const(None, None, len(new_str), self.project.arch.bits),
+                    ]
+
+                return [Call(stmt.idx, call_name, args=args, **stmt.tags)]
+
+        return None
+
+    @staticmethod
+    def _is_inlined_strcpy(stmt: Call):
+        if isinstance(stmt.target, str) and stmt.target == "strncpy":
+            if len(stmt.args) == 3 and isinstance(stmt.args[1], Const) and hasattr(stmt.args[1], "custom_string"):
+                return True
+        return False
+
+    @staticmethod
+    def _parse_addr(addr: Expression) -> tuple[Expression, int]:
+        if isinstance(addr, Register):
+            return addr, 0
+        if isinstance(addr, StackBaseOffset):
+            return StackBaseOffset(None, addr.bits, 0), addr.offset
+        if isinstance(addr, BinaryOp):
+            if addr.op == "Add" and isinstance(addr.operands[1], Const):
+                base_0, offset_0 = InlinedStrcpyConsolidation._parse_addr(addr.operands[0])
+                return base_0, offset_0 + addr.operands[1].value
+            if addr.op == "Sub" and isinstance(addr.operands[1], Const):
+                base_0, offset_0 = InlinedStrcpyConsolidation._parse_addr(addr.operands[0])
+                return base_0, offset_0 - addr.operands[1].value
+
+        return addr, 0
+
+    @staticmethod
+    def _get_delta(addr_0: Expression, addr_1: Expression) -> int | None:
+        base_0, offset_0 = InlinedStrcpyConsolidation._parse_addr(addr_0)
+        base_1, offset_1 = InlinedStrcpyConsolidation._parse_addr(addr_1)
+        if base_0.likes(base_1):
+            return offset_1 - offset_0
+        return None