rust: bump pyo3 from 0.27.1 to 0.27.2

angr/__init__.py

@@ -168,6 +168,7 @@
 from .sim_manager import SimulationManager
 from .analyses import Analysis, register_analysis
 from . import analyses
+from .rust.analyses import *
 from . import knowledge_plugins
 from . import exploration_techniques
 from .exploration_techniques import ExplorationTechnique

angr/ailment/block_walker.py

@@ -1,6 +1,7 @@
 # pylint:disable=unused-argument,no-self-use
 # pyright: reportIncompatibleMethodOverride=false
 from __future__ import annotations
+from collections import OrderedDict
 from typing import Any
 from collections.abc import Callable
 
@@ -16,6 +17,7 @@
     Jump,
     DirtyStatement,
     WeakAssignment,
+    FunctionLikeMacro,
 )
 from .expression import (
     Load,
@@ -33,6 +35,11 @@
     MultiStatementExpression,
     VirtualVariable,
     Phi,
+    Enum,
+    Struct,
+    Array,
+    StringLiteral,
+    ComboRegister,
 )
 
 
@@ -65,11 +72,17 @@ def __init__(self, stmt_handlers=None, expr_handlers=None):
             VEXCCallExpression: self._handle_VEXCCallExpression,
             Tmp: self._handle_Tmp,
             Register: self._handle_Register,
+            ComboRegister: self._handle_ComboRegister,
             Reinterpret: self._handle_Reinterpret,
             Const: self._handle_Const,
             MultiStatementExpression: self._handle_MultiStatementExpression,
             VirtualVariable: self._handle_VirtualVariable,
             Phi: self._handle_Phi,
+            Enum: self._handle_Enum,
+            Struct: self._handle_Struct,
+            Array: self._handle_Array,
+            FunctionLikeMacro: self._handle_FunctionLikeMacroExpr,
+            StringLiteral: self._handle_StringLiteral,
         }
 
         self.stmt_handlers: dict[type, Callable] = stmt_handlers if stmt_handlers else _default_stmt_handlers
