angr 9.2.62__py3-none-win_amd64.whl → 9.2.63__py3-none-win_amd64.whl

angr/__init__.py

@@ -1,7 +1,7 @@
 # pylint: disable=wildcard-import
 # pylint: disable=wrong-import-position
 
-__version__ = "9.2.62"
+__version__ = "9.2.63"
 
 if bytes is str:
     raise Exception(

angr/analyses/cfg/cfg_fast.py

@@ -2714,30 +2714,28 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             for segment in self.project.loader.main_object.segments:
                 if segment.vaddr + segment.memsize == data_addr:
                     # yeah!
-                    new_data = self.model.add_memory_data(data_addr, MemoryDataSort.SegmentBoundary, data_size=0)
-                    if new_data or self._cross_references:
-                        cr = XRef(
-                            ins_addr=insn_addr,
-                            block_addr=irsb_addr,
-                            stmt_idx=stmt_idx,
-                            memory_data=self.model.memory_data[data_addr],
-                            xref_type=XRefType.Offset,
-                        )
-                        self.kb.xrefs.add_xref(cr)
+                    self.model.add_memory_data(data_addr, MemoryDataSort.SegmentBoundary, data_size=0)
+                    cr = XRef(
+                        ins_addr=insn_addr,
+                        block_addr=irsb_addr,
+                        stmt_idx=stmt_idx,
+                        memory_data=self.model.memory_data[data_addr],
+                        xref_type=XRefType.Offset,
+                    )
+                    self.kb.xrefs.add_xref(cr)
                     break
 
             return
 
-        new_data = self.model.add_memory_data(data_addr, data_type, data_size=data_size)
-        if new_data or self._cross_references:
-            cr = XRef(
-                ins_addr=insn_addr,
-                block_addr=irsb_addr,
-                stmt_idx=stmt_idx,
-                memory_data=self.model.memory_data[data_addr],
-                xref_type=XRefType.Offset,
-            )
-            self.kb.xrefs.add_xref(cr)
+        self.model.add_memory_data(data_addr, data_type, data_size=data_size)
+        cr = XRef(
+            ins_addr=insn_addr,
+            block_addr=irsb_addr,
+            stmt_idx=stmt_idx,
+            memory_data=self.model.memory_data[data_addr],
+            xref_type=XRefType.Offset,
+        )
+        self.kb.xrefs.add_xref(cr)
 
         if is_arm_arch(self.project.arch):
             if (irsb_addr & 1) == 1 and data_addr == (insn_addr & 0xFFFF_FFFF_FFFF_FFFE) + 4:

angr/analyses/decompiler/clinic.py

@@ -176,6 +176,7 @@ class Clinic(Analysis):
         self._convert_all()
 
         ail_graph = self._make_ailgraph()
+        self._rewrite_ite_expressions(ail_graph)
         self._remove_redundant_jump_blocks(ail_graph)
         if self._insert_labels:
             self._insert_block_labels(ail_graph)
@@ -1000,6 +1001,7 @@ class Clinic(Analysis):
             kb=tmp_kb,
             track_sp=False,
             func_args=arg_list,
+            unify_variables=False,
         )
         # get ground-truth types
         var_manager = tmp_kb.variables[self.function.addr]
@@ -1284,6 +1286,148 @@ class Clinic(Analysis):
 
         return graph
 
+    def _rewrite_ite_expressions(self, ail_graph):
+        for block in list(ail_graph):
+            ite_ins_addrs = []
+            for stmt in block.statements:
+                if isinstance(stmt, ailment.Stmt.Assignment) and isinstance(stmt.src, ailment.Expr.ITE):
+                    if stmt.ins_addr not in ite_ins_addrs:
+                        ite_ins_addrs.append(stmt.ins_addr)
+
+            if ite_ins_addrs:
+                block_addr = block.addr
+                for ite_ins_addr in ite_ins_addrs:
+                    block_addr = self._create_triangle_for_ite_expression(ail_graph, block_addr, ite_ins_addr)
+                    if block_addr is None or block_addr >= block.addr + block.original_size:
+                        break
+
+    def _create_triangle_for_ite_expression(self, ail_graph, block_addr: int, ite_ins_addr: int):
+        # lift the ite instruction to get its size
+        ite_insn_size = self.project.factory.block(ite_ins_addr, num_inst=1).size
+        if ite_insn_size <= 1:  # we need an address for true_block and another address for false_block
+            return None
+
+        # relift the head and the ITE instruction
+        new_head = self.project.factory.block(
+            block_addr, size=ite_ins_addr - block_addr + ite_insn_size, cross_insn_opt=False
+        )
+        new_head_ail = ailment.IRSBConverter.convert(new_head.vex, self._ail_manager)
+        # remove all statements between the ITE expression and the very end of the block
+        ite_expr_stmt_idx = None
+        ite_expr_stmt = None
+        for idx, stmt in enumerate(new_head_ail.statements):
+            if isinstance(stmt, ailment.Stmt.Assignment) and isinstance(stmt.src, ailment.Expr.ITE):
+                ite_expr_stmt_idx = idx
+                ite_expr_stmt = stmt
+                break
+        if ite_expr_stmt_idx is None:
+            return None
+
+        ite_expr: ailment.Expr.ITE = ite_expr_stmt.src
+        new_head_ail.statements = new_head_ail.statements[:ite_expr_stmt_idx]
+        # build the conditional jump
+        true_block_addr = ite_ins_addr
+        false_block_addr = ite_ins_addr + 1
+        cond_jump_stmt = ailment.Stmt.ConditionalJump(
+            ite_expr_stmt.idx,
+            ite_expr.cond,
+            ailment.Expr.Const(None, None, true_block_addr, self.project.arch.bits),
+            ailment.Expr.Const(None, None, false_block_addr, self.project.arch.bits),
+            **ite_expr_stmt.tags,
+        )
+        new_head_ail.statements.append(cond_jump_stmt)
+
+        # build the true block
+        true_block = self.project.factory.block(ite_ins_addr, num_inst=1)
+        true_block_ail = ailment.IRSBConverter.convert(true_block.vex, self._ail_manager)
+        true_block_ail.addr = true_block_addr
+
+        ite_expr_stmt_idx = None
+        ite_expr_stmt = None
+        for idx, stmt in enumerate(true_block_ail.statements):
+            if isinstance(stmt, ailment.Stmt.Assignment) and isinstance(stmt.src, ailment.Expr.ITE):
+                ite_expr_stmt_idx = idx
+                ite_expr_stmt = stmt
+                break
+        if ite_expr_stmt_idx is None:
+            return None
+
+        true_block_ail.statements[ite_expr_stmt_idx] = ailment.Stmt.Assignment(
+            ite_expr_stmt.idx, ite_expr_stmt.dst, ite_expr_stmt.src.iftrue, **ite_expr_stmt.tags
+        )
+
+        # build the false block
+        false_block = self.project.factory.block(ite_ins_addr, num_inst=1)
+        false_block_ail = ailment.IRSBConverter.convert(false_block.vex, self._ail_manager)
+        false_block_ail.addr = false_block_addr
+
+        ite_expr_stmt_idx = None
+        ite_expr_stmt = None
+        for idx, stmt in enumerate(false_block_ail.statements):
+            if isinstance(stmt, ailment.Stmt.Assignment) and isinstance(stmt.src, ailment.Expr.ITE):
+                ite_expr_stmt_idx = idx
+                ite_expr_stmt = stmt
+                break
+        if ite_expr_stmt_idx is None:
+            return None
+
+        false_block_ail.statements[ite_expr_stmt_idx] = ailment.Stmt.Assignment(
+            ite_expr_stmt.idx, ite_expr_stmt.dst, ite_expr_stmt.src.iffalse, **ite_expr_stmt.tags
+        )
+
+        original_block = next(iter(b for b in ail_graph if b.addr == block_addr))
+
+        original_block_in_edges = list(ail_graph.in_edges(original_block))
+        original_block_out_edges = list(ail_graph.out_edges(original_block))
+
+        # build the target block if the target block does not exist in the current function
+        end_block_addr = ite_ins_addr + ite_insn_size
+        if block_addr < end_block_addr < block_addr + original_block.original_size:
+            end_block = self.project.factory.block(
+                ite_ins_addr + ite_insn_size,
+                size=block_addr + original_block.original_size - (ite_ins_addr + ite_insn_size),
+                cross_insn_opt=False,
+            )
+            end_block_ail = ailment.IRSBConverter.convert(end_block.vex, self._ail_manager)
+        else:
+            end_block_ail = next(iter(b for b in ail_graph if b.addr == end_block_addr))
+
+        # last check: if the first instruction of the end block has Sar, then we bail (due to the peephole optimization
+        # SarToSignedDiv)
+        for stmt in end_block_ail.statements:
+            if stmt.ins_addr > end_block_ail.addr:
+                break
+            if (
+                isinstance(stmt, ailment.Stmt.Assignment)
+                and isinstance(stmt.src, ailment.Expr.BinaryOp)
+                and stmt.src.op == "Sar"
+            ):
+                return None
+
+        ail_graph.remove_node(original_block)
+
+        if end_block_ail not in ail_graph:
+            # newly created. add it and the necessary edges into the graph
+            for _, dst in original_block_out_edges:
+                if dst is original_block:
+                    ail_graph.add_edge(end_block_ail, new_head_ail)
+                else:
+                    ail_graph.add_edge(end_block_ail, dst)
+
+        # in edges
+        for src, _ in original_block_in_edges:
+            if src is original_block:
+                raise ValueError("Unexpected...")
+            ail_graph.add_edge(src, new_head_ail)
+
+        # triangle
+        ail_graph.add_edge(new_head_ail, true_block_ail)
+        ail_graph.add_edge(new_head_ail, false_block_ail)
+        ail_graph.add_edge(true_block_ail, end_block_ail)
+        ail_graph.add_edge(false_block_ail, end_block_ail)
+
+        return end_block_ail.addr
+
     @staticmethod
     def _remove_redundant_jump_blocks(ail_graph):
         def first_conditional_jump(block: ailment.Block) -> Optional[ailment.Stmt.ConditionalJump]:

