angr 9.2.61__py3-none-manylinux2014_x86_64.whl → 9.2.63__py3-none-manylinux2014_x86_64.whl

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

@@ -196,7 +196,7 @@ class LiveDefinitions:
             ctnt += ", %d tmpdefs" % len(self.tmps)
         return "<%s>" % ctnt
 
-    def copy(self) -> "LiveDefinitions":
+    def copy(self, discard_tmpdefs=False) -> "LiveDefinitions":
         rd = LiveDefinitions(
             self.arch,
             track_tmps=self.track_tmps,
@@ -205,12 +205,12 @@ class LiveDefinitions:
             stack_definitions=self.stack_definitions.copy(),
             heap_definitions=self.heap_definitions.copy(),
             memory_definitions=self.memory_definitions.copy(),
-            tmps=self.tmps.copy(),
+            tmps=self.tmps.copy() if not discard_tmpdefs else None,
             register_uses=self.register_uses.copy(),
             stack_uses=self.stack_uses.copy(),
             heap_uses=self.heap_uses.copy(),
             memory_uses=self.memory_uses.copy(),
-            tmp_uses=self.tmp_uses.copy(),
+            tmp_uses=self.tmp_uses.copy() if not discard_tmpdefs else None,
         )
 
         return rd
@@ -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)
@@ -600,8 +603,15 @@ class LiveDefinitions:
                 size=size,
                 endness=endness,
             )
-        except SimMemoryMissingError:
-            return
+        except SimMemoryMissingError as ex:
+            # load values and stop at the missing location
+            if ex.missing_addr > reg_offset:
+                values: MultiValues = self.register_definitions.load(
+                    reg_offset, size=ex.missing_addr - reg_offset, endness=endness
+                )
+            else:
+                # nothing we can do
+                return
         yield from LiveDefinitions.extract_defs_from_mv(values)
 
     def get_stack_values(self, stack_offset: int, size: int, endness: str) -> Optional[MultiValues]:

angr/knowledge_plugins/key_definitions/liveness.py

@@ -0,0 +1,94 @@
+from typing import DefaultDict, Optional, List, Set, Tuple, TYPE_CHECKING
+
+from collections import defaultdict
+
+from .constants import ObservationPointType, OP_BEFORE, OP_AFTER
+
+if TYPE_CHECKING:
+    from .definition import Definition
+    from angr.code_location import CodeLocation
+
+
+LocationType = Tuple[int, Optional[int], Optional[int]]  # block addr, block ID, stmt ID
+LocationWithPosType = Tuple[
+    int, Optional[int], Optional[int], ObservationPointType
+]  # block addr, block ID, stmt ID, before/after
+
+
+class Liveness:
+    """
+    This class stores liveness information for each definition.
+    """
+
+    def __init__(self):
+        self.curr_live_defs: Set["Definition"] = set()
+        self.curr_loc: Optional[LocationType] = None
+        self.def_to_liveness: DefaultDict["Definition", Set[LocationType]] = defaultdict(set)
+        self.loc_to_defs: DefaultDict[LocationWithPosType, Set["Definition"]] = defaultdict(set)
+        self._node_max_stmt_id: DefaultDict[Tuple[int, Optional[int]], int] = defaultdict(int)
+
+    def add_def(self, d: "Definition", code_loc: "CodeLocation") -> None:
+        loc = (code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx)
+        self.curr_live_defs.add(d)
+        self.def_to_liveness[d].add(loc)
+
+    def kill_def(self, d: "Definition") -> None:
+        self.curr_live_defs.discard(d)
+
+    def complete_loc(self) -> None:
+        if self.curr_loc is not None:
+            for live_def in self.curr_live_defs:
+                self.def_to_liveness[live_def].add(self.curr_loc)
+            self.loc_to_defs[self.curr_loc + (OP_AFTER,)] |= self.curr_live_defs
+
+    def at_new_stmt(self, code_loc: "CodeLocation") -> None:
+        """
+        Only support moving from a statement to the next statement within one basic block.
+        """
+        self.complete_loc()
+        self.curr_loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx
+        if (
+            code_loc.stmt_idx is not None
+            and code_loc.stmt_idx > self._node_max_stmt_id[(code_loc.block_addr, code_loc.block_idx)]
+        ):
+            self._node_max_stmt_id[(code_loc.block_addr, code_loc.block_idx)] = code_loc.stmt_idx
+
+    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: List["CodeLocation"]) -> None:
+        """
+        Only support moving to a new block from one or more blocks.
+        """
+        loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx
+        key = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, OP_BEFORE
+        for pred_codeloc in pred_codelocs:
+            if pred_codeloc.stmt_idx is None:
+                # external code location
+                pred_max_stmt_id = None
+            else:
+                pred_max_stmt_id = self._node_max_stmt_id[(pred_codeloc.block_addr, pred_codeloc.block_idx)]
+            pred_key = pred_codeloc.block_addr, pred_codeloc.block_idx, pred_max_stmt_id, OP_AFTER
+            pred_defs = self.loc_to_defs[pred_key]
+            for pred_def in pred_defs:
+                self.def_to_liveness[pred_def].add(loc)
+            self.loc_to_defs[key] |= pred_defs
+
+        self.curr_live_defs = set(self.loc_to_defs[key])
+        self.curr_loc = loc
+
+    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
+        if op == OP_BEFORE:
+            if code_loc.stmt_idx != 0:
+                loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx - 1, OP_AFTER
+            else:
+                loc = code_loc.block_addr, code_loc.block_idx, 0, OP_BEFORE
+        else:
+            loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, OP_AFTER
+        return set() if loc not in self.loc_to_defs else self.loc_to_defs[loc]
+
+    def copy(self) -> "Liveness":
+        o = Liveness()
+        o.curr_live_defs = self.curr_live_defs.copy()
+        o.curr_loc = self.curr_loc
+        o.def_to_liveness = self.def_to_liveness.copy()
+        o.loc_to_defs = self.loc_to_defs.copy()
+        o._node_max_stmt_id = self._node_max_stmt_id.copy()
+        return o

