angr 9.2.101__py3-none-win_amd64.whl → 9.2.103__py3-none-win_amd64.whl

angr/knowledge_plugins/propagations/prop_value.py

@@ -1,4 +1,5 @@
-from typing import Dict, Any, Tuple, Iterable, Generator, Optional, TYPE_CHECKING
+from typing import Any, Optional, TYPE_CHECKING
+from collections.abc import Iterable, Generator
 
 import claripy
 import ailment
@@ -17,7 +18,7 @@ class Detail:
 
     __slots__ = ("size", "expr", "def_at")
 
-    def __init__(self, size: int, expr: Optional[ailment.Expression], def_at: Optional["CodeLocation"]):
+    def __init__(self, size: int, expr: ailment.Expression | None, def_at: Optional["CodeLocation"]):
         self.size = size
         self.expr = expr
         self.def_at = def_at
@@ -39,7 +40,7 @@ class PropValue:
         "offset_and_details",
     )
 
-    def __init__(self, value: claripy.ast.Bits, offset_and_details: Optional[Dict[int, Detail]] = None):
+    def __init__(self, value: claripy.ast.Bits, offset_and_details: dict[int, Detail] | None = None):
         self.value = value
         self.offset_and_details = offset_and_details
 
@@ -48,7 +49,7 @@ class PropValue:
         return not bool(self.offset_and_details)
 
     @property
-    def one_expr(self) -> Optional[ailment.Expression]:
+    def one_expr(self) -> ailment.Expression | None:
         """
         Get the expression that starts at offset 0 and covers the entire PropValue. Returns None if there are no
         expressions or multiple expressions.
@@ -109,7 +110,7 @@ class PropValue:
             value = claripy.fpToIEEEBV(value)
         return value[chop_start:chop_end]
 
-    def value_and_labels(self) -> Generator[Tuple[int, claripy.ast.Bits, int, Optional[Dict]], None, None]:
+    def value_and_labels(self) -> Generator[tuple[int, claripy.ast.Bits, int, dict | None], None, None]:
         if not self.offset_and_details:
             return
         keys = list(sorted(self.offset_and_details.keys()))
@@ -140,7 +141,7 @@ class PropValue:
 
     @staticmethod
     def from_value_and_labels(
-        value: claripy.ast.Bits, labels: Iterable[Tuple[int, int, int, Dict[str, Any]]]
+        value: claripy.ast.Bits, labels: Iterable[tuple[int, int, int, dict[str, Any]]]
     ) -> "PropValue":
         if not labels:
             return PropValue(value)
@@ -164,8 +165,8 @@ class PropValue:
 
     @staticmethod
     def extract_ail_expression(
-        start: int, bits: int, expr: Optional[ailment.Expr.Expression]
-    ) -> Optional[ailment.Expr.Expression]:
+        start: int, bits: int, expr: ailment.Expr.Expression | None
+    ) -> ailment.Expr.Expression | None:
         if expr is None:
             return None
 
@@ -182,7 +183,7 @@ class PropValue:
             return ailment.Expr.Convert(None, a.bits, bits, False, a, **expr.tags)
 
     @staticmethod
-    def extend_ail_expression(bits: int, expr: Optional[ailment.Expr.Expression]) -> Optional[ailment.Expr.Expression]:
+    def extend_ail_expression(bits: int, expr: ailment.Expr.Expression | None) -> ailment.Expr.Expression | None:
         if expr is None:
             return None
         if isinstance(expr, ailment.Expr.Const):

angr/knowledge_plugins/propagations/propagation_manager.py

@@ -1,5 +1,3 @@
-from typing import Dict, Tuple
-
 from angr.knowledge_plugins.plugin import KnowledgeBasePlugin
 from .propagation_model import PropagationModel
 
@@ -11,9 +9,9 @@ class PropagationManager(KnowledgeBasePlugin):
 
     def __init__(self, kb):
         super().__init__(kb=kb)
-        self._propagations: Dict[Tuple, PropagationModel] = {}
+        self._propagations: dict[tuple, PropagationModel] = {}
 
-    def exists(self, prop_key: Tuple) -> bool:
+    def exists(self, prop_key: tuple) -> bool:
         """
         Internal function to check if a func, specified as a CodeLocation
         exists in our known propagations