@@ -207,6 +220,12 @@ def _handle_Tmp(self, expr_idx: int, expr: Tmp, stmt_idx: int, stmt: Statement,
     def _handle_Register(self, expr_idx: int, expr: Register, stmt_idx: int, stmt: Statement, block: Block | None):
         pass
 
+    def _handle_ComboRegister(
+        self, expr_idx: int, expr: ComboRegister, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        for idx, reg in enumerate(expr.registers):
+            self._handle_expr(idx, reg, stmt_idx, stmt, block)
+
     def _handle_Const(self, expr_idx: int, expr: Const, stmt_idx: int, stmt: Statement, block: Block | None):
         pass
 
@@ -241,6 +260,35 @@ def _handle_VEXCCallExpression(
         for idx, operand in enumerate(expr.operands):
             self._handle_expr(idx, operand, stmt_idx, stmt, block)
 
+    def _handle_Enum(self, expr_idx: int, expr: Enum, stmt_idx: int, stmt: Statement, block: Block | None):
+        for idx, field in enumerate(expr.fields):
+            self._handle_expr(idx, field, stmt_idx, stmt, block)
+
+    def _handle_Struct(self, expr_idx: int, expr: Struct, stmt_idx: int, stmt: Statement, block: Block | None):
+        for idx, field in enumerate(expr.fields.values()):
+            self._handle_expr(idx, field, stmt_idx, stmt, block)
+
+    def _handle_Array(self, expr_idx: int, expr: Array, stmt_idx: int, stmt: Statement, block: Block | None):
+        for idx, ele in enumerate(expr.elements):
+            self._handle_expr(idx, ele, stmt_idx, stmt, block)
+
+    def _handle_FunctionLikeMacro(self, stmt_idx: int, stmt: FunctionLikeMacro, block: Block | None):
+        if stmt.args:
+            for i, arg in enumerate(stmt.args):
+                self._handle_expr(i, arg, stmt_idx, stmt, block)
+
+    def _handle_FunctionLikeMacroExpr(
+        self, expr_idx: int, expr: FunctionLikeMacro, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        if expr.args:
+            for i, arg in enumerate(expr.args):
+                self._handle_expr(i, arg, stmt_idx, stmt, block)
+
+    def _handle_StringLiteral(
+        self, expr_idx: int, expr: StringLiteral, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        pass
+
 
 class AILBlockWalker(AILBlockWalkerBase):
     """
@@ -466,14 +514,20 @@ def _handle_Call(self, stmt_idx: int, stmt: Call, block: Block | None):
                         new_args.append(arg)
                 i += 1
 
+        new_ret_expr = None
+        if stmt.ret_expr is not None:
+            new_ret_expr = self._handle_expr(-1, stmt.ret_expr, stmt_idx, stmt, block)
+            if new_ret_expr is not None and new_ret_expr is not stmt.ret_expr:
+                changed = True
+
         if changed:
             new_stmt = Call(
                 stmt.idx,
                 new_target if new_target is not None else stmt.target,
                 calling_convention=stmt.calling_convention,
                 prototype=stmt.prototype,
                 args=new_args,
-                ret_expr=stmt.ret_expr,
+                ret_expr=new_ret_expr or stmt.ret_expr,
                 **stmt.tags,
             )
             if self._update_block and block is not None:
@@ -622,6 +676,27 @@ def _handle_DirtyStatement(self, stmt_idx: int, stmt: DirtyStatement, block: Blo
     # Expression handlers
     #
 
+    def _handle_ComboRegister(
+        self, expr_idx: int, expr: ComboRegister, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        changed = False
+        new_regs = []
+
+        for idx, reg in enumerate(expr.registers):
+            new_reg = self._handle_expr(idx, reg, stmt_idx, stmt, block)
+            if new_reg and new_reg is not reg:
+                changed = True
+                new_regs.append(new_reg)
+            else:
+                new_regs.append(reg)
+
+        if changed:
+            new_expr = expr.copy()
+            new_expr.registers = new_regs
+            return new_expr
+
+        return None
+
     def _handle_Load(self, expr_idx: int, expr: Load, stmt_idx: int, stmt: Statement, block: Block | None):
         addr = self._handle_expr(0, expr.addr, stmt_idx, stmt, block)
 
@@ -843,3 +918,113 @@ def _handle_MultiStatementExpression(
             expr_.stmts = new_statements
             return expr_
         return None
+
+    def _handle_Enum(self, expr_idx: int, expr: Enum, stmt_idx: int, stmt: Statement, block: Block | None):
+        changed = False
+        new_fields = []
+        for idx, field in enumerate(expr.fields):
+            new_field = self._handle_expr(idx, field, stmt_idx, stmt, block)
+            if new_field is not None and new_field is not field:
+                changed = True
+                new_fields.append(new_field)
+            else:
+                new_fields.append(field)
+
+        if changed:
+            new_expr = expr.copy()
+            new_expr.fields = tuple(new_fields)
+            return new_expr
+        return None
+
+    def _handle_Struct(self, expr_idx: int, expr: Struct, stmt_idx: int, stmt: Statement, block: Block | None):
+        changed = False
+        new_fields = OrderedDict()
+        for idx, (offset, field) in enumerate(expr.fields.items()):
+            new_field = self._handle_expr(idx, field, stmt_idx, stmt, block)
+            if new_field is not None and new_field is not field:
+                changed = True
+                new_fields[offset] = new_field
+            else:
+                new_fields[offset] = field
+
+        if changed:
+            new_expr = expr.copy()
+            new_expr.fields = new_fields
+            return new_expr
+        return None
+
+    def _handle_Array(self, expr_idx: int, expr: Array, stmt_idx: int, stmt: Statement, block: Block | None):
+        changed = False
+        new_elements = []
+        for idx, ele in enumerate(expr.elements):
+            new_ele = self._handle_expr(idx, ele, stmt_idx, stmt, block)
+            if new_ele is not None and new_ele is not ele:
+                changed = True
+                new_elements.append(new_ele)
+            else:
+                new_elements.append(ele)
+
+        if changed:
+            new_expr = expr.copy()
+            new_expr.elements = tuple(new_elements)
+            return new_expr
+        return None
+
+    def _handle_FunctionLikeMacro(self, stmt_idx: int, stmt: FunctionLikeMacro, block: Block | None):
+        changed = False
+
+        new_args = None
+        if stmt.args is not None:
+            new_args = []
+
+            i = 0
+            while i < len(stmt.args):
+                arg = stmt.args[i]
+                new_arg = self._handle_expr(i, arg, stmt_idx, stmt, block)
+                if new_arg is not None and new_arg is not arg:
+                    if not changed:
+                        # initialize new_args
+                        new_args = list(stmt.args[:i])
+                    new_args.append(new_arg)
+                    changed = True
+                else:
+                    if changed:
+                        new_args.append(arg)
+                i += 1
+
+        if changed:
+            new_stmt = stmt.copy()
+            new_stmt.args = new_args
+            if self._update_block and block is not None:
+                block.statements[stmt_idx] = new_stmt
+            return new_stmt
+        return None
+
+    def _handle_FunctionLikeMacroExpr(
+        self, expr_idx: int, expr: FunctionLikeMacro, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        changed = False
+
+        new_args = None
+        if expr.args is not None:
+            i = 0
+            new_args = []
+            while i < len(expr.args):
+                arg = expr.args[i]
+                new_arg = self._handle_expr(i, arg, stmt_idx, stmt, block)
+                if new_arg is not None and new_arg is not arg:
+                    if not changed:
+                        # initialize new_args
+                        new_args = list(expr.args[:i])
+                    new_args.append(new_arg)
+                    changed = True
+                else:
+                    if changed:
+                        new_args.append(arg)
+                i += 1
+
+        if changed:
+            expr = expr.copy()
+            expr.args = new_args
+            return expr
+        return None