angr/knowledge_plugins/key_definitions/rd_model.py

@@ -1,13 +1,14 @@
-from typing import Dict, Tuple, Set, Union, Optional, TYPE_CHECKING, overload
-
-from angr.knowledge_plugins.key_definitions.constants import ObservationPointType
-from angr.code_location import CodeLocation
+from typing import Dict, List, Tuple, Set, Union, Optional, TYPE_CHECKING, overload
 
+from .atoms import Atom, Register, MemoryLocation, SpOffset
 from .uses import Uses
 from .live_definitions import LiveDefinitions
+from .liveness import Liveness
+from .constants import OP_BEFORE, ObservationPointType
 
 if TYPE_CHECKING:
     from angr.knowledge_plugins.key_definitions.definition import Definition
+    from angr.code_location import CodeLocation
 
 
 # TODO: Make ReachingDefinitionsModel serializable
@@ -23,6 +24,7 @@ class ReachingDefinitionsModel:
         ] = {}
         self.all_definitions: Set["Definition"] = set()
         self.all_uses = Uses()
+        self.liveness = Liveness()
 
     def __repr__(self):
         return "<RDModel{} with {} observations>".format(
@@ -30,11 +32,70 @@ class ReachingDefinitionsModel:
             len(self.observed_results),
         )
 
+    def add_def(self, d: "Definition", codeloc: "CodeLocation") -> None:
+        self.liveness.add_def(d, codeloc)
+
+    def kill_def(self, d: "Definition") -> None:
+        self.liveness.kill_def(d)
+
+    def at_new_stmt(self, codeloc: "CodeLocation") -> None:
+        self.liveness.at_new_stmt(codeloc)
+
+    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: List["CodeLocation"]) -> None:
+        self.liveness.at_new_block(code_loc, pred_codelocs)
+
+    def complete_loc(self) -> None:
+        self.liveness.complete_loc()
+
+    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
+        return self.liveness.find_defs_at(code_loc, op=op)
+
+    def get_defs(self, atom: Atom, code_loc: "CodeLocation", op: int) -> Set["Definition"]:
+        all_defs = self.liveness.find_defs_at(code_loc, op=op)
+        defs = None
+        if isinstance(atom, Register):
+            defs = {
+                d
+                for d in all_defs
+                if isinstance(d.atom, Register)
+                and d.atom.reg_offset <= atom.reg_offset < d.atom.reg_offset + d.atom.size
+            }
+        elif isinstance(atom, MemoryLocation):
+            if isinstance(atom.addr, int):
+                defs = {
+                    d
+                    for d in all_defs
+                    if isinstance(d.atom, MemoryLocation)
+                    and isinstance(d.atom.addr, int)
+                    and (
+                        d.atom.addr <= atom.addr < d.atom.addr + d.size
+                        or atom.addr <= d.atom.addr < atom.addr + atom.size
+                    )
+                }
+            elif isinstance(atom.addr, SpOffset):
+                defs = {
+                    d
+                    for d in all_defs
+                    if isinstance(d.atom, MemoryLocation)
+                    and isinstance(d.atom.addr, SpOffset)
+                    and (
+                        d.atom.addr.offset <= atom.addr.offset < d.atom.addr.offset + d.size
+                        or atom.addr.offset <= d.atom.addr.offset < atom.addr.offset + atom.size
+                    )
+                }
+
+        if defs is None:
+            # unsupported for now
+            defs = set()
+
+        return defs
+
     def copy(self) -> "ReachingDefinitionsModel":
         new = ReachingDefinitionsModel(self.func_addr)
         new.observed_results = self.observed_results.copy()
         new.all_definitions = self.all_definitions.copy()
         new.all_uses = self.all_uses.copy()