@@ -23,7 +21,7 @@ class PropagationManager(KnowledgeBasePlugin):
         """
         return prop_key in self._propagations
 
-    def update(self, prop_key: Tuple, model: PropagationModel) -> None:
+    def update(self, prop_key: tuple, model: PropagationModel) -> None:
         """
         Add the replacements to known propagations
 

angr/knowledge_plugins/propagations/propagation_model.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Dict, Set, DefaultDict, Any, Optional
+from typing import DefaultDict, Any
 from collections import defaultdict
 
 import claripy
@@ -29,14 +29,14 @@ class PropagationModel(Serializable):
 
     def __init__(
         self,
-        prop_key: Tuple,
-        node_iterations: Optional[DefaultDict[Any, int]] = None,
-        states: Optional[Dict] = None,
-        block_initial_reg_values: Optional[Dict] = None,
-        replacements: Optional[DefaultDict[Any, Dict]] = None,
-        equivalence: Optional[Set] = None,
-        function: Optional[Function] = None,
-        input_states: Optional[Dict] = None,
+        prop_key: tuple,
+        node_iterations: DefaultDict[Any, int] | None = None,
+        states: dict | None = None,
+        block_initial_reg_values: dict | None = None,
+        replacements: DefaultDict[Any, dict] | None = None,
+        equivalence: set | None = None,
+        function: Function | None = None,
+        input_states: dict | None = None,
     ):
         self.key = prop_key
         self.node_iterations = node_iterations if node_iterations is not None else defaultdict(int)

angr/knowledge_plugins/propagations/states.py

@@ -1,5 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
-from typing import Set, Optional, Union, Tuple, DefaultDict, List, Any, Dict, TYPE_CHECKING
+from typing import Optional, Union, DefaultDict, Any, TYPE_CHECKING
 from collections import defaultdict
 import weakref
 
@@ -39,7 +39,7 @@ class CallExprFinder(ailment.AILBlockWalker):
         expr: ailment.Stmt.Call,
         stmt_idx: int,
         stmt: ailment.Stmt.Statement,
-        block: Optional[ailment.Block],
+        block: ailment.Block | None,
     ):
         self.has_call = True
 
@@ -73,6 +73,7 @@ class PropagatorState:
         "_gp",
         "_max_prop_expr_occurrence",
         "model",
+        "_artificial_reg_offsets",
         "__weakref__",
     )
 
@@ -83,14 +84,15 @@ class PropagatorState:
         arch: "Arch",
         project: Optional["Project"] = None,
         rda=None,
-        replacements: Optional[DefaultDict[CodeLocation, Dict]] = None,
+        replacements: DefaultDict[CodeLocation, dict] | None = None,
         only_consts: bool = False,
-        expr_used_locs: Optional[DefaultDict[Any, Set[CodeLocation]]] = None,
-        equivalence: Optional[Set["Equivalence"]] = None,
+        expr_used_locs: DefaultDict[Any, set[CodeLocation]] | None = None,
+        equivalence: set["Equivalence"] | None = None,
         store_tops: bool = True,
-        gp: Optional[int] = None,
+        gp: int | None = None,
         max_prop_expr_occurrence: int = 1,
         model=None,
+        artificial_reg_offsets=None,
     ):
         self.arch = arch
         self.gpr_size = arch.bits // arch.byte_width  # size of the general-purpose registers
@@ -99,12 +101,13 @@ class PropagatorState:
         self._expr_used_locs = defaultdict(list) if expr_used_locs is None else expr_used_locs
         self._only_consts = only_consts
         self._replacements = defaultdict(dict) if replacements is None else replacements
-        self._equivalence: Set[Equivalence] = equivalence if equivalence is not None else set()
+        self._equivalence: set[Equivalence] = equivalence if equivalence is not None else set()
         self._store_tops = store_tops
         self._max_prop_expr_occurrence = max_prop_expr_occurrence
+        self._artificial_reg_offsets = artificial_reg_offsets if artificial_reg_offsets is not None else set()
 
         # architecture-specific information
-        self._gp: Optional[int] = gp  # Value of gp for MIPS32 and 64 binaries
+        self._gp: int | None = gp  # Value of gp for MIPS32 and 64 binaries
 
         self.project = project
         self.model = model
