angr 9.2.98__tar.gz → 9.2.100__tar.gz

{angr-9.2.98/angr.egg-info → angr-9.2.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.98
+Version: 9.2.100
 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
@@ -17,13 +17,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.98
-Requires-Dist: archinfo==9.2.98
+Requires-Dist: ailment==9.2.100
+Requires-Dist: archinfo==9.2.100
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.0.post1
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.98
-Requires-Dist: cle==9.2.98
+Requires-Dist: claripy==9.2.100
+Requires-Dist: cle==9.2.100
 Requires-Dist: dpkt
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
@@ -33,7 +33,7 @@ Requires-Dist: protobuf>=3.19.0
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.98
+Requires-Dist: pyvex==9.2.100
 Requires-Dist: rich>=13.1.0
 Requires-Dist: rpyc
 Requires-Dist: sortedcontainers

{angr-9.2.98 → angr-9.2.100}/angr/__init__.py

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

{angr-9.2.98 → angr-9.2.100}/angr/analyses/cfg/cfg_fast.py

@@ -3287,7 +3287,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         removed_nodes = set()
 
-        a = None  # it always hold the very recent non-removed node
+        a = None  # it always holds the very recent non-removed node
         is_arm = is_arm_arch(self.project.arch)
 
         for i in range(len(sorted_nodes)):  # pylint:disable=consider-using-enumerate
@@ -3341,7 +3341,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
                 # but somehow we thought b is the beginning
                 if a.addr + a.size == b.addr + b.size:
                     in_edges = len([_ for _, _, data in self.graph.in_edges([b], data=True)])
-                    if in_edges == 0:
+                    if in_edges == 0 and b in self.graph:
                         # we use node a to replace node b
                         # link all successors of b to a
                         for _, dst, data in self.graph.out_edges([b], data=True):
@@ -3360,7 +3360,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
                 # next case - if b is directly from function prologue detection, or a basic block that is a successor of
                 # a wrongly identified basic block, we might be totally misdecoding b
-                if b.instruction_addrs[0] not in a.instruction_addrs:
+                if b.instruction_addrs[0] not in a.instruction_addrs and b in self.graph:
                     # use a, truncate b
 
                     new_b_addr = a.addr + a.size  # b starts right after a terminates

{angr-9.2.98 → angr-9.2.100}/angr/analyses/cfg/indirect_jump_resolvers/jumptable.py

@@ -954,7 +954,7 @@ class JumpTableResolver(IndirectJumpResolver):
         # for a typical vtable call (or jump if at the end of a function), the block as two predecessors that form a
         # diamond shape
         curr_node = func.get_node(addr)
-        if curr_node is None:
+        if curr_node is None or curr_node not in func.graph:
             l.debug("Could not find the node %#x in the function transition graph", addr)
             return False, None
         preds = list(func.graph.predecessors(curr_node))

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/clinic.py

@@ -33,6 +33,7 @@ from ...procedures.stubs.UnresolvableJumpTarget import UnresolvableJumpTarget
 from .. import Analysis, register_analysis
 from ..cfg.cfg_base import CFGBase
 from ..reaching_definitions import ReachingDefinitionsAnalysis
+from .return_maker import ReturnMaker
 from .ailgraph_walker import AILGraphWalker, RemoveNodeNotice
 from .optimization_passes import (
     get_default_optimization_passes,
@@ -1054,46 +1055,7 @@ class Clinic(Analysis):
             # unknown calling convention. cannot do much about return expressions.
             return ail_graph
 
-        # Block walker
-
-        def _handle_Return(
-            stmt_idx: int, stmt: ailment.Stmt.Return, block: Optional[ailment.Block]
-        ):  # pylint:disable=unused-argument
-            if (
-                block is not None
-                and not stmt.ret_exprs
-                and self.function.prototype is not None
-                and self.function.prototype.returnty is not None
-                and type(self.function.prototype.returnty) is not SimTypeBottom
-            ):
-                new_stmt = stmt.copy()
-                ret_val = self.function.calling_convention.return_val(self.function.prototype.returnty)
-                if isinstance(ret_val, SimRegArg):
-                    reg = self.project.arch.registers[ret_val.reg_name]
-                    new_stmt.ret_exprs.append(
-                        ailment.Expr.Register(
-                            self._next_atom(),
-                            None,
-                            reg[0],
-                            ret_val.size * self.project.arch.byte_width,
-                            reg_name=self.project.arch.translate_register_name(reg[0], ret_val.size),
-                        )
-                    )
-                else:
-                    l.warning("Unsupported type of return expression %s.", type(ret_val))
-                block.statements[stmt_idx] = new_stmt
-
-        def _handler(block):
-            walker = ailment.AILBlockWalker()
-            # we don't need to handle any statement besides Returns
-            walker.stmt_handlers.clear()
-            walker.expr_handlers.clear()
-            walker.stmt_handlers[ailment.Stmt.Return] = _handle_Return
-            walker.walk(block)
-
-        # Graph walker
-
-        AILGraphWalker(ail_graph, _handler, replace_nodes=True).walk()
+        ReturnMaker(self._ail_manager, self.project.arch, self.function, ail_graph)
 
         return ail_graph
 

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/graph_region.py

@@ -267,7 +267,7 @@ class GraphRegion:
                 for succ in replace_with.successors:
                     if succ not in self.successors:
                         for succ_ in self.successors:
-                            if isinstance(succ_, GraphRegion) and succ_.head == succ:
+                            if isinstance(succ_, GraphRegion) and succ_.addr == succ.addr:
                                 successor_map[succ] = succ_
         if successor_map:
             replace_with_graph_with_successors = networkx.DiGraph()
@@ -364,6 +364,16 @@ class GraphRegion:
                 while isinstance(dst_head, GraphRegion) and dst_head not in sub_graph:
                     dst_head = dst_head.head
 
+                if dst_head not in sub_graph:
+                    # unexpected: structuring failed and resulted in a bad sub_graph
+                    l.warning(
+                        "Node %r for node %r is not found in the sub graph at address %#x. Nodes may go missing.",
+                        dst_head,
+                        dst_in_subgraph,
+                        sub_graph_head.addr,
+                    )
+                    continue
+
                 for src in sub_graph.predecessors(dst_head):
                     graph.add_edge(src, dst)
                 # replace the corresponding nodes in sub_graph_nodes and sub_graph_edges

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/optimization_passes/const_derefs.py

@@ -136,7 +136,8 @@ class BlockWalker(AILBlockWalker):
         if isinstance(expr.addr, Const):
             # *(const_addr)
             # does it belong to a read-only section/segment?
-            if self._addr_belongs_to_got(expr.addr.value) or self._addr_belongs_to_ro_region(expr.addr.value):
+            is_got = self._addr_belongs_to_got(expr.addr.value)
+            if is_got or self._addr_belongs_to_ro_region(expr.addr.value):
                 try:
                     w = self._project.loader.memory.unpack_word(
                         expr.addr.value,
@@ -147,8 +148,9 @@ class BlockWalker(AILBlockWalker):
                     # we don't have enough bytes to read out
                     w = None
                 if w is not None:
-                    # nice! replace it with the actual value
-                    return Const(None, None, w, expr.bits, **expr.tags)
+                    if not (is_got and w == 0):
+                        # nice! replace it with the actual value
+                        return Const(None, None, w, expr.bits, **expr.tags)
         elif isinstance(expr.addr, Load) and expr.addr.bits == self._project.arch.bits:
             if isinstance(expr.addr.addr, Const):
                 # *(*(const_addr))

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/optimization_passes/inlined_string_transformation_simplifier.py

@@ -231,6 +231,9 @@ class InlinedStringTransformationAILEngine(SimEngineLightAILMixin):
             return claripy.BVV(1, 1) if op0.concrete_value >= op1.concrete_value else claripy.BVV(0, 1)
         return None
 
+    def _handle_Call(self, stmt):
+        pass
+
 
 class InlineStringTransformationDescriptor:
     """

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/optimization_passes/ite_region_converter.py

@@ -2,7 +2,7 @@
 import logging
 
 from ailment.statement import ConditionalJump, Assignment, Jump
-from ailment.expression import ITE
+from ailment.expression import ITE, Const
 
 from ....utils.graph import subgraph_between_nodes
 from ..utils import remove_labels, to_ail_supergraph
@@ -146,10 +146,11 @@ class ITERegionConverter(OptimizationPass):
         #
 
         new_region_head = region_head.copy()
+        conditional_jump: ConditionalJump = region_head.statements[-1]
         addr_obj = true_stmt.src if "ins_addr" in true_stmt.src.tags else true_stmt
         ternary_expr = ITE(
             None,
-            region_head.statements[-1].condition,
+            conditional_jump.condition,
             true_stmt.src,
             false_stmt.src,
             ins_addr=addr_obj.ins_addr,
@@ -160,6 +161,13 @@ class ITERegionConverter(OptimizationPass):
         new_assignment.src = ternary_expr
         new_region_head.statements[-1] = new_assignment
 
+        # add a goto statement to the region tail so it can be transformed into a break or other types of control-flow
+        # transitioning statement in the future
+        goto_stmt = Jump(
+            None, Const(None, None, region_tail.addr, self.project.arch.bits), region_tail.idx, **conditional_jump.tags
+        )
+        new_region_head.statements.append(goto_stmt)
+
         #
         # destroy all the old region blocks
         #

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/peephole_optimizations/constant_derefs.py

@@ -24,6 +24,8 @@ class ConstantDereferences(PeepholeOptimizationExprBase):
                     val = self.project.loader.memory.unpack_word(expr.addr.value, size=expr.size)
                 except KeyError:
                     return None
+                if "got" in sec.name and val == 0:
+                    return None
 
                 return Const(None, None, val, expr.bits, **expr.tags, deref_src_addr=expr.addr.value)
 

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/region_simplifiers/expr_folding.py

@@ -4,6 +4,7 @@ from typing import Optional, Any, Dict, Set, Tuple, Iterable, Union, DefaultDict
 
 import ailment
 from ailment import Expression, Block, AILBlockWalker
+from ailment.expression import ITE
 from ailment.statement import Statement, Assignment, Call
 
 from ..sequence_walker import SequenceWalker
@@ -385,11 +386,11 @@ class ExpressionReplacer(AILBlockWalker):
         return None
 
     def _handle_Assignment(self, stmt_idx: int, stmt: Assignment, block: Optional[Block]):
-        # override the base handler and make sure we do not replace .dst with a Call expression
+        # override the base handler and make sure we do not replace .dst with a Call expression or an ITE expression
         changed = False
 
         dst = self._handle_expr(0, stmt.dst, stmt_idx, stmt, block)
-        if dst is not None and dst is not stmt.dst and not isinstance(dst, Call):
+        if dst is not None and dst is not stmt.dst and not isinstance(dst, (Call, ITE)):
             changed = True
         else:
             dst = stmt.dst
@@ -446,7 +447,8 @@ class ExpressionFolder(SequenceWalker):
         for stmt in node.statements:
             if isinstance(stmt, ailment.Stmt.Assignment):
                 if isinstance(stmt.dst, ailment.Expr.Register) and stmt.dst.variable is not None:
-                    if stmt.dst.variable in self._assignments:
+                    unified_var = self._u(stmt.dst.variable)
+                    if unified_var in self._assignments:
                         # remove this statement
                         continue
             if (

angr-9.2.100/angr/analyses/decompiler/return_maker.py

@@ -0,0 +1,71 @@
+from typing import Optional
+import logging
+
+import ailment
+
+from angr.sim_type import SimTypeBottom
+from angr.calling_conventions import SimRegArg
+from .ailgraph_walker import AILGraphWalker
+
+l = logging.getLogger(__name__)
+
+
+class ReturnMaker(AILGraphWalker):
+    """
+    Traverse the AILBlock graph of a function and update .ret_exprs of all return statements.
+    """
+
+    def __init__(self, ail_manager, arch, function, ail_graph):
+        super().__init__(ail_graph, self._handler, replace_nodes=True)
+        self.ail_manager = ail_manager
+        self.arch = arch
+        self.function = function
+        self._new_block = None
+
+        self.walk()
+
+    def _next_atom(self) -> int:
+        return self.ail_manager.next_atom()
+
+    def _handle_Return(
+        self, stmt_idx: int, stmt: ailment.Stmt.Return, block: Optional[ailment.Block]
+    ):  # pylint:disable=unused-argument
+        if (
+            block is not None
+            and not stmt.ret_exprs
+            and self.function.prototype is not None
+            and self.function.prototype.returnty is not None
+            and type(self.function.prototype.returnty) is not SimTypeBottom
+        ):
+            new_stmt = stmt.copy()
+            ret_val = self.function.calling_convention.return_val(self.function.prototype.returnty)
+            if isinstance(ret_val, SimRegArg):
+                reg = self.arch.registers[ret_val.reg_name]
+                new_stmt.ret_exprs.append(
+                    ailment.Expr.Register(
+                        self._next_atom(),
+                        None,
+                        reg[0],
+                        ret_val.size * self.arch.byte_width,
+                        reg_name=self.arch.translate_register_name(reg[0], ret_val.size),
+                    )
+                )
+            else:
+                l.warning("Unsupported type of return expression %s.", type(ret_val))
+            new_statements = block.statements[::]
+            new_statements[stmt_idx] = new_stmt
+            self._new_block = block.copy(statements=new_statements)
+
+    def _handler(self, block):
+        walker = ailment.AILBlockWalker()
+        # we don't need to handle any statement besides Returns
+        walker.stmt_handlers.clear()
+        walker.expr_handlers.clear()
+        walker.stmt_handlers[ailment.Stmt.Return] = self._handle_Return
+
+        self._new_block = None
+        walker.walk(block)
+
+        if self._new_block is not None:
+            return self._new_block
+        return None

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/structured_codegen/c.py

@@ -1408,6 +1408,26 @@ class CUnsupportedStatement(CStatement):
         yield "\n", None
 
 
+class CDirtyStatement(CExpression):
+
+    __slots__ = ("dirty",)
+
+    def __init__(self, dirty, **kwargs):
+        super().__init__(**kwargs)
+        self.dirty = dirty
+
+    @property
+    def type(self):
+        return SimTypeInt().with_arch(self.codegen.project.arch)
+
+    def c_repr_chunks(self, indent=0, asexpr=False):
+        indent_str = self.indent_str(indent=indent)
+
+        yield indent_str, None
+        yield str(self.dirty), None
+        yield "\n", None
+
+
 class CLabel(CStatement):
     """
     Represents a label in C code.
@@ -2414,6 +2434,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             Stmt.ConditionalJump: self._handle_Stmt_ConditionalJump,
             Stmt.Return: self._handle_Stmt_Return,
             Stmt.Label: self._handle_Stmt_Label,
+            Stmt.DirtyStatement: self._handle_Stmt_Dirty,
             # AIL expressions
             Expr.Register: self._handle_Expr_Register,
             Expr.Load: self._handle_Expr_Load,
@@ -3311,6 +3332,9 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         self.map_addr_to_label[(stmt.ins_addr, stmt.block_idx)] = clabel
         return clabel
 
+    def _handle_Stmt_Dirty(self, stmt: Stmt.DirtyStatement, **kwargs):
+        return CDirtyStatement(stmt, codegen=self)
+
     #
     # AIL expression handlers
     #

{angr-9.2.98 → angr-9.2.100}/angr/analyses/decompiler/structuring/phoenix.py

@@ -1131,9 +1131,14 @@ class PhoenixStructurer(StructurerBase):
             return False
         cmp_expr, cmp_lb, cmp_ub = cmp  # pylint:disable=unused-variable
 
-        node_a = next(iter(nn for nn in graph.nodes if nn.addr == target))
+        node_a = next(iter(nn for nn in graph.nodes if nn.addr == target), None)
+        if node_a is None:
+            return False
+
         # the default case
-        node_b_addr = next(iter(t for t in successor_addrs if t != target))
+        node_b_addr = next(iter(t for t in successor_addrs if t != target), None)
+        if node_b_addr is None:
+            return False
 
         # populate whitelist_edges
         for case_node_addr in jump_table.jumptable_entries:

{angr-9.2.98 → angr-9.2.100}/angr/engines/light/engine.py

@@ -1324,9 +1324,12 @@ class SimEngineLightAILMixin(SimEngineLightMixin):
             expr_1 = arg1
 
         try:
-            return expr_0 >> expr_1
+            if isinstance(expr_1, claripy.ast.BV) and expr_1.concrete:
+                return expr_0 >> expr_1.concrete_value
         except TypeError:
-            return ailment.Expr.BinaryOp(expr.idx, "Shr", [expr_0, expr_1], expr.signed, **expr.tags)
+            pass
+
+        return ailment.Expr.BinaryOp(expr.idx, "Shr", [expr_0, expr_1], expr.signed, **expr.tags)
 
     def _ail_handle_Shl(self, expr):
         arg0, arg1 = expr.operands
@@ -1339,9 +1342,12 @@ class SimEngineLightAILMixin(SimEngineLightMixin):
             expr_1 = arg1
 
         try:
-            return expr_0 << expr_1
+            if isinstance(expr_1, claripy.ast.BV) and expr_1.concrete:
+                return expr_0 << expr_1.concrete_value
         except TypeError:
-            return ailment.Expr.BinaryOp(expr.idx, "Shl", [expr_0, expr_1], expr.signed, **expr.tags)
+            pass
+
+        return ailment.Expr.BinaryOp(expr.idx, "Shl", [expr_0, expr_1], expr.signed, **expr.tags)
 
     def _ail_handle_Sal(self, expr):
         return self._ail_handle_Shl(expr)

{angr-9.2.98 → angr-9.2.100}/angr/simos/linux.py

@@ -100,12 +100,18 @@ class SimLinux(SimUserland):
                         _rtld_global_ro.rebased_addr + 0x0D0, 2
                     )  # cpu features: kind = amd
 
-            tls_obj = self.project.loader.tls.new_thread()
-            if isinstance(self.project.arch, ArchAMD64):
-                self.project.loader.memory.pack_word(tls_obj.thread_pointer + 0x28, 0x5F43414E41525900)  # _CANARY\x00
-                self.project.loader.memory.pack_word(tls_obj.thread_pointer + 0x30, 0x5054524755415244)
-            elif isinstance(self.project.arch, ArchX86):
-                self.project.loader.memory.pack_word(tls_obj.thread_pointer + 0x10, self.vsyscall_addr)
+            try:
+                tls_obj = self.project.loader.tls.new_thread()
+            except NotImplementedError:
+                pass
+            else:
+                if isinstance(self.project.arch, ArchAMD64):
+                    self.project.loader.memory.pack_word(
+                        tls_obj.thread_pointer + 0x28, 0x5F43414E41525900
+                    )  # _CANARY\x00
+                    self.project.loader.memory.pack_word(tls_obj.thread_pointer + 0x30, 0x5054524755415244)
+                elif isinstance(self.project.arch, ArchX86):
+                    self.project.loader.memory.pack_word(tls_obj.thread_pointer + 0x10, self.vsyscall_addr)
 
         if isinstance(self.project.arch, ArchARM):
             # https://www.kernel.org/doc/Documentation/arm/kernel_user_helpers.txt
@@ -208,19 +214,20 @@ class SimLinux(SimUserland):
         if not self._is_core and hasattr(state.memory, "allocate_stack_pages"):
             state.memory.allocate_stack_pages(state.solver.eval(state.regs.sp) - 1, 0x20 * 0x1000)
 
-        tls_obj = self.project.loader.tls.threads[thread_idx if thread_idx is not None else 0]
-        if isinstance(state.arch, ArchAMD64):
-            state.regs.fs = tls_obj.user_thread_pointer
-        elif isinstance(state.arch, ArchX86):
-            state.regs.gs = tls_obj.user_thread_pointer >> 16
-        elif isinstance(state.arch, (ArchMIPS32, ArchMIPS64)):
-            state.regs.ulr = tls_obj.user_thread_pointer
-        elif isinstance(state.arch, ArchPPC32):
-            state.regs.r2 = tls_obj.user_thread_pointer
-        elif isinstance(state.arch, ArchPPC64):
-            state.regs.r13 = tls_obj.user_thread_pointer
-        elif isinstance(state.arch, ArchAArch64):
-            state.regs.tpidr_el0 = tls_obj.user_thread_pointer
+        if self.project.loader.tls.threads:
+            tls_obj = self.project.loader.tls.threads[thread_idx if thread_idx is not None else 0]
+            if isinstance(state.arch, ArchAMD64):
+                state.regs.fs = tls_obj.user_thread_pointer
+            elif isinstance(state.arch, ArchX86):
+                state.regs.gs = tls_obj.user_thread_pointer >> 16
+            elif isinstance(state.arch, (ArchMIPS32, ArchMIPS64)):
+                state.regs.ulr = tls_obj.user_thread_pointer
+            elif isinstance(state.arch, ArchPPC32):
+                state.regs.r2 = tls_obj.user_thread_pointer
+            elif isinstance(state.arch, ArchPPC64):
+                state.regs.r13 = tls_obj.user_thread_pointer
+            elif isinstance(state.arch, ArchAArch64):
+                state.regs.tpidr_el0 = tls_obj.user_thread_pointer
 
         if fs is None:
             fs = {}
@@ -397,7 +404,7 @@ class SimLinux(SimUserland):
                         state.registers.store(reg, self.project.loader.main_object.ppc64_initial_rtoc)
                 elif val == "entry":
                     state.registers.store(reg, state.registers.load("pc"))
-                elif val == "thread_pointer":
+                elif val == "thread_pointer" and self.project.loader.tls.threads:
                     state.registers.store(reg, self.project.loader.tls.threads[0].user_thread_pointer)
                 else:
                     _l.warning('Unknown entry point register value indicator "%s"', val)

{angr-9.2.98 → angr-9.2.100/angr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.98
+Version: 9.2.100
 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
@@ -17,13 +17,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.98
-Requires-Dist: archinfo==9.2.98
+Requires-Dist: ailment==9.2.100
+Requires-Dist: archinfo==9.2.100
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.0.post1
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.98
-Requires-Dist: cle==9.2.98
+Requires-Dist: claripy==9.2.100
+Requires-Dist: cle==9.2.100
 Requires-Dist: dpkt
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
@@ -33,7 +33,7 @@ Requires-Dist: protobuf>=3.19.0
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.98
+Requires-Dist: pyvex==9.2.100
 Requires-Dist: rich>=13.1.0
 Requires-Dist: rpyc
 Requires-Dist: sortedcontainers

{angr-9.2.98 → angr-9.2.100}/angr.egg-info/SOURCES.txt

@@ -123,6 +123,7 @@ angr/analyses/decompiler/jumptable_entry_condition_rewriter.py
 angr/analyses/decompiler/redundant_label_remover.py
 angr/analyses/decompiler/region_identifier.py
 angr/analyses/decompiler/region_walker.py
+angr/analyses/decompiler/return_maker.py
 angr/analyses/decompiler/seq_to_blocks.py
 angr/analyses/decompiler/sequence_walker.py
 angr/analyses/decompiler/utils.py

{angr-9.2.98 → angr-9.2.100}/angr.egg-info/requires.txt

@@ -1,12 +1,12 @@
 CppHeaderParser
 GitPython
-ailment==9.2.98
-archinfo==9.2.98
+ailment==9.2.100
+archinfo==9.2.100
 cachetools
 capstone==5.0.0.post1
 cffi>=1.14.0
-claripy==9.2.98
-cle==9.2.98
+claripy==9.2.100
+cle==9.2.100
 dpkt
 itanium-demangler
 mulpyplexer
@@ -16,7 +16,7 @@ protobuf>=3.19.0
 psutil
 pycparser>=2.18
 pyformlang
-pyvex==9.2.98
+pyvex==9.2.100
 rich>=13.1.0
 rpyc
 sortedcontainers

{angr-9.2.98 → angr-9.2.100}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=59", "wheel", "pyvex==9.2.98", "unicorn==2.0.1.post1"]
+requires = ["setuptools>=59", "wheel", "pyvex==9.2.100", "unicorn==2.0.1.post1"]
 build-backend = "setuptools.build_meta"
 
 [tool.black]

{angr-9.2.98 → angr-9.2.100}/setup.cfg

@@ -22,13 +22,13 @@ packages = find:
 install_requires = 
 	CppHeaderParser
 	GitPython
-	ailment==9.2.98
-	archinfo==9.2.98
+	ailment==9.2.100
+	archinfo==9.2.100
 	cachetools
 	capstone==5.0.0.post1
 	cffi>=1.14.0
-	claripy==9.2.98
-	cle==9.2.98
+	claripy==9.2.100
+	cle==9.2.100
 	dpkt
 	itanium-demangler
 	mulpyplexer
@@ -38,7 +38,7 @@ install_requires =
 	psutil
 	pycparser>=2.18
 	pyformlang
-	pyvex==9.2.98
+	pyvex==9.2.100
 	rich>=13.1.0
 	rpyc
 	sortedcontainers