angr/analyses/decompiler/condition_processor.py

@@ -93,7 +93,8 @@ _ail2claripy_op_mapping = {
     "Div": lambda expr, conv, _: conv(expr.operands[0], nobool=True) / conv(expr.operands[1], nobool=True),
     "Mod": lambda expr, conv, _: conv(expr.operands[0], nobool=True) % conv(expr.operands[1], nobool=True),
     "Not": lambda expr, conv, _: claripy.Not(conv(expr.operand)),
-    "Neg": lambda expr, conv, _: ~conv(expr.operand),
+    "Neg": lambda expr, conv, _: -conv(expr.operand),
+    "BitwiseNeg": lambda expr, conv, _: ~conv(expr.operand),
     "Xor": lambda expr, conv, _: conv(expr.operands[0], nobool=True) ^ conv(expr.operands[1], nobool=True),
     "And": lambda expr, conv, _: conv(expr.operands[0], nobool=True) & conv(expr.operands[1], nobool=True),
     "Or": lambda expr, conv, _: conv(expr.operands[0], nobool=True) | conv(expr.operands[1], nobool=True),
@@ -642,7 +643,8 @@ class ConditionProcessor:
 
         _mapping = {
             "Not": lambda cond_, tags: _unary_op_reduce("Not", cond_.args[0], tags),
-            "__invert__": lambda cond_, tags: _unary_op_reduce("Neg", cond_.args[0], tags),
+            "__neg__": lambda cond_, tags: _unary_op_reduce("Not", cond_.args[0], tags),
+            "__invert__": lambda cond_, tags: _unary_op_reduce("BitwiseNeg", cond_.args[0], tags),
             "And": lambda cond_, tags: _binary_op_reduce("LogicalAnd", cond_.args, tags),
             "Or": lambda cond_, tags: _binary_op_reduce("LogicalOr", cond_.args, tags),
             "__le__": lambda cond_, tags: _binary_op_reduce("CmpLE", cond_.args, tags, signed=True),

angr/analyses/decompiler/peephole_optimizations/eager_eval.py

@@ -88,6 +88,8 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
                         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)
 
         elif expr.op == "And":
             if isinstance(expr.operands[0], Const) and isinstance(expr.operands[1], Const):

angr/analyses/decompiler/structured_codegen/c.py

@@ -1576,6 +1576,7 @@ class CUnaryOp(CExpression):
         OP_MAP = {
             "Not": self._c_repr_chunks_not,
             "Neg": self._c_repr_chunks_neg,
+            "BitwiseNeg": self._c_repr_chunks_bitwiseneg,
             "Reference": self._c_repr_chunks_reference,
             "Dereference": self._c_repr_chunks_dereference,
         }
@@ -1597,13 +1598,20 @@ class CUnaryOp(CExpression):
         yield from CExpression._try_c_repr_chunks(self.operand)
         yield ")", paren
 
-    def _c_repr_chunks_neg(self):
+    def _c_repr_chunks_bitwiseneg(self):
         paren = CClosingObject("(")
         yield "~", self
         yield "(", paren
         yield from CExpression._try_c_repr_chunks(self.operand)
         yield ")", paren
 
+    def _c_repr_chunks_neg(self):
+        paren = CClosingObject("(")
+        yield "-", self
+        yield "(", paren
+        yield from CExpression._try_c_repr_chunks(self.operand)
+        yield ")", paren
+
     def _c_repr_chunks_reference(self):
         yield "&", self
         yield from CExpression._try_c_repr_chunks(self.operand)

angr/analyses/disassembly.py

@@ -214,10 +214,6 @@ class Instruction(DisassemblyPiece):
         assert hasattr(self.insn, "operands")
 
         op_str = self.insn.op_str
-        # NOTE: the size of dummy_operands is not necessarily equal to
-        # operands count of capstone disasm result. If we check
-        # len(self.operands) == len(self.insn.operands)
-        # special cases in arm disassembly will mess up the code
         dummy_operands = self.split_arm_op_string(op_str)
 
         for operand in dummy_operands:
@@ -278,16 +274,16 @@ class Instruction(DisassemblyPiece):
 
     @staticmethod
     def split_arm_op_string(op_str: str):
-        # Split arm operand string by comma outside brackets
+        # Split arm operand string with commas outside the square brackets
         pieces = []
-        outside_brackets = True
+        in_square_brackets = False
         cur_opr = ""
         for c in op_str:
-            if c == "[" or c == "{":
-                outside_brackets = False
-            if c == "]" or c == "}":
-                outside_brackets = True
-            if c == "," and outside_brackets:
+            if c == "[":
+                in_square_brackets = True
+            if c == "]":
+                in_square_brackets = False
+            if c == "," and not in_square_brackets:
                 pieces.append(cur_opr)
                 cur_opr = ""
                 continue

angr/analyses/reaching_definitions/engine_ail.py

@@ -256,6 +256,11 @@ class SimEngineRDAIL(
         ip = Register(self.arch.ip_offset, self.arch.bytes)
         self.state.kill_definitions(ip)
 
+        statement = self.block.statements[self.stmt_idx]
+        caller_will_handle_single_ret = True
+        if hasattr(statement, "dst") and statement.dst != stmt.ret_expr:
+            caller_will_handle_single_ret = False
+
         data = FunctionCallData(
             self.state.codeloc,
             self._function_handler.make_function_codeloc(
@@ -267,7 +272,7 @@ class SimEngineRDAIL(
             name=func_name,
             args_values=[self._expr(arg) for arg in stmt.args] if stmt.args is not None else None,
             redefine_locals=stmt.args is None and not is_expr,
-            caller_will_handle_single_ret=True,
+            caller_will_handle_single_ret=caller_will_handle_single_ret,
             ret_atoms={Atom.from_ail_expr(stmt.ret_expr, self.arch)} if stmt.ret_expr is not None else None,
         )
 

angr/analyses/reaching_definitions/engine_vex.py

@@ -213,7 +213,10 @@ class SimEngineRDVEX(
                     atom = MemoryLocation(a, size)
                     tags = None
                 elif self.state.is_stack_address(a):
-                    atom = MemoryLocation(SpOffset(self.arch.bits, self.state.get_stack_offset(a)), size)
+                    offset = self.state.get_stack_offset(a)
+                    if offset is None:
+                        continue
+                    atom = MemoryLocation(SpOffset(self.arch.bits, offset), size)
                     function_address = None  # we cannot get the function address in the middle of a store if a CFG
                     # does not exist. you should backpatch the function address later using
                     # the 'ins_addr' metadata entry.
@@ -269,6 +272,14 @@ class SimEngineRDVEX(
         _ = self._expr(stmt.guard)
         target = stmt.dst.value
         self.state.mark_guard(target)
+        if self.state.analysis is not None:
+            self.state.analysis.exit_observe(
+                self.block.addr,
+                self.stmt_idx,
+                self.block,
+                self.state,
+                node_idx=self.block.block_idx if hasattr(self.block, "block_idx") else None,
+            )
         if (
             self.block.instruction_addrs
             and self.ins_addr in self.block.instruction_addrs
@@ -671,12 +682,14 @@ class SimEngineRDVEX(
             # we do not support division between two real multivalues
             r = MultiValues(self.state.top(bits))
         elif expr0_v is None and expr1_v is not None:
-            if expr0.count() == 1 and 0 in expr0:
+            if expr1_v == 0:
+                r = MultiValues(self.state.top(bits))
+            elif expr0.count() == 1 and 0 in expr0:
                 vs = {v / expr1_v for v in expr0[0]}
                 r = MultiValues(offset_to_values={0: vs})
         elif expr0_v is not None and expr1_v is None:
             if expr1.count() == 1 and 0 in expr1:
-                vs = {v / expr0_v for v in expr1[0]}
+                vs = {expr0_v / v for v in expr1[0] if (not v.concrete) or v.concrete_value != 0}
                 r = MultiValues(offset_to_values={0: vs})
         else:
             if expr0_v.concrete and expr1_v.concrete:

angr/analyses/reaching_definitions/function_handler.py

@@ -52,7 +52,7 @@ class FunctionCallData:
 
     Function handler contract:
 
-    - If redefine_locals is unset, do not adjust any artifacts of the function call abstration, such as the stack
+    - If redefine_locals is unset, do not adjust any artifacts of the function call abstraction, such as the stack
       pointer, the caller saved registers, etc.
     - If caller_will_handle_single_ret is set, and there is a single entry in `ret_atoms`, do not apply to the state
       effects modifying this atom. Instead, set `ret_values` and `ret_values_deps` to the values and deps which are
@@ -137,7 +137,13 @@ class FunctionCallData:
             )
         else:
             self.effects.append(
-                FunctionEffect(dest, set(sources), value=value, apply_at_callsite=apply_at_callsite, tags=tags)
+                FunctionEffect(
+                    dest,
+                    set(sources),
+                    value=value,
+                    apply_at_callsite=apply_at_callsite,
+                    tags=tags,
+                )
             )
 
 
@@ -333,7 +339,7 @@ class FunctionHandler:
                 mv, defs = state.kill_and_add_definition(
                     effect.dest,
                     value,
-                    endness=state.arch.memory_endness,
+                    endness=None,
                     uses=effect.sources_defns or set(),
                     tags=effect.tags,
                 )

angr/analyses/reaching_definitions/reaching_definitions.py

@@ -28,7 +28,9 @@ from .dep_graph import DepGraph
 if TYPE_CHECKING:
     from typing import Literal
 
-    ObservationPoint = Tuple[Literal["insn", "node", "stmt"], Union[int, Tuple[int, int, int]], ObservationPointType]
+    ObservationPoint = Tuple[
+        Literal["insn", "node", "stmt", "exit"], Union[int, Tuple[int, int], Tuple[int, int, int]], ObservationPointType
+    ]
 
 l = logging.getLogger(name=__name__)
 
@@ -228,11 +230,18 @@ class ReachingDefinitionsAnalysis(
 
         return self.observed_results[key]
 
-    def node_observe(self, node_addr: int, state: ReachingDefinitionsState, op_type: ObservationPointType) -> None:
+    def node_observe(
+        self,
+        node_addr: int,
+        state: ReachingDefinitionsState,
+        op_type: ObservationPointType,
+        node_idx: Optional[int] = None,
+    ) -> None:
         """
         :param node_addr:   Address of the node.
         :param state:       The analysis state.
-        :param op_type:     Type of the bbservation point. Must be one of the following: OP_BEFORE, OP_AFTER.
+        :param op_type:     Type of the observation point. Must be one of the following: OP_BEFORE, OP_AFTER.
+        :param node_idx:    ID of the node. Used in AIL to differentiate blocks with the same address.
         """
 
         key = None
@@ -241,15 +250,21 @@ class ReachingDefinitionsAnalysis(
 
         if self._observe_all:
             observe = True
-            key: ObservationPoint = ("node", node_addr, op_type)
+            key: ObservationPoint = (
+                ("node", node_addr, op_type) if node_idx is None else ("node", (node_addr, node_idx), op_type)
+            )
         elif self._observation_points is not None:
-            key: ObservationPoint = ("node", node_addr, op_type)
+            key: ObservationPoint = (
+                ("node", node_addr, op_type) if node_idx is None else ("node", (node_addr, node_idx), op_type)
+            )
             if key in self._observation_points:
                 observe = True
         elif self._observe_callback is not None:
-            observe = self._observe_callback("node", addr=node_addr, state=state, op_type=op_type)
+            observe = self._observe_callback("node", addr=node_addr, state=state, op_type=op_type, node_idx=node_idx)
             if observe:
-                key: ObservationPoint = ("node", node_addr, op_type)
+                key: ObservationPoint = (
+                    ("node", node_addr, op_type) if node_idx is None else ("node", (node_addr, node_idx), op_type)
+                )
 
         if observe:
             self.observed_results[key] = state.live_definitions
@@ -351,6 +366,52 @@ class ReachingDefinitionsAnalysis(
             # it's an AIL block
             self.observed_results[key] = state.live_definitions.copy()
 
+    def exit_observe(
+        self,
+        node_addr: int,
+        exit_stmt_idx: int,
+        block: Union[Block, ailment.Block],
+        state: ReachingDefinitionsState,
+        node_idx: Optional[int] = None,
+    ):
+        observe = False
+        key = None
+
+        if self._observe_all:
+            observe = True
+            key = (
+                ("exit", (node_addr, exit_stmt_idx), ObservationPointType.OP_AFTER)
+                if node_idx is None
+                else ("exit", (node_addr, node_idx, exit_stmt_idx), ObservationPointType.OP_AFTER)
+            )
+        elif self._observation_points is not None:
+            key = (
+                ("exit", (node_addr, exit_stmt_idx), ObservationPointType.OP_AFTER)
+                if node_idx is None
+                else ("exit", (node_addr, node_idx, exit_stmt_idx), ObservationPointType.OP_AFTER)
+            )
+            if key in self._observation_points:
+                observe = True
+        elif self._observe_callback is not None:
+            observe = self._observe_callback(
+                "exit",
+                node_addr=node_addr,
+                exit_stmt_idx=exit_stmt_idx,
+                block=block,
+                state=state,
+            )
+            if observe:
+                key = (
+                    ("exit", (node_addr, exit_stmt_idx), ObservationPointType.OP_AFTER)
+                    if node_idx is None
+                    else ("exit", (node_addr, node_idx, exit_stmt_idx), ObservationPointType.OP_AFTER)
+                )
+
+        if not observe:
+            return
+
+        self.observed_results[key] = state.live_definitions.copy()
+
     @property
     def subject(self):
         return self._subject
@@ -411,7 +472,8 @@ class ReachingDefinitionsAnalysis(
             l.warning("Unsupported node type %s.", node.__class__)
             return False, state.copy(discard_tmpdefs=True)
 
-        self.node_observe(node.addr, state, OP_BEFORE)
+        state = state.copy(discard_tmpdefs=True)
+        self.node_observe(node.addr, state.copy(), OP_BEFORE)
 
         if self.subject.type == SubjectType.Function:
             node_parents = [
@@ -425,7 +487,6 @@ class ReachingDefinitionsAnalysis(
                 node_parents,
             )
 
-        state = state.copy(discard_tmpdefs=True)
         state = engine.process(
             state,
             block=block,

angr/analyses/variable_recovery/variable_recovery_fast.py

@@ -241,6 +241,7 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
         track_sp=True,
         func_args: Optional[List[SimVariable]] = None,
         store_live_variables=False,
+        unify_variables=True,
     ):
         if not isinstance(func, Function):
             func = self.kb.functions[func]
@@ -268,6 +269,7 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
         self._job_ctr = 0
         self._track_sp = track_sp and self.project.arch.sp_offset is not None
         self._func_args = func_args
+        self._unify_variables = unify_variables
 
         self._ail_engine = SimEngineVRAIL(self.project, self.kb, call_info=call_info)
         self._vex_engine = SimEngineVRVEX(self.project, self.kb, call_info=call_info)
@@ -460,6 +462,9 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
                     state.downsize_region(state.stack_region),
                 )
 
+        if self._unify_variables:
+            self.variable_manager[self.function.addr].unify_variables()
+
         # unify type variables for global variables
         for var, typevars in self.var_to_typevars.items():
             if len(typevars) > 1 and isinstance(var, SimMemoryVariable) and not isinstance(var, SimStackVariable):

angr/calling_conventions.py

@@ -158,6 +158,12 @@ def refine_locs_with_struct_type(
             for field, field_ty in arg_type.fields.items()
         }
         return SimStructArg(arg_type, locs)
+    if isinstance(arg_type, SimUnion):
+        # Treat a SimUnion as functionality equivalent to its longest member
+        for member in arg_type.members.values():
+            if member.size == arg_type.size:
+                return refine_locs_with_struct_type(arch, locs, member, offset)
+
     raise TypeError("I don't know how to lay out a %s" % arg_type)
 
 
@@ -1813,6 +1819,24 @@ class SimCCAArch64LinuxSyscall(SimCCSyscall):
         return state.regs.x8
 
 
+class SimCCRISCV64LinuxSyscall(SimCCSyscall):
+    # TODO: Make sure all the information is correct
+    ARG_REGS = ["a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7"]
+    FP_ARG_REGS = []  # TODO: ???
+    RETURN_VAL = SimRegArg("a0", 8)
+    RETURN_ADDR = SimRegArg("ip_at_syscall", 4)
+    ARCH = archinfo.ArchRISCV64
+
+    @classmethod
+    def _match(cls, arch, args, sp_delta):  # pylint: disable=unused-argument
+        # never appears anywhere except syscalls
+        return False
+
+    @staticmethod
+    def syscall_num(state):
+        return state.regs.a0
+
+
 class SimCCO32(SimCC):
     ARG_REGS = ["a0", "a1", "a2", "a3"]
     FP_ARG_REGS = [
@@ -2292,6 +2316,10 @@ SYSCALL_CC: Dict[str, Dict[str, Type[SimCCSyscall]]] = {
         "default": SimCCS390XLinuxSyscall,
         "Linux": SimCCS390XLinuxSyscall,
     },
+    "RISCV64": {
+        "default": SimCCRISCV64LinuxSyscall,
+        "Linux": SimCCRISCV64LinuxSyscall,
+    },
 }
 
 

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -495,6 +495,9 @@ class LiveDefinitions:
             except SimMemoryError:
                 l.warning("Failed to store register definition %s at %d.", d, atom.reg_offset, exc_info=True)
         elif isinstance(atom, MemoryLocation):
+            if endness is None:
+                endness = atom.endness
+
             if isinstance(atom.addr, SpOffset):
                 if atom.addr.offset is not None:
                     stack_addr = self.stack_offset_to_stack_addr(atom.addr.offset)

angr/knowledge_plugins/key_definitions/rd_model.py

@@ -120,12 +120,18 @@ class ReachingDefinitionsModel:
         return self.observed_results.get(("insn", ins_addr.ins_addr, kind))
 
     def get_observation_by_node(
-        self, node_addr: Union[int, "CodeLocation"], kind: ObservationPointType
+        self, node_addr: Union[int, "CodeLocation"], kind: ObservationPointType, node_idx: Optional[int] = None
     ) -> Optional[LiveDefinitions]:
         if isinstance(node_addr, int):
-            return self.observed_results.get(("node", node_addr, kind), None)
+            key = ("node", node_addr, kind) if node_idx is None else ("node", (node_addr, node_idx), kind)
+            return self.observed_results.get(key, None)
         else:
-            return self.observed_results.get(("node", node_addr.block_addr, kind))
+            key = (
+                ("node", node_addr.block_addr, kind)
+                if node_idx is None
+                else ("node", (node_addr.block_addr, node_idx), kind)
+            )
+            return self.observed_results.get(key, None)
 
     @overload
     def get_observation_by_stmt(self, codeloc: "CodeLocation", kind: ObservationPointType) -> Optional[LiveDefinitions]:
@@ -150,3 +156,16 @@ class ReachingDefinitionsModel:
                 return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx), arg2), None)
             else:
                 return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx, block_idx), arg2), None)
+
+    def get_observation_by_exit(
+        self,
+        node_addr: int,
+        stmt_idx: int,
+        src_node_idx: Optional[int] = None,
+    ) -> Optional[LiveDefinitions]:
+        key = (
+            ("exit", (node_addr, stmt_idx), ObservationPointType.OP_AFTER)
+            if src_node_idx is None
+            else ("exit", (node_addr, src_node_idx, stmt_idx), ObservationPointType.OP_AFTER)
+        )
+        return self.observed_results.get(key, None)

angr/knowledge_plugins/variables/variable_manager.py

@@ -1,4 +1,4 @@
-from typing import Set, List, Tuple, Dict, Union, Optional, TYPE_CHECKING
+from typing import Set, List, Tuple, Dict, Union, Optional, Literal, TYPE_CHECKING
 import logging
 from collections import defaultdict
 from itertools import count, chain
@@ -591,14 +591,15 @@ class VariableManagerInternal(Serializable):
 
         return accesses
 
-    def get_variables(self, sort=None, collapse_same_ident=False) -> List[Union[SimStackVariable, SimRegisterVariable]]:
+    def get_variables(
+        self, sort: Optional[Literal["stack", "reg"]] = None, collapse_same_ident=False
+    ) -> List[Union[SimStackVariable, SimRegisterVariable]]:
         """
         Get a list of variables.
 
-        :param str or None sort:    Sort of the variable to get.
+        :param sort:                Sort of the variable to get.
         :param collapse_same_ident: Whether variables of the same identifier should be collapsed or not.
         :return:                    A list of variables.
-        :rtype:                     list
         """
 
         variables = []
@@ -615,6 +616,27 @@ class VariableManagerInternal(Serializable):
 
         return variables
 
+    def get_unified_variables(
+        self, sort: Optional[Literal["stack", "reg"]] = None
+    ) -> List[Union[SimStackVariable, SimRegisterVariable]]:
+        """
+        Get a list of unified variables.
+
+        :param sort:    Sort of the variable to get.
+        :return:        A list of variables.
+        """
+
+        variables = []
+
+        for var in self._unified_variables:
+            if sort == "stack" and not isinstance(var, SimStackVariable):
+                continue
+            if sort == "reg" and not isinstance(var, SimRegisterVariable):
+                continue
+            variables.append(var)
+
+        return variables
+
     def get_global_variables(self, addr):
         """
         Get global variable by the address of the variable.

angr/project.py

@@ -268,8 +268,8 @@ class Project:
         """
         Initializes self.analyses using a given preset.
         """
-        self.analyses = cast("AnalysesHubWithDefault", AnalysesHub(self))
-        self.analyses.use_plugin_preset(self._analyses_preset if self._analyses_preset is not None else "default")
+        self._analyses = cast("AnalysesHubWithDefault", AnalysesHub(self))
+        self._analyses.use_plugin_preset(self._analyses_preset if self._analyses_preset is not None else "default")
 
     def _register_object(self, obj, sim_proc_arch):
         """

angr/sim_type.py

@@ -849,7 +849,7 @@ class SimTypeFunction(SimType):
     _fields = ("args", "returnty")
     base = False
 
-    def __init__(self, args, returnty, label=None, arg_names=None, variadic=False):
+    def __init__(self, args: List[SimType], returnty: Optional[SimType], label=None, arg_names=None, variadic=False):
         """
         :param label:    The type label
         :param args:     A tuple of types representing the arguments to the function
@@ -857,7 +857,7 @@ class SimTypeFunction(SimType):
         :param variadic: Whether the function accepts varargs
         """
         super().__init__(label=label)
-        self.args = args
+        self.args: List[SimType] = args
         self.returnty: Optional[SimType] = returnty
         self.arg_names = arg_names if arg_names else ()
         self.variadic = variadic

angr/storage/memory_mixins/multi_value_merger_mixin.py

@@ -21,11 +21,16 @@ class MultiValueMergerMixin(MemoryMixin):
         # try to merge it in the traditional way
         if len(values_set) > self._element_limit:
             # strip annotations from each value and see how many raw values there are in total
-            stripped_values_set = {v._apply_to_annotations(lambda alist: None) for v in values_set}
+            # We have to use cache_key to determine uniqueness here, because if __hash__ collides,
+            # python implicitly calls __eq__ to determine if the two objects are actually the same
+            # and that just results in a new AST for a BV. Python then tries to convert that AST to a bool
+            # which fails with the safeguard in claripy.ast.bool.Bool.__bool__.
+            stripped_values_set = {v._apply_to_annotations(lambda alist: None).cache_key for v in values_set}
             if len(stripped_values_set) > 1:
                 ret_val = self._top_func(merged_size * self.state.arch.byte_width)
             else:
-                ret_val = next(iter(stripped_values_set))
+                # Get the AST back from the cache_key
+                ret_val = next(iter(stripped_values_set)).ast
             # migrate annotations
             annotations = []
             for v in values_set:

{angr-9.2.62.dist-info → angr-9.2.63.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.62
+Version: 9.2.63
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 Home-page: https://github.com/angr/angr
 License: BSD-2-Clause
@@ -16,27 +16,27 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment (==9.2.62)
-Requires-Dist: archinfo (==9.2.62)
+Requires-Dist: ailment ==9.2.63
+Requires-Dist: archinfo ==9.2.63
 Requires-Dist: cachetools
-Requires-Dist: capstone (!=5.0.0rc2,>=3.0.5rc2)
-Requires-Dist: cffi (>=1.14.0)
-Requires-Dist: claripy (==9.2.62)
-Requires-Dist: cle (==9.2.62)
+Requires-Dist: capstone !=5.0.0rc2,>=3.0.5rc2
+Requires-Dist: cffi >=1.14.0
+Requires-Dist: claripy ==9.2.63
+Requires-Dist: cle ==9.2.63
 Requires-Dist: dpkt
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
 Requires-Dist: nampa
-Requires-Dist: networkx (!=2.8.1,>=2.0)
-Requires-Dist: protobuf (>=3.19.0)
+Requires-Dist: networkx !=2.8.1,>=2.0
+Requires-Dist: protobuf >=3.19.0
 Requires-Dist: psutil
-Requires-Dist: pycparser (>=2.18)
-Requires-Dist: pyvex (==9.2.62)
-Requires-Dist: rich (>=13.1.0)
+Requires-Dist: pycparser >=2.18
+Requires-Dist: pyvex ==9.2.63
+Requires-Dist: rich >=13.1.0
 Requires-Dist: rpyc
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy
-Requires-Dist: unicorn (==2.0.1.post1)
+Requires-Dist: unicorn ==2.0.1.post1
 Requires-Dist: colorama ; platform_system == "Windows"
 Provides-Extra: angrdb
 Requires-Dist: sqlalchemy ; extra == 'angrdb'
@@ -46,10 +46,10 @@ Requires-Dist: myst-parser ; extra == 'docs'
 Requires-Dist: sphinx ; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints ; extra == 'docs'
 Provides-Extra: pcode
-Requires-Dist: pypcode (>=1.1) ; extra == 'pcode'
+Requires-Dist: pypcode >=1.1 ; extra == 'pcode'
 Provides-Extra: testing
 Requires-Dist: keystone-engine ; extra == 'testing'
-Requires-Dist: pypcode (>=1.1) ; extra == 'testing'
+Requires-Dist: pypcode >=1.1 ; extra == 'testing'
 Requires-Dist: pytest ; extra == 'testing'
 Requires-Dist: pytest-split ; extra == 'testing'
 Requires-Dist: pytest-xdist ; extra == 'testing'

{angr-9.2.62.dist-info → angr-9.2.63.dist-info}/RECORD

@@ -1,16 +1,16 @@
-angr/__init__.py,sha256=ZkMIdCekKQnsfeMCiqb4fSeHhDSJ5BtCRh071y76A_Q,2800
+angr/__init__.py,sha256=_fNDmP91K4YZntgKbJuPKWxw112jMpQv-ysV3f9GMbw,2800
 angr/annocfg.py,sha256=dK5JAdN4Ig_jgxTBZeZXwk3kAS4-IQUvE6T02GBZTDQ,10818
 angr/blade.py,sha256=1f5cqw1w6mKtYszN2-5QMxaoP_bbqpIaVlE7Vpf8yjc,15161
 angr/block.py,sha256=RXro1XdUTztfPL2r62m2YA1XTNe7bP0lkBUDYzz_FyE,14371
 angr/callable.py,sha256=p98KlOijfkcGnUx1C-lNt-R5ncYF4md6oxC7aBKc8Ws,5513
-angr/calling_conventions.py,sha256=v7fx384BhTO82Rq-ownnyAF9HzIVe49duvHxZDczRjo,87741
+angr/calling_conventions.py,sha256=RiJO0pz7EImjZA4wJzQ4M_Ez8d26QTs-d2RXbFLzgQo,88701
 angr/code_location.py,sha256=_EXS1uAEkoOKBoxtvxAOluLsbKkcjyAWnCnviHdBK7w,4720
 angr/codenode.py,sha256=uF9iObkowp87iBZimrpNl-JSr7vQanhL94dWESnw1Ks,3759
 angr/errors.py,sha256=uYZEr2kYrKeylLIkrfNOtLy68sA0R3OJ9CD77Ucg4NQ,8191
 angr/factory.py,sha256=rHwRkt47EeJW2tsL9aIq_NjantEJwCsqdd34mg2HmVk,17141
 angr/graph_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 angr/keyed_region.py,sha256=vgaJ7sUkUeGfXY-dRcRl40qNtB-JDbIWaL7xRdcDGdQ,17363
-angr/project.py,sha256=THmzvwJ-2yrtz18PURPGufOj7Mr11GiHt_UV5Td0i10,37021
+angr/project.py,sha256=2Wi1VBGb94EQl8DeGi5cAE1_joF17O-kt5R0FFhHkw8,37023
 angr/py.typed,sha256=SQuN8RfR7Scqb98Wf7vJndZle4ROvVL1kp6l5M7EpmY,7
 angr/serializable.py,sha256=6cljvzAqFwsLqFu9ouCno7hMpgstha5-8C7RyWNCRXc,1502
 angr/service.py,sha256=9R50bFaCf6zjxybiEIVIkODSVCsE2VcTul_KjjsjaGU,1102
@@ -19,7 +19,7 @@ angr/sim_options.py,sha256=OuT01xS_F3ifBD9MAfZmNCnfjtTg0HulZlrKcs1LNSY,18057
 angr/sim_procedure.py,sha256=uM4poyQYkVy_zlJqgyM_CbtVcDRbSsyZ1Z50i4yFwNw,25822
 angr/sim_state.py,sha256=BxL2lvo4bWmen5PKs1TegedOgnM8EFBgDJ-rsZf-XkE,37869
 angr/sim_state_options.py,sha256=lfP7ygngjGe0AGV5rkE24tvBazJBZG-RTdrKj4rL9XE,12530
-angr/sim_type.py,sha256=3_dCKz6-vBL2fuXdiqXFZn9PlB8D5LLK78JuLaz_ssk,115684
+angr/sim_type.py,sha256=71FRCbPM1sl0d-Wp7pzQeNsMC0nVE7wggoRa7YloeTM,115733
 angr/sim_variable.py,sha256=GhlHsMknbMs6OWfI0CM0VUMKlk16irBzPloSk7S8HuI,17235
 angr/slicer.py,sha256=kbLKMAjf2kC6ov-OiGb95BqLmgV0QRl5mmEANcvzuAk,10640
 angr/state_hierarchy.py,sha256=w_5Tl-7h9xUXBsIKZRAWw8Xh0we8GIAaN6nbKgYH_Qo,8467
@@ -40,7 +40,7 @@ angr/analyses/complete_calling_conventions.py,sha256=4vJA0lrF2q6do-f4wYy3tpfwI8y
 angr/analyses/congruency_check.py,sha256=U3xBVim4pNSrnURqsFysipVIuGFWbqtxZ6nfRBfWaLY,16456
 angr/analyses/datagraph_meta.py,sha256=75AVKJ8LIL4Id0nlz3Gf6XlruqarYyBX1WylxRvcAeQ,3386
 angr/analyses/ddg.py,sha256=DLDVy7jA20gobLLJkm617uoVK7sQ74v3bfwqq_61ETw,63433
-angr/analyses/disassembly.py,sha256=qgu3a63LQTcHlYT8rsypi0ZzgNaqiIT3QTzJ3yI4rIE,45396
+angr/analyses/disassembly.py,sha256=hLHnCSeHXm94rbtGJS3Ri-LfvVML92NO2tAm_sUTgTo,45143
 angr/analyses/disassembly_utils.py,sha256=4Np0PCPjr0h0jIVzUUG6KzrEKl9--IpTE3sgmmsmhcg,2989
 angr/analyses/dominance_frontier.py,sha256=XRfC_LUUetE8t1Cc9bwvWS9sl63Fx9sp8KFqN_Y9IDg,1245
 angr/analyses/find_objects_static.py,sha256=qrSNCLXsZQY8Jyx6jwCVF3k8jNfyV4ELpYuM3grhNio,10152
@@ -64,7 +64,7 @@ angr/analyses/cfg/cfg.py,sha256=1JpPGlqXXRFwE0tk26xjabT_-dq-kqAxMv7o6-DUhp4,3146
 angr/analyses/cfg/cfg_arch_options.py,sha256=YONHg6y-h6BCsBkJK9tuxb94DDfeOoy9CUS-LVyyDyg,3112
 angr/analyses/cfg/cfg_base.py,sha256=2uUMpylpVgM1bKHGavvCSxKd1Hseic-Jg4nbYlJczlw,121101
 angr/analyses/cfg/cfg_emulated.py,sha256=Fi3rDN5ByxhO-H4Y7qn-3WZgBG12JGyvxcWmrD_FnFQ,152842
-angr/analyses/cfg/cfg_fast.py,sha256=q9iR6AFmpc4s1_4kXFDtRNwo2aRS-4G4_leEO_U2qjA,201457
+angr/analyses/cfg/cfg_fast.py,sha256=4DAyC7pNwJ7OUy7RkzthrnHUHu1Wt-s3GqpuJ3DY_gg,201265
 angr/analyses/cfg/cfg_fast_soot.py,sha256=eA_P-OY3gRRNj2BBgSPMsB_llGyFFCNW3VyGZ2uiMoM,26047
 angr/analyses/cfg/cfg_job_base.py,sha256=3IQE_Iy17xtGfsIkrKc2ERIakAYiNdLtRb_jwOGQtHU,5989
 angr/analyses/cfg/segment_list.py,sha256=XM-rcLHkl008U5xu9pkVCenhcHWAFBKwVdDLa-kGFgY,20467
@@ -92,8 +92,8 @@ angr/analyses/decompiler/ail_simplifier.py,sha256=1vWds_c62_D_muGGjdYZpPc_248zlE
 angr/analyses/decompiler/ailgraph_walker.py,sha256=sBz9Cn0GtdpuFt7R9y3oX6NFvETQTZRh6N80eM9ZdJQ,1595
 angr/analyses/decompiler/block_simplifier.py,sha256=xsHjw_brmhrYZB_K6aaEECzWS6UkCWWxS_a77JCfTwo,16809
 angr/analyses/decompiler/callsite_maker.py,sha256=Zro4ps4ZFie-iiB39Zg_xLkEFOgfwM1Czb8q-ReSEDk,14956
-angr/analyses/decompiler/clinic.py,sha256=Ga3eXiejMG_NjhpxAT0293LjfesXaR6A2WydSUNAkjA,64793
-angr/analyses/decompiler/condition_processor.py,sha256=ga9dcpSxZIyvDstuOa8ZmrNfD5xqPtKQxa4cpmgvgZQ,47566
+angr/analyses/decompiler/clinic.py,sha256=HjR4x1NYuagWr0b_lK0W5i3oqAl9EdymMK0BOvwzZQs,71322
+angr/analyses/decompiler/condition_processor.py,sha256=6zuncOn59kDxl4DOm92U-d-rt3-R-LyJOv3vKKxJ7Y8,47723
 angr/analyses/decompiler/decompilation_cache.py,sha256=NveTVs6IY3TTdgsLvTb3ktftM4n0NrAJIkqjXqQ3550,1119
 angr/analyses/decompiler/decompilation_options.py,sha256=W_l0Sl6yLiYC2iLkXgC0I8staUWgYoeR2yevwcXri9c,6739
 angr/analyses/decompiler/decompiler.py,sha256=fYfM3UqQA_tjcjk1sWiLHNyfGDsvIMdHtG8z-0wOGHc,19690
@@ -147,7 +147,7 @@ angr/analyses/decompiler/peephole_optimizations/constant_derefs.py,sha256=n3SVw_
 angr/analyses/decompiler/peephole_optimizations/conv_a_sub0_shr_and.py,sha256=pvIOzWNBYUyDjj634KeSlo5Qb8E_UBuezDoyYGE_CBw,2568
 angr/analyses/decompiler/peephole_optimizations/conv_const_mull_a_shift.py,sha256=0dX8tqr7qOgIuZaiQ1YT9o-t-uj6cQmDbz67wSEM79U,3569
 angr/analyses/decompiler/peephole_optimizations/conv_shl_shr.py,sha256=4zQ5DGNX6z-CAartjDM4vm-zCeiaRXYFbhriMKuOLp8,2060
-angr/analyses/decompiler/peephole_optimizations/eager_eval.py,sha256=4-9taii1sKd17YZNWwUDmppaYJbFEOOd1kRPnDKWtpg,8301
+angr/analyses/decompiler/peephole_optimizations/eager_eval.py,sha256=SUjzkqLm0s-95zOdmg3oY1OBUoT0rXz08h5Ck_5Y-Tk,8464
 angr/analyses/decompiler/peephole_optimizations/extended_byte_and_mask.py,sha256=Snm7FXANsgoTUqV0_wVZvxNxFx75hJW9JYnazhMyMWg,2005
 angr/analyses/decompiler/peephole_optimizations/one_sub_bool.py,sha256=XJjQQ28vLIj-2KjlX1hL8JVeXM0Fhj2lkDufPlPFsBU,1126
 angr/analyses/decompiler/peephole_optimizations/remove_cascading_conversions.py,sha256=Iwe7cTZiskgkieA2u0Nkaz5XgMVY_7E2zO67P8PKh2Y,581
@@ -181,7 +181,7 @@ angr/analyses/decompiler/region_simplifiers/switch_cluster_simplifier.py,sha256=
 angr/analyses/decompiler/region_simplifiers/switch_expr_simplifier.py,sha256=HGIiC6c3C91VfcqxUHe9aTsRohwmMXOHZH_G_dbwwx4,3327
 angr/analyses/decompiler/structured_codegen/__init__.py,sha256=Glc4jBCr7lZckltN9XZdSvMrGHf0swXFyKTr_QQKdWE,290
 angr/analyses/decompiler/structured_codegen/base.py,sha256=nJPOoeJCbewchYdXjSE4S2b1-WN6pT3TxmCQMDO0azw,3845
-angr/analyses/decompiler/structured_codegen/c.py,sha256=O9kctNUZ40DzAkn0j0flBZk5Ujx1N_pjhUGpI6g02eU,123028
+angr/analyses/decompiler/structured_codegen/c.py,sha256=s55_oBWcjPcmwZel20reZYRlmncQCsmPwO1l0DCqr04,123302
 angr/analyses/decompiler/structured_codegen/dummy.py,sha256=IVfmtcWpTgNCRVsuW3GdQgDnuPmvodX85V0bBYtF_BI,535
 angr/analyses/decompiler/structured_codegen/dwarf_import.py,sha256=TMz65TkF_ID_Ipocj0aFDb84H6slolN90wq0tzhY2Rk,6773
 angr/analyses/decompiler/structuring/__init__.py,sha256=eSiT6xUpv9K5-enK3OZj2lNzxwowS9_5OTrjHiPgfFs,371
@@ -242,13 +242,13 @@ angr/analyses/propagator/vex_vars.py,sha256=O0W7GekEZIVwiNiOdyu-BuxCZmHFZPh_ho7j
 angr/analyses/reaching_definitions/__init__.py,sha256=24NQuCGrTgHT6lNdw4gAL5lZ0SDDfnJdOhdRbvwCoMM,2070
 angr/analyses/reaching_definitions/call_trace.py,sha256=5y8VtU-5-2ISamCkok6zoMahWASO2TBQYl5Q0pgeLGw,2217
 angr/analyses/reaching_definitions/dep_graph.py,sha256=3kyfEZpNo5ybTOZnl_6Xg08Wd6xvzVzJrJI6Z8fw0Mo,14374
-angr/analyses/reaching_definitions/engine_ail.py,sha256=a-_R3d8D43E8ztZjwaNyC5ZyMF67Wanj_4eq9LyM_UQ,43796
-angr/analyses/reaching_definitions/engine_vex.py,sha256=3usK6diT4MYbxyXG4x0WZ7u5gBRuWaXGOJC_OpdSMto,40423
+angr/analyses/reaching_definitions/engine_ail.py,sha256=hbRjCgjhW5ndDeCC2qoR6GN98Dq6TDLKfYENsuZE8LA,44047
+angr/analyses/reaching_definitions/engine_vex.py,sha256=kqrh_LEMgldOVHr4PyVLmR9k_R1Tp99dVlUWObXAP64,40978
 angr/analyses/reaching_definitions/external_codeloc.py,sha256=1tWKiupu1wTSFP11P5lEhWaSSe7iRwWtERPIxJcHtbI,814
-angr/analyses/reaching_definitions/function_handler.py,sha256=_mIgUm8Qqmlxb6ie-BDNt67J-bT_L8zdiAtQx6mHf9Q,20465
+angr/analyses/reaching_definitions/function_handler.py,sha256=a9Kmd6pKYyaPprXqlbrLJ3QJt_41BiFZMjiVJIGcQ-A,20564
 angr/analyses/reaching_definitions/heap_allocator.py,sha256=L7LCcE-QvLd_vuc0slWmQ6X73wkYNMkUEDy1cJAV818,2634
 angr/analyses/reaching_definitions/rd_state.py,sha256=2b_lCaCTQ4vGZHcB71hwxsIAYnoq9w5eLaIQoKokZiY,27365
-angr/analyses/reaching_definitions/reaching_definitions.py,sha256=h4TOFGjSPatDlNatf4ac571lLMNfukdvCvS09GtLIIY,19335
+angr/analyses/reaching_definitions/reaching_definitions.py,sha256=PYkWduHW6Vkz__zssNzkpOYYPD4NwvEC9jYE3f1mG9Y,21524
 angr/analyses/reaching_definitions/subject.py,sha256=GVaI1jM-Nv2MWaCjJ-Q_54nSS3hvAaZthz14AJJNq-A,1995
 angr/analyses/typehoon/__init__.py,sha256=kCQMAuvsUKAdYFiOstBzMBCqpquJKJCQSe0CGAr2Rng,31
 angr/analyses/typehoon/lifter.py,sha256=IfkY27IyJ7QeQnVER89ZhdyScKLAoHCdVpcvtdqTy8I,1675
@@ -265,7 +265,7 @@ angr/analyses/variable_recovery/engine_vex.py,sha256=cWSqeBRhejy2IDNm5N0gNq3-ldx
 angr/analyses/variable_recovery/irsb_scanner.py,sha256=gozNZF5LHFWCp_H4NW8CIgVnm4iiYWYUspu7NCOY0Tc,4300
 angr/analyses/variable_recovery/variable_recovery.py,sha256=G5YCt8qoEnPQjy50lES0m_8DlcN30R8W8oIrO4b98-Y,21823
 angr/analyses/variable_recovery/variable_recovery_base.py,sha256=VXTSv1JSPJHisQUsSh1_GTp-KzCOH90bJ814n4fo_7s,13256
-angr/analyses/variable_recovery/variable_recovery_fast.py,sha256=rjn1cCcoyOtXSWwWgvAq5RIY4ZRyZPHPzM_4WbNyYys,23587
+angr/analyses/variable_recovery/variable_recovery_fast.py,sha256=dPIFyndE3qmBFlQskJlc4ZCe0p75jnOxIWVWHZwqJSY,23772
 angr/angrdb/__init__.py,sha256=df9W7J7c4rD5oYx6fZGf0BIBwOqVVJlIJTDrAtQChqY,231
 angr/angrdb/db.py,sha256=HZL4tvxNkxwqLKNTGSz0-5n07OvWcXoIqWWtpBy-M9k,6459
 angr/angrdb/models.py,sha256=iFEouZNGa5gJK8U5-vy98CErrgeM5E3CGbSKOXjoMfU,4750
@@ -436,9 +436,9 @@ angr/knowledge_plugins/key_definitions/definition.py,sha256=7V81e7SgN0YKQPdeQ7de
 angr/knowledge_plugins/key_definitions/environment.py,sha256=cbNst29pGtv13Z6jlvdBIajYkE3X9MnAV5ixRTHkHzQ,3461
 angr/knowledge_plugins/key_definitions/heap_address.py,sha256=62vX5xkT91qO-6IKtGtGNUqgkfFUU1_Al6B9vU-SA7E,922
 angr/knowledge_plugins/key_definitions/key_definition_manager.py,sha256=PETOIDYYj7VPp2rtIO5XhXnvi3lgDr9qXa4pZrwbCho,3235
-angr/knowledge_plugins/key_definitions/live_definitions.py,sha256=vD01P9yWoMy-yB51zr2a_9T7Wthr35iBRmFPTiPJtws,31022
+angr/knowledge_plugins/key_definitions/live_definitions.py,sha256=wPvnEybnMq8zsRjPHIXbYAR944KblL7kxd29fdLoRew,31094
 angr/knowledge_plugins/key_definitions/liveness.py,sha256=PqciLk4cdHLxNp4mmyCDMpgCxSbk9VJZlx5Ai5_LYos,4054
-angr/knowledge_plugins/key_definitions/rd_model.py,sha256=1Cx7gZos3DxXuZL-1yor_oN0zx80bXuPNCzy8SyFsJw,6281
+angr/knowledge_plugins/key_definitions/rd_model.py,sha256=pNPkHRVI41ObxZ_BDK-4cLoK-WfeCwxa9gOpAyHBQIM,7022
 angr/knowledge_plugins/key_definitions/tag.py,sha256=uBHlS71E3Ok_6V3K8NkMblctCrnAHmPYikaFTA02PyA,1682
 angr/knowledge_plugins/key_definitions/undefined.py,sha256=dv1fo4jR48tuslsbPZ40YZhqePfVxBohH9LtFKP8qhk,1236
 angr/knowledge_plugins/key_definitions/unknown_size.py,sha256=YwA1DWBE9796BTU8KdY6xIR88IXc2KDUAZuxHEqO710,1510
@@ -454,12 +454,12 @@ angr/knowledge_plugins/sync/__init__.py,sha256=RN3y0UhYax-GdPyAhondMXEBuWIu-enHj
 angr/knowledge_plugins/sync/sync_controller.py,sha256=TipNeYSek6VZCU87SDgBDBTZUBI9iAebGpYE1lJ9YTg,9315
 angr/knowledge_plugins/variables/__init__.py,sha256=tmh_2i0X6Y41TkEgxHRQ4y-kVEGZnlDIpJZ_wUkCISI,60
 angr/knowledge_plugins/variables/variable_access.py,sha256=CtstTsBph7RCGoWTFsiaPLDMuXjKQAoQ8lgwVMESisA,3751
-angr/knowledge_plugins/variables/variable_manager.py,sha256=S46n9FzEmS6XeadHfJycVFI2wJ-6IRRW-PAf6g7QH-A,41260
+angr/knowledge_plugins/variables/variable_manager.py,sha256=unVauUDoC-mVn20Lp73Cq4QWm-ciXt1frwWJlhcJxZ4,41925
 angr/knowledge_plugins/xrefs/__init__.py,sha256=-5A2h048WTRu6Et7q7bqlc-AyBXNuJ9AF9nE9zc3M4I,94
 angr/knowledge_plugins/xrefs/xref.py,sha256=w4wjDFl4xtJYOtJplp9s1AIX3wI1RE71po3ufh1M4aY,4963
 angr/knowledge_plugins/xrefs/xref_manager.py,sha256=GYF9N1t4JxkDNGAwrVLo4_NF51P4gqiuQ21F0IbloF0,4026
 angr/knowledge_plugins/xrefs/xref_types.py,sha256=VR3xLQQ-gUg25oX0OL3BJHyQRlZh2A8syBac9ZMS9n4,271
-angr/lib/angr_native.dll,sha256=teROZS83j4I1MP_3zctfQlZhKp41_Kw1j-dbNeGOJn8,19211264
+angr/lib/angr_native.dll,sha256=fCkJlpcah5whSRp96g83Zu0RJT9FpVxlTuEJ47JZ3iw,19212800
 angr/misc/__init__.py,sha256=Ct-Q6-c-Frdz5Ihkqmou3j_1jyJi8WJXlQxs-gPQg0Y,237
 angr/misc/ansi.py,sha256=TKrx7d_MViChHh5RBR2VLufNrujTUioJWsZS5ugk8k4,807
 angr/misc/autoimport.py,sha256=6WT-Z6wf5NiacQhKZmR4d2bPOvNrokA7Wg0g2MUXSuw,2371
@@ -1129,7 +1129,7 @@ angr/storage/memory_mixins/default_filler_mixin.py,sha256=aNi2UAmknGHr0JNnD7WWj9
 angr/storage/memory_mixins/dirty_addrs_mixin.py,sha256=-UDDtjEkh19Dd5paf-62NBvSiIHTmQXPM0QtriJ5eig,317
 angr/storage/memory_mixins/hex_dumper_mixin.py,sha256=ciMIrmfTmxWPWVUUiIw5h8YNdHmrWg_GsK6Bzg5omzE,3668
 angr/storage/memory_mixins/label_merger_mixin.py,sha256=F-1F_zotCO9OOTXaG8Ax2-Mi2F2aN7hQ8pIwxgH1nVE,858
-angr/storage/memory_mixins/multi_value_merger_mixin.py,sha256=XbKfGE3h2QIjk2qVazPH0dF6a2pLu0UwIboJA9YvhBY,1773
+angr/storage/memory_mixins/multi_value_merger_mixin.py,sha256=nzO53flhiADGsCS4WAFSo_mRSAYZ9sa1jVzx-flIPqg,2226
 angr/storage/memory_mixins/name_resolution_mixin.py,sha256=YOM3yDjTmybDgAVvJGHuVWUgkDqsbFsWRgkJP8vI9ho,3412
 angr/storage/memory_mixins/simple_interface_mixin.py,sha256=zdTLTKblqep-eA5LwQ3kuUIfV2fhUpgQN4bxRGhIf-g,2492
 angr/storage/memory_mixins/simplification_mixin.py,sha256=stTzmaoa0IHxhDSWsYdzKGSt2n37XRjJ7kgZdoa5Uu0,502
@@ -1182,8 +1182,8 @@ angr/utils/library.py,sha256=MYbY6rvC2Fi1ofbBHynh6-cdmaDETxj8hBz1gxKvsQQ,7178
 angr/utils/loader.py,sha256=QdkatPiyRfz5KdfCzRI1Xp3TJL_Pa75wY0dsILgMbwk,1944
 angr/utils/mp.py,sha256=xSWDnZdkLaTwGXntuSDwb2tIqMsIxJpmLrxd_YWBILw,1822
 angr/utils/timing.py,sha256=uOowCP8kotDrKDOjlAod-guBuYkAA8zEtiAwpdwMlIU,1334
-angr-9.2.62.dist-info/LICENSE,sha256=cgL_ho5B1NH8UxwtBuqThRWdjear8b7hktycaS1sz6g,1327
-angr-9.2.62.dist-info/METADATA,sha256=ly0aEBw6VhCrySkymeWqwDrH8Xzc30ClY_Yi1M2Xqio,4812
-angr-9.2.62.dist-info/WHEEL,sha256=mrWOx6J2F1tE6ZQ2IHrEElXwJlXc4qGHu6mNTK_VE4U,98
-angr-9.2.62.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
-angr-9.2.62.dist-info/RECORD,,
+angr-9.2.63.dist-info/LICENSE,sha256=cgL_ho5B1NH8UxwtBuqThRWdjear8b7hktycaS1sz6g,1327
+angr-9.2.63.dist-info/METADATA,sha256=Uj-LZodnnYChYgiC3JBei_qQwD96Y8NrA3cH5pcpOM8,4784
+angr-9.2.63.dist-info/WHEEL,sha256=lSKux-xIjaDq1E0C7owBo6jeb0yEUWF9cMz4nJ57Kn0,98
+angr-9.2.63.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
+angr-9.2.63.dist-info/RECORD,,

{angr-9.2.62.dist-info → angr-9.2.63.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.0)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-win_amd64