@@ -202,7 +205,7 @@ class PropagatorState:
         :return:            Whether merging has happened or not.
         """
 
-        def _get_repl_size(repl_value: Union[Dict, ailment.Expression, claripy.ast.Bits]) -> int:
+        def _get_repl_size(repl_value: dict | ailment.Expression | claripy.ast.Bits) -> int:
             if isinstance(repl_value, dict):
                 return _get_repl_size(repl_value["expr"])
             if isinstance(repl_value, ailment.Expression):
@@ -384,6 +387,7 @@ class PropagatorVEXState(PropagatorState):
         gp=None,
         max_prop_expr_occurrence: int = 1,
         model=None,
+        artificial_reg_offsets=None,
     ):
         super().__init__(
             arch,
@@ -396,6 +400,7 @@ class PropagatorVEXState(PropagatorState):
             gp=gp,
             max_prop_expr_occurrence=max_prop_expr_occurrence,
             model=model,
+            artificial_reg_offsets=artificial_reg_offsets,
         )
         self.do_binops = do_binops
         self._registers = (
@@ -487,11 +492,12 @@ class PropagatorVEXState(PropagatorState):
             gp=self._gp,
             max_prop_expr_occurrence=self._max_prop_expr_occurrence,
             model=self.model,
+            artificial_reg_offsets=self._artificial_reg_offsets,
         )
 
         return cp
 
-    def merge(self, *others: "PropagatorVEXState") -> Tuple["PropagatorVEXState", bool]:
+    def merge(self, *others: "PropagatorVEXState") -> tuple["PropagatorVEXState", bool]:
         state = self.copy()
         merge_occurred = state._registers.merge([o._registers for o in others], None)
         merge_occurred |= state._stack_variables.merge([o._stack_variables for o in others], None)
@@ -524,7 +530,7 @@ class PropagatorVEXState(PropagatorState):
         except SimMemoryMissingError:
             return self.top(size * self.arch.byte_width).annotate(RegisterAnnotation(offset, size))
 
-    def register_results(self) -> Dict[str, claripy.ast.BV]:
+    def register_results(self) -> dict[str, claripy.ast.BV]:
         result = {}
         for reg, (offset, size) in self.arch.registers.items():
             val = self.load_register(offset, size)
@@ -600,6 +606,7 @@ class PropagatorAILState(PropagatorState):
         max_prop_expr_occurrence: int = 1,
         sp_adjusted: bool = False,
         model=None,
+        artificial_reg_offsets=None,
     ):
         super().__init__(
             arch,
@@ -612,6 +619,7 @@ class PropagatorAILState(PropagatorState):
             gp=gp,
             max_prop_expr_occurrence=max_prop_expr_occurrence,
             model=model,
+            artificial_reg_offsets=artificial_reg_offsets,
         )
 
         self._stack_variables = (
@@ -628,7 +636,7 @@ class PropagatorAILState(PropagatorState):
         self.temp_expressions = {}
         self.register_expressions = {}
         self.block_initial_reg_values: DefaultDict[
-            Tuple[int, int], List[Tuple[ailment.Expr.Register, ailment.Expr.Const]]
+            tuple[int, int], list[tuple[ailment.Expr.Register, ailment.Expr.Const]]
         ] = (defaultdict(list) if block_initial_reg_values is None else block_initial_reg_values)
         self._sp_adjusted: bool = sp_adjusted
 
@@ -637,8 +645,8 @@ class PropagatorAILState(PropagatorState):
         # last_stack_store stores the most recent stack store statement with a non-concrete or unresolvable address. we
         # use this information to determine if stack reads after this store can be safely resolved to definitions prior
         # to the stack read.
-        self.last_stack_store: Optional[Tuple[int, int, ailment.Stmt.Store]] = None
-        self.global_stores: List[Tuple[int, int, Any, ailment.Stmt.Store]] = []
+        self.last_stack_store: tuple[int, int, ailment.Stmt.Store] | None = None
+        self.global_stores: list[tuple[int, int, Any, ailment.Stmt.Store]] = []
 
     def __repr__(self):
         return "<PropagatorAILState>"
@@ -711,6 +719,18 @@ class PropagatorAILState(PropagatorState):
                 PropValue(claripy.BVV(0, 32), offset_and_details={0: Detail(4, reg_value, initial_codeloc)}),
             )
 
+        elif project.arch.name.startswith("PowerPC:"):
+            # pcode PowerPC
+            state._artificial_reg_offsets = {project.arch.registers["tea"][0]}
+
+            # clear xer_so
+            reg_expr = ailment.Expr.Register(None, None, *project.arch.registers["xer_so"])
+            reg_value = ailment.Expr.Const(None, None, 0, 8)
+            state.store_register(
+                reg_expr,
+                PropValue(claripy.BVV(0, 8), offset_and_details={0: Detail(1, reg_value, initial_codeloc)}),
+            )
+
         if project is not None and project.simos is not None and project.simos.function_initial_registers:
             if func_addr is not None:
                 for reg_name, reg_value in project.simos.function_initial_registers.items():
@@ -744,12 +764,13 @@ class PropagatorAILState(PropagatorState):
             max_prop_expr_occurrence=self._max_prop_expr_occurrence,
             sp_adjusted=self._sp_adjusted,
             model=self.model,
+            artificial_reg_offsets=self._artificial_reg_offsets,
         )
 
         return rd
 
     @staticmethod
-    def is_const_or_register(value: Optional[Union[ailment.Expr.Expression, claripy.ast.Bits]]) -> bool:
+    def is_const_or_register(value: ailment.Expr.Expression | claripy.ast.Bits | None) -> bool:
         if value is None:
             return False
         if isinstance(value, claripy.ast.BV):
@@ -769,7 +790,7 @@ class PropagatorAILState(PropagatorState):
             return True
         return False
 
-    def merge(self, *others) -> Tuple["PropagatorAILState", bool]:
+    def merge(self, *others) -> tuple["PropagatorAILState", bool]:
         state, merge_occurred = super().merge(*others)
         state: "PropagatorAILState"
 
@@ -781,7 +802,7 @@ class PropagatorAILState(PropagatorState):
     def store_temp(self, tmp_idx: int, value: PropValue):
         self._tmps[tmp_idx] = value
 
-    def load_tmp(self, tmp_idx: int) -> Optional[PropValue]:
+    def load_tmp(self, tmp_idx: int) -> PropValue | None:
         return self._tmps.get(tmp_idx, None)
 
     def store_register(self, reg: ailment.Expr.Register, value: PropValue) -> None:
@@ -807,7 +828,7 @@ class PropagatorAILState(PropagatorState):
         for offset, value, size, label in new.value_and_labels():
             self._stack_variables.store(sp_offset + offset, value, size=size, endness=endness, label=label)
 
-    def load_register(self, reg: ailment.Expr.Register) -> Optional[PropValue]:
+    def load_register(self, reg: ailment.Expr.Register) -> PropValue | None:
         try:
             value, labels = self._registers.load_with_labels(
                 reg.reg_offset, size=reg.size, endness=self.project.arch.register_endness
@@ -819,7 +840,7 @@ class PropagatorAILState(PropagatorState):
         prop_value = PropValue.from_value_and_labels(value, labels)
         return prop_value
 
-    def load_stack_variable(self, sp_offset: int, size, endness=None) -> Optional[PropValue]:
+    def load_stack_variable(self, sp_offset: int, size, endness=None) -> PropValue | None:
         # normalize sp_offset to handle negative offsets
         sp_offset += 0x65536
         sp_offset &= (1 << self.arch.bits) - 1
@@ -847,13 +868,22 @@ class PropagatorAILState(PropagatorState):
         prop_value = PropValue.from_value_and_labels(value, labels)
         return prop_value
 
+    def should_replace_reg(self, old_reg_offset: int, bp_as_gpr: bool, new_value) -> bool:
+        if old_reg_offset == self.arch.sp_offset or (not bp_as_gpr and old_reg_offset == self.arch.bp_offset):
+            return True
+        if old_reg_offset in self._artificial_reg_offsets:
+            return True
+        if isinstance(new_value, ailment.Expr.StackBaseOffset):
+            return True
+        return False
+
     def add_replacement(
         self,
         codeloc: CodeLocation,
         old,
         new,
         force_replace: bool = False,
-        stmt_to_remove: Optional[CodeLocation] = None,
+        stmt_to_remove: CodeLocation | None = None,
         bp_as_gpr: bool = False,
     ) -> bool:
         if self._only_consts:
@@ -889,7 +919,7 @@ class PropagatorAILState(PropagatorState):
             if (
                 isinstance(old, ailment.Expr.Tmp)
                 or isinstance(old, ailment.Expr.Register)
-                and (old.reg_offset == self.arch.sp_offset or (not bp_as_gpr and old.reg_offset == self.arch.bp_offset))
+                and self.should_replace_reg(old.reg_offset, bp_as_gpr, new)
             ):
                 self._replacements[codeloc][old] = (
                     new if stmt_to_remove is None else {"expr": new, "stmt_to_remove": stmt_to_remove}
@@ -955,7 +985,7 @@ class PropagatorAILState(PropagatorState):
 
         return replaced
 
-    def revert_past_replacements(self, replaced_by, to_replace=None, to_replace_def=None) -> Set[CodeLocation]:
+    def revert_past_replacements(self, replaced_by, to_replace=None, to_replace_def=None) -> set[CodeLocation]:
         updated_codelocs = set()
         if self.model.replacements is not None:
             for codeloc_ in self._expr_used_locs[to_replace_def if to_replace_def is not None else to_replace]:

angr/knowledge_plugins/structured_code/manager.py

@@ -1,5 +1,5 @@
 # pylint:disable=import-outside-toplevel
-from typing import Dict, Any, Union, TYPE_CHECKING
+from typing import Any, Union, TYPE_CHECKING
 
 from .. import KnowledgeBasePlugin
 
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 class StructuredCodeManager(KnowledgeBasePlugin):
     def __init__(self, kb):
         super().__init__(kb=kb)
-        self.cached: Dict[Any, "DecompilationCache"] = {}
+        self.cached: dict[Any, "DecompilationCache"] = {}
 
     def _normalize_key(self, item):
         if type(item) is not tuple:

angr/knowledge_plugins/sync/sync_controller.py

@@ -1,6 +1,6 @@
 # pylint:disable=import-outside-toplevel
 from functools import wraps
-from typing import Optional, List
+from typing import Optional
 
 from ... import knowledge_plugins
 from ...knowledge_plugins.plugin import KnowledgeBasePlugin
@@ -172,7 +172,7 @@ class SyncController(KnowledgeBasePlugin):
     @init_checker
     @make_state
     # pylint:disable=unused-argument,no-self-use
-    def push_comments(self, comments: List["binsync.data.Comment"], user=None, state=None):
+    def push_comments(self, comments: list["binsync.data.Comment"], user=None, state=None):
         """
         Push a bunch of comments upwards.
 
