angr 9.2.159__tar.gz → 9.2.160__tar.gz

{angr-9.2.159 → angr-9.2.160}/Cargo.toml

@@ -1,7 +1,7 @@
 [workspace]
 resolver = "3"
 rust-version = "1.86.0"
-members = ["crates/angr"]
+members = ["native/angr"]
 
 [workspace.package]
 license = "BSD-2-Clause"

angr-9.2.160/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include Cargo.toml
+include Cargo.lock
+graft native

{angr-9.2.159 → angr-9.2.160}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.159
+Version: 9.2.160
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 License: BSD-2-Clause
 Project-URL: Homepage, https://angr.io/
 Project-URL: Repository, https://github.com/angr/angr
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
@@ -17,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.159
+Requires-Dist: archinfo==9.2.160
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.159
-Requires-Dist: cle==9.2.159
+Requires-Dist: claripy==9.2.160
+Requires-Dist: cle==9.2.160
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
 Requires-Dist: protobuf>=5.28.2
@@ -31,7 +30,7 @@ Requires-Dist: pycparser>=2.18
 Requires-Dist: pydemumble
 Requires-Dist: pyformlang
 Requires-Dist: pypcode<4.0,>=3.2.1
-Requires-Dist: pyvex==9.2.159
+Requires-Dist: pyvex==9.2.160
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.159 → angr-9.2.160}/angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.159"
+__version__ = "9.2.160"
 
 if bytes is str:
     raise Exception(

{angr-9.2.159 → angr-9.2.160}/angr/analyses/decompiler/clinic.py

@@ -143,7 +143,8 @@ class Clinic(Analysis):
         desired_variables: set[str] | None = None,
         force_loop_single_exit: bool = True,
         complete_successors: bool = False,
-        max_type_constraints: int = 4000,
+        max_type_constraints: int = 100_000,
+        type_constraint_set_degradation_threshold: int = 150,
         ail_graph: networkx.DiGraph | None = None,
         arg_vvars: dict[int, tuple[ailment.Expr.VirtualVariable, SimVariable]] | None = None,
         start_stage: ClinicStage | None = ClinicStage.INITIALIZATION,
@@ -185,6 +186,7 @@ class Clinic(Analysis):
         self._cache = cache
         self._mode = mode
         self._max_type_constraints = max_type_constraints
+        self._type_constraint_set_degradation_threshold = type_constraint_set_degradation_threshold
         self.vvar_id_start = vvar_id_start
         self.vvar_to_vvar: dict[int, int] | None = None
         # during SSA conversion, we create secondary stack variables because they overlap and are larger than the
@@ -1871,6 +1873,7 @@ class Clinic(Analysis):
                     must_struct=must_struct,
                     ground_truth=groundtruth,
                     stackvar_max_sizes=tv_max_sizes,
+                    constraint_set_degradation_threshold=self._type_constraint_set_degradation_threshold,
                 )
                 # tp.pp_constraints()
                 # tp.pp_solution()

{angr-9.2.159 → angr-9.2.160}/angr/analyses/decompiler/decompiler.py

@@ -23,7 +23,7 @@ from .ailgraph_walker import AILGraphWalker
 from .condition_processor import ConditionProcessor
 from .decompilation_options import DecompilationOption
 from .decompilation_cache import DecompilationCache
-from .utils import remove_labels, remove_edges_in_ailgraph
+from .utils import remove_edges_in_ailgraph
 from .sequence_walker import SequenceWalker
 from .structuring.structurer_nodes import SequenceNode
 from .presets import DECOMPILATION_PRESETS, DecompilationPreset
@@ -319,12 +319,8 @@ class Decompiler(Analysis):
         # removed!
         remove_edges_in_ailgraph(clinic.graph, clinic.edges_to_remove)
 
-        # Rewrite the graph to remove phi expressions
-        # this is probably optional if we do not pretty-print clinic.graph
-        clinic.graph = self._transform_graph_from_ssa(clinic.graph)
-
         # save the graph before structuring happens (for AIL view)
-        clinic.cc_graph = remove_labels(clinic.copy_graph())
+        clinic.cc_graph = clinic.copy_graph()
 
         codegen = None
         seq_node = None
@@ -357,7 +353,7 @@ class Decompiler(Analysis):
             )
 
             # rewrite the sequence node to remove phi expressions