+        new.liveness = self.liveness.copy()
         return new
 
     def merge(self, model: "ReachingDefinitionsModel"):
@@ -47,9 +108,10 @@ class ReachingDefinitionsModel:
                     self.observed_results[k] = merged
         self.all_definitions.union(model.all_definitions)
         self.all_uses.merge(model.all_uses)
+        # TODO: Merge self.liveness
 
     def get_observation_by_insn(
-        self, ins_addr: Union[int, CodeLocation], kind: ObservationPointType
+        self, ins_addr: Union[int, "CodeLocation"], kind: ObservationPointType
     ) -> Optional[LiveDefinitions]:
         if isinstance(ins_addr, int):
             return self.observed_results.get(("insn", ins_addr, kind), None)
@@ -58,15 +120,21 @@ 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]:
+    def get_observation_by_stmt(self, codeloc: "CodeLocation", kind: ObservationPointType) -> Optional[LiveDefinitions]:
         ...
 
     @overload
@@ -88,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/propagations/states.py

@@ -235,6 +235,9 @@ class PropagatorState:
 
         return state, merge_occurred
 
+    def init_replacements(self):
+        self._replacements = defaultdict(dict)
+
     def add_replacement(self, codeloc, old: CodeLocation, new):
         """
         Add a replacement record: Replacing expression `old` with `new` at program location `codeloc`.

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/state_plugins/unicorn_engine.py

@@ -481,6 +481,7 @@ def _load_native():
             ctypes.c_uint64,
             ctypes.c_uint32,
             ctypes.c_uint64,
+            ctypes.c_uint64,
             ctypes.c_uint32,
             ctypes.c_uint64,
         )
@@ -1273,7 +1274,14 @@ class Unicorn(SimStatePlugin):
                     )
 
             _UC_NATIVE.set_cgc_syscall_details(
-                self._uc_state, 2, cgc_transmit_addr, 3, cgc_receive_addr, 7, cgc_random_addr
+                self._uc_state,
+                2,
+                cgc_transmit_addr,
+                3,
+                cgc_receive_addr,
+                self.state.cgc.max_receive_size,
+                7,
+                cgc_random_addr,
             )
 
         # set memory map callback so we can call it explicitly

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/utils/timing.py

@@ -1,14 +1,16 @@
-# pylint:disable=no-member
+# pylint:disable=no-member,global-statement
+import os
 import time
 from functools import wraps
 from collections import defaultdict
 
-TIMING = False
-PRINT = False
+TIMING = os.environ.get("TIMING", "").lower() not in {"", "no", "0", "false"}
+PRINT = os.environ.get("PRINT", "").lower() not in {"", "no", "0", "false"}
 TIME_DISTRIBUTION = False
 
 total_time = defaultdict(float)
 time_distribution = defaultdict(list)
+depth = 0
 
 
 def timethis(func):
@@ -19,18 +21,23 @@ def timethis(func):
             def _t():
                 return time.perf_counter_ns() / 1000000
 
+            global depth
+            depth += 1
+
             start = _t()
             r = func(*args, **kwargs)
             millisec = _t() - start
             sec = millisec / 1000
             if PRINT:
+                indent = " " * ((depth - 1) * 2)
                 if sec > 1.0:
-                    print(f"[timing] {func.__name__} took {sec:f} seconds ({millisec:f} milliseconds).")
+                    print(f"[timing] {indent}{func.__name__} took {sec:f} seconds ({millisec:f} milliseconds).")
                 else:
-                    print(f"[timing] {func.__name__} took {millisec:f} milliseconds.")
+                    print(f"[timing] {indent}{func.__name__} took {millisec:f} milliseconds.")
             total_time[func] += millisec
             if TIME_DISTRIBUTION:
                 time_distribution[func].append(millisec)
+            depth -= 1
             return r
         else:
             return func(*args, **kwargs)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.61
+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.61)
-Requires-Dist: archinfo (==9.2.61)
+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.61)
-Requires-Dist: cle (==9.2.61)
+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.61)
-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'