@@ -189,7 +189,7 @@ class SyncController(KnowledgeBasePlugin):
     @make_state
     # pylint:disable=unused-argument,no-self-use
     def push_stack_variables(
-        self, stack_variables: List[SimStackVariable], var_manager: VariableManagerInternal, user=None, state=None
+        self, stack_variables: list[SimStackVariable], var_manager: VariableManagerInternal, user=None, state=None
     ):
         """
 

angr/knowledge_plugins/variables/variable_access.py

@@ -1,5 +1,5 @@
 # pylint:disable=arguments-differ,no-member
-from typing import Dict, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from ...code_location import CodeLocation
 from ...serializable import Serializable
@@ -36,8 +36,8 @@ class VariableAccess(Serializable):
         self.variable: "SimVariable" = variable
         self.access_type: int = access_type
         self.location: CodeLocation = location
-        self.offset: Optional[int] = offset
-        self.atom_hash: Optional[int] = atom_hash
+        self.offset: int | None = offset
+        self.atom_hash: int | None = atom_hash
 
     def __repr__(self):
         access_type = {
@@ -90,7 +90,7 @@ class VariableAccess(Serializable):
 
     @classmethod
     def parse_from_cmessage(
-        cls, cmsg, variable_by_ident: Optional[Dict[str, "SimVariable"]] = None, **kwargs
+        cls, cmsg, variable_by_ident: dict[str, "SimVariable"] | None = None, **kwargs
     ) -> "VariableAccess":
         assert variable_by_ident is not None