-            seq_node = self._transform_seqnode_from_ssa(seq_node)
+            seq_node = self.transform_seqnode_from_ssa(seq_node)
 
             # update memory data
             if self._cfg is not None and self._update_memory_data:
@@ -670,14 +666,21 @@ class Decompiler(Analysis):
             memory_data_addrs=added_memory_data_addrs,
         )
 
-    def _transform_graph_from_ssa(self, ail_graph: networkx.DiGraph) -> networkx.DiGraph:
+    def transform_graph_from_ssa(self, ail_graph: networkx.DiGraph) -> networkx.DiGraph:
+        """
+        Translate an SSA AIL graph out of SSA form. This is useful for producing a non-SSA AIL graph for displaying in
+        angr management.
+
+        :param ail_graph:   The AIL graph to transform out of SSA form.
+        :return:            The translated AIL graph.
+        """
         variable_kb = self._variable_kb
         dephication = self.project.analyses.GraphDephication(
             self.func, ail_graph, rewrite=True, variable_kb=variable_kb, kb=self.kb, fail_fast=self._fail_fast
         )
         return dephication.output
 
-    def _transform_seqnode_from_ssa(self, seq_node: SequenceNode) -> SequenceNode:
+    def transform_seqnode_from_ssa(self, seq_node: SequenceNode) -> SequenceNode:
         variable_kb = self._variable_kb
         dephication = self.project.analyses.SeqNodeDephication(
             self.func, seq_node, rewrite=True, variable_kb=variable_kb, kb=self.kb, fail_fast=self._fail_fast

{angr-9.2.159 → angr-9.2.160}/angr/analyses/typehoon/simple_solver.py

@@ -1,4 +1,4 @@
-# pylint:disable=missing-class-docstring
+# pylint:disable=missing-class-docstring,too-many-boolean-expressions
 from __future__ import annotations
 import enum
 from collections import defaultdict
@@ -432,7 +432,14 @@ class SimpleSolver:
     improvements.
     """
 
-    def __init__(self, bits: int, constraints, typevars, stackvar_max_sizes: dict[TypeVariable, int] | None = None):
+    def __init__(
+        self,
+        bits: int,
+        constraints,
+        typevars,
+        constraint_set_degradation_threshold: int = 150,
+        stackvar_max_sizes: dict[TypeVariable, int] | None = None,
+    ):
         if bits not in (32, 64):
             raise ValueError(f"Pointer size {bits} is not supported. Expect 32 or 64.")
 
@@ -440,6 +447,7 @@ class SimpleSolver:
         self._constraints: dict[TypeVariable, set[TypeConstraint]] = constraints
         self._typevars: set[TypeVariable] = typevars
         self.stackvar_max_sizes = stackvar_max_sizes if stackvar_max_sizes is not None else {}
+        self._constraint_set_degradation_threshold = constraint_set_degradation_threshold
         self._base_lattice = BASE_LATTICES[bits]
         self._base_lattice_inverted = networkx.DiGraph()
         for src, dst in self._base_lattice.edges:
@@ -459,7 +467,11 @@ class SimpleSolver:
                 self.processed_constraints_count += len(self._constraints[typevar])
 
                 self._constraints[typevar] |= self._eq_constraints_from_add(typevar)
-                self._constraints[typevar] = self._handle_equivalence(typevar)
+                self._constraints[typevar] |= self._discover_equivalence(self._constraints[typevar])
+                new_constraints, replacements = self._handle_equivalence(self._constraints[typevar])
+                self._equivalence |= replacements
+                self._constraints[typevar] = new_constraints
+                self._constraints[typevar] = self._filter_constraints(self._constraints[typevar])
 
                 self.simplified_constraints_count += len(self._constraints[typevar])
 
@@ -517,11 +529,18 @@ class SimpleSolver:
 
         _, sketches = self.infer_shapes(typevars, constraints)
         constraintset2tvs = defaultdict(set)
+        tvs_seen = set()
         for idx, tv in enumerate(constrained_typevars):
             _l.debug("Collecting constraints for type variable %r (%d/%d)", tv, idx + 1, len(constrained_typevars))
+            if tv in tvs_seen:
+                continue
             # build a sub constraint set for the type variable
-            constraint_subset = frozenset(self._generate_constraint_subset(constraints, {tv}))
-            constraintset2tvs[constraint_subset].add(tv)
+            constraint_subset, related_tvs = self._generate_constraint_subset(constraints, {tv})
+            # drop all type vars outside constrained_typevars
+            related_tvs = related_tvs.intersection(constrained_typevars)
+            tvs_seen |= related_tvs
+            frozen_constraint_subset = frozenset(constraint_subset)
+            constraintset2tvs[frozen_constraint_subset] = related_tvs
 
         for idx, (constraint_subset, tvs) in enumerate(constraintset2tvs.items()):
             _l.debug(
@@ -534,8 +553,31 @@ class SimpleSolver:
             )
             self.eqclass_constraints_count.append(len(constraint_subset))
 
-            while True:
-                base_constraint_graph = self._generate_constraint_graph(constraint_subset, tvs | PRIMITIVE_TYPES)
+            if len(constraint_subset) > self._constraint_set_degradation_threshold:
+                _l.debug(
+                    "Constraint subset contains %d constraints, which is over the limit of %d. Enter degradation.",
+                    len(constraint_subset),
+                    self._constraint_set_degradation_threshold,
+                )
+                constraint_subset = self._degrade_constraint_set(constraint_subset)
+                _l.debug("Degraded constraint subset to %d constraints.", len(constraint_subset))
+
+            while constraint_subset:
+
+                _l.debug("Working with %d constraints.", len(constraint_subset))
+
+                # remove constraints that are a <: b where a only appears once; in this case, the solution fo a is
+                # entirely determined by the solution of b (which is the upper bound of a)
+                filtered_constraint_subset, ub_subtypes = self._filter_leaf_typevars(constraint_subset, tvs)
+                _l.debug(
+                    "Filtered %d leaf typevars; %d constraints remain.",
+                    len(ub_subtypes),
+                    len(filtered_constraint_subset),
+                )
+
+                base_constraint_graph = self._generate_constraint_graph(
+                    filtered_constraint_subset, tvs | PRIMITIVE_TYPES
+                )
                 primitive_constraints = self._generate_primitive_constraints(tvs, base_constraint_graph)
                 tvs_with_primitive_constraints = set()
                 for primitive_constraint in primitive_constraints:
@@ -546,12 +588,22 @@ class SimpleSolver:
                 solutions = {}
                 self.determine(sketches, tvs_with_primitive_constraints, solutions)
                 _l.debug("Determined solutions for %d type variable(s).", len(tvs_with_primitive_constraints))
+
+                leaf_solutions = 0
+                for tv_, ub_tv in ub_subtypes.items():
+                    if ub_tv in solutions:
+                        solutions[tv_] = solutions[ub_tv]
+                        leaf_solutions += 1
+                    elif isinstance(ub_tv, TypeConstant):
+                        solutions[tv_] = ub_tv
+                        leaf_solutions += 1
+                _l.debug("Determined solutions for %d leaf type variable(s).", leaf_solutions)
+
                 if not solutions:
                     break
-
                 self.solution |= solutions
 
-                tvs = {tv for tv in tvs if tv not in tvs_with_primitive_constraints}
+                tvs = {tv for tv in tvs if tv not in solutions}
                 if not tvs:
                     break
                 # rewrite existing constraints
@@ -559,7 +611,7 @@ class SimpleSolver:
                 for constraint in constraint_subset:
                     rewritten = self._rewrite_constraint(constraint, solutions)
                     new_constraint_subset.add(rewritten)
-                constraint_subset = new_constraint_subset
+                constraint_subset = self._filter_constraints(new_constraint_subset)
 
         # set the solution for missing type vars to TOP
         self.determine(sketches, set(sketches).difference(set(self.solution)), self.solution)
@@ -775,14 +827,45 @@ class SimpleSolver:
                     new_constraints.add(Equivalence(constraint.type_1, constraint.type_r))
         return new_constraints
 
-    def _handle_equivalence(self, typevar: TypeVariable):
+    @staticmethod
+    def _discover_equivalence(constraints: set[TypeConstraint]) -> set[Equivalence]:
+        """
+        a <:b && b <: a  ==>  a == b
+        """
+
+        new_eq_constraints: set[Equivalence] = set()
+        subtypes = defaultdict(set)
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                sub_type = constraint.sub_type
+                super_type = constraint.super_type
+                subtypes[sub_type].add(super_type)
+
+        # check everything
+        seen = set()
+        for tv, tv_supers in subtypes.items():
+            for tv_super in tv_supers:
+                if tv_super in subtypes and tv in subtypes[tv_super]:  # noqa: SIM102
+                    # we have a pair of subtypes that are equivalent
+                    if (tv, tv_super) not in seen and (tv_super, tv) not in seen:
+                        new_eq_constraints.add(Equivalence(tv, tv_super))
+                        seen.add((tv, tv_super))
+
+        _l.debug(
+            "Discovered %d equivalence constraints from %d constraints.", len(new_eq_constraints), len(constraints)
+        )
+        return new_eq_constraints
+
+    @staticmethod
+    def _handle_equivalence(
+        constraint_set: set[TypeConstraint],
+    ) -> tuple[set[TypeConstraint], dict[TypeVariable, TypeVariable | TypeConstant]]:
         graph = networkx.Graph()
 
-        replacements = {}
-        constraints = set()
+        replacements: dict[TypeVariable, TypeVariable | TypeConstant] = {}
 
         # collect equivalence relations
-        for constraint in self._constraints[typevar]:
+        for constraint in constraint_set:
             if isinstance(constraint, Equivalence):
                 # | type_a == type_b
                 # we apply unification and removes one of them
@@ -803,15 +886,30 @@ class SimpleSolver:
             for tv in components_lst[1:]:
                 replacements[tv] = representative
 
-        # replace
-        for constraint in self._constraints[typevar]:
+        constraints = SimpleSolver._rewrite_constraints_with_replacements(constraint_set, replacements)
+
+        # import pprint
+        # print("Replacements")
+        # pprint.pprint(replacements)
+        # print("Constraints (after replacement)")
+        # pprint.pprint(constraints)
+
+        return constraints, replacements
+
+    @staticmethod
+    def _rewrite_constraints_with_replacements(
+        constraints: set[TypeConstraint], replacements: dict[TypeVariable, TypeVariable]
+    ) -> set[TypeConstraint]:
+        # replace constraints according to a dictionary of type variable replacements
+        replaced_constraints = set()
+        for constraint in constraints:
             if isinstance(constraint, Existence):
                 replaced, new_constraint = constraint.replace(replacements)
 
                 if replaced:
-                    constraints.add(new_constraint)
+                    replaced_constraints.add(new_constraint)
                 else:
-                    constraints.add(constraint)
+                    replaced_constraints.add(constraint)
 
             elif isinstance(constraint, Subtype):
                 # subtype <: supertype
@@ -819,18 +917,122 @@ class SimpleSolver:
                 replaced, new_constraint = constraint.replace(replacements)
 
                 if replaced:
-                    constraints.add(new_constraint)
+                    replaced_constraints.add(new_constraint)
                 else:
-                    constraints.add(constraint)
+                    replaced_constraints.add(constraint)
+        return replaced_constraints
 
-        # import pprint
-        # print("Replacements")
-        # pprint.pprint(replacements)
-        # print("Constraints (after replacement)")
-        # pprint.pprint(constraints)
+    @staticmethod
+    def _filter_constraints(constraints: set[TypeConstraint]) -> set[TypeConstraint]:
+        """
+        Filter out constraints that we don't yet support.
+        """
+
+        filtered_constraints = set()
+        for constraint in constraints:
+            dropped = False
+            if isinstance(constraint, Subtype) and (
+                (isinstance(constraint.sub_type, TypeConstant) and isinstance(constraint.super_type, TypeConstant))
+                or (
+                    isinstance(constraint.sub_type, DerivedTypeVariable)
+                    and isinstance(constraint.sub_type.labels[-1], ConvertTo)
+                )
+                or (
+                    isinstance(constraint.sub_type, TypeVariable)
+                    and isinstance(constraint.super_type, TypeVariable)
+                    and constraint.sub_type == constraint.super_type
+                )
+            ):
+                dropped = True
 
-        self._equivalence = replacements
-        return constraints
+            if not dropped:
+                filtered_constraints.add(constraint)
+
+        return filtered_constraints
+
+    @staticmethod
+    def _filter_leaf_typevars(
+        constraints: set[TypeConstraint], tvs_to_solve: set[TypeVariable]
+    ) -> tuple[set[TypeConstraint], dict[TypeVariable, TypeVariable]]:
+        """
+        Filter out leaf type variables that only appear once in the constraints. These type variables are not
+        interesting and can be removed from the constraints.
+        """
+
+        sub_typevars = defaultdict(set)
+        tv_to_dtvs: dict[TypeVariable, set[TypeVariable | DerivedTypeVariable]] = defaultdict(set)
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                if isinstance(constraint.sub_type, TypeVariable):
+                    sub_typevars[constraint.sub_type].add(constraint.super_type)
+                for tv in [constraint.sub_type, constraint.super_type]:
+                    if isinstance(tv, DerivedTypeVariable):
+                        tv_to_dtvs[tv.type_var].add(constraint.sub_type)
+                    elif isinstance(tv, TypeVariable):
+                        tv_to_dtvs[tv].add(constraint.sub_type)
+
+        ub_subtypes: dict[TypeVariable, TypeVariable] = {}
+        for tv, dtvs in tv_to_dtvs.items():
+            if len(dtvs) == 1 and tv in sub_typevars and len(sub_typevars[tv]) == 1:
+                ub = next(iter(sub_typevars[tv]))
+                if ub in tvs_to_solve:
+                    ub_subtypes[tv] = ub
+
+        filtered_constraints = set()
+        for constraint in constraints:
+            if isinstance(constraint, Subtype) and constraint.sub_type in ub_subtypes:
+                continue
+            filtered_constraints.add(constraint)
+
+        return filtered_constraints, ub_subtypes
+
+    def _degrade_constraint_set(self, constraints: set[TypeConstraint]) -> set[TypeConstraint]:
+        """
+        Degrade the constraint set to a smaller set of constraints to speed up the DFA generation process.
+        """
+
+        tv_with_ls = defaultdict(set)  # tv_with_ls are type variables with Loads or Stores
+        graph = networkx.Graph()
+
+        for constraint in constraints:
+            if isinstance(constraint, Subtype):
+                if isinstance(constraint.sub_type, DerivedTypeVariable) and isinstance(
+                    constraint.sub_type.labels[0], (Load, Store)
+                ):
+                    tv_with_ls[constraint.sub_type.type_var].add(constraint.sub_type)
+                if type(constraint.sub_type) is TypeVariable and type(constraint.super_type) is TypeVariable:
+                    graph.add_edge(constraint.sub_type, constraint.super_type)
+
+        tv_to_degrade = set()
+        for tv, dtvs in tv_with_ls.items():
+            if len(dtvs) > 5:
+                # degrade all subtype relationships involving this type variable to equivalence
+                tv_to_degrade.add(tv)
+
+        replacements = {}
+        for components in networkx.connected_components(graph):
+            if len(components) == 1:
+                continue
+            if any(tv in tv_to_degrade for tv in components):
+                components_lst = sorted(components, key=str)
+                representative = components_lst[0]
+                for tv in components_lst[1:]:
+                    replacements[tv] = representative
+
+        degraded_constraints = self._rewrite_constraints_with_replacements(constraints, replacements)
+
+        # discover more equivalence relations
+        eq_constraints = self._discover_equivalence(degraded_constraints)
+        _l.debug("Discovered %d equivalence constraints from degraded constraints.", len(eq_constraints))
+        if eq_constraints:
+            degraded_constraints, eq_replacements = self._handle_equivalence(degraded_constraints | eq_constraints)
+            self._equivalence |= eq_replacements
+
+        # filter them
+        degraded_constraints = self._filter_constraints(degraded_constraints)
+
+        self._equivalence |= replacements
+        return degraded_constraints
 
     def _convert_arrays(self, constraints):
         for constraint in constraints:
@@ -860,7 +1062,7 @@ class SimpleSolver:
     @staticmethod
     def _generate_constraint_subset(
         constraints: set[TypeConstraint], typevars: set[TypeVariable]
-    ) -> set[TypeConstraint]:
+    ) -> tuple[set[TypeConstraint], set[TypeVariable]]:
         subset = set()
         related_typevars = set(typevars)
         while True:
@@ -890,7 +1092,7 @@ class SimpleSolver:
             if not new:
                 break
             subset |= new
-        return subset
+        return subset, related_typevars
 
     def _generate_constraint_graph(
         self, constraints: set[TypeConstraint], interesting_variables: set[DerivedTypeVariable]

{angr-9.2.159 → angr-9.2.160}/angr/analyses/typehoon/typehoon.py

@@ -40,6 +40,7 @@ class Typehoon(Analysis):
         must_struct: set[TypeVariable] | None = None,
         stackvar_max_sizes: dict[TypeVariable, int] | None = None,
         stack_offset_tvs: dict[int, TypeVariable] | None = None,
+        constraint_set_degradation_threshold: int = 150,
     ):
         """
 
@@ -57,6 +58,7 @@ class Typehoon(Analysis):
         self._must_struct = must_struct
         self._stackvar_max_sizes = stackvar_max_sizes if stackvar_max_sizes is not None else {}
         self._stack_offset_tvs = stack_offset_tvs if stack_offset_tvs is not None else {}
+        self._constraint_set_degradation_threshold = constraint_set_degradation_threshold
 
         self.bits = self.project.arch.bits
         self.solution = None
@@ -193,7 +195,7 @@ class Typehoon(Analysis):
             self.simtypes_solution.update(self._ground_truth)
 
     @staticmethod
-    def _resolve_derived(tv):
+    def _resolve_derived(tv: TypeVariable | DerivedTypeVariable) -> TypeVariable:
         return tv.type_var if isinstance(tv, DerivedTypeVariable) else tv
 
     def _solve(self):
@@ -211,7 +213,13 @@ class Typehoon(Analysis):
                     if isinstance(constraint.super_type, TypeVariable):
                         typevars.add(self._resolve_derived(constraint.super_type))
 
-        solver = SimpleSolver(self.bits, self._constraints, typevars, stackvar_max_sizes=self._stackvar_max_sizes)
+        solver = SimpleSolver(
+            self.bits,
+            self._constraints,
+            typevars,
+            stackvar_max_sizes=self._stackvar_max_sizes,
+            constraint_set_degradation_threshold=self._constraint_set_degradation_threshold,
+        )
         self.solution = solver.solution
         self.processed_constraints_count = solver.processed_constraints_count
         self.eqclass_constraints_count = solver.eqclass_constraints_count

{angr-9.2.159 → angr-9.2.160}/angr/analyses/variable_recovery/engine_ail.py

@@ -633,10 +633,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
         return RichR(r0.data << shiftamount, typevar=typeconsts.int_type(result_size), type_constraints=None)
@@ -651,10 +648,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -672,10 +666,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -691,10 +682,7 @@ class SimEngineVRAIL(
         if not r1.data.concrete:
             # we don't support symbolic shiftamount
             r = self.state.top(result_size)
-            return RichR(
-                r,
-                typevar=r0.typevar,
-            )
+            return RichR(r)
 
         shiftamount = r1.data.concrete_value
 
@@ -761,22 +749,22 @@ class SimEngineVRAIL(
     def _handle_binop_Rol(self, expr):
         arg0, arg1 = expr.operands
 
-        r0 = self._expr_bv(arg0)
+        _ = self._expr_bv(arg0)
         _ = self._expr_bv(arg1)
         result_size = arg0.bits
 
         r = self.state.top(result_size)
-        return RichR(r, typevar=r0.typevar)
+        return RichR(r)
 
     def _handle_binop_Ror(self, expr):
         arg0, arg1 = expr.operands
 
-        r0 = self._expr_bv(arg0)
+        _ = self._expr_bv(arg0)
         _ = self._expr_bv(arg1)
         result_size = arg0.bits
 
         r = self.state.top(result_size)
-        return RichR(r, typevar=r0.typevar)
+        return RichR(r)
 
     def _handle_binop_Concat(self, expr):
         arg0, arg1 = expr.operands

{angr-9.2.159 → angr-9.2.160}/angr/state_plugins/unicorn_engine.py

@@ -394,14 +394,14 @@ class _VexArchInfo(ctypes.Structure):
 
 def _load_native():
     if sys.platform == "darwin":
-        libfile = "angr_native.dylib"
+        libfile = "unicornlib.dylib"
     elif sys.platform in {"win32", "cygwin"}:
-        libfile = "angr_native.dll"
+        libfile = "unicornlib.dll"
     else:
-        libfile = "angr_native.so"
+        libfile = "unicornlib.so"
 
     try:
-        angr_path = str(importlib.resources.files("angr") / "lib" / libfile)
+        angr_path = str(importlib.resources.files("angr") / libfile)
         h = ctypes.CDLL(angr_path)
 
         VexArch = ctypes.c_int