angr 9.2.148__py3-none-win_amd64.whl → 9.2.149__py3-none-win_amd64.whl

angr/knowledge_plugins/functions/function.py

@@ -26,6 +26,7 @@ from angr.calling_conventions import DEFAULT_CC, default_cc
 from angr.sim_type import SimTypeFunction, parse_defns
 from angr.calling_conventions import SimCC
 from angr.project import Project
+from angr.utils.library import get_cpp_function_name
 from .function_parser import FunctionParser
 
 l = logging.getLogger(name=__name__)
@@ -1582,11 +1583,78 @@ class Function(Serializable):
         # int, long
         return addr
 
+    def is_rust_function(self):
+        ast = pydemumble.demangle(self.name)
+        if ast:
+            nodes = ast.split("::")
+            if len(nodes) >= 2:
+                last_node = nodes[-1]
+                return (
+                    len(last_node) == 17
+                    and last_node.startswith("h")
+                    and all(c in "0123456789abcdef" for c in last_node[1:])
+                )
+        return False
+
+    @staticmethod
+    def _rust_fmt_node(node):
+        result = []
+        rest = node
+        if rest.startswith("_$"):
+            rest = rest[1:]
+        while True:
+            if rest.startswith("."):
+                if len(rest) > 1 and rest[1] == ".":
+                    result.append("::")
+                    rest = rest[2:]
+                else:
+                    result.append(".")
+                    rest = rest[1:]
+            elif rest.startswith("$"):
+                if "$" in rest[1:]:
+                    escape, rest = rest[1:].split("$", 1)
+                else:
+                    break
+
+                unescaped = {"SP": "@", "BP": "*", "RF": "&", "LT": "<", "GT": ">", "LP": "(", "RP": ")", "C": ","}.get(
+                    escape
+                )
+
+                if unescaped is None and escape.startswith("u"):
+                    digits = escape[1:]
+                    if all(c in "0123456789abcdef" for c in digits):
+                        c = chr(int(digits, 16))
+                        if ord(c) >= 32 and ord(c) != 127:
+                            result.append(c)
+                            continue
+                if unescaped:
+                    result.append(unescaped)
+                else:
+                    break
+            else:
+                idx = min((rest.find(c) for c in "$." if c in rest), default=len(rest))
+                result.append(rest[:idx])
+                rest = rest[idx:]
+                if not rest:
+                    break
+        return "".join(result)
+
     @property
     def demangled_name(self):
         ast = pydemumble.demangle(self.name)
+        if self.is_rust_function():
+            nodes = ast.split("::")[:-1]
+            ast = "::".join([Function._rust_fmt_node(node) for node in nodes])
         return ast if ast else self.name
 
+    @property
+    def short_name(self):
+        if self.is_rust_function():
+            ast = pydemumble.demangle(self.name)
+            return Function._rust_fmt_node(ast.split("::")[-2])
+        func_name = get_cpp_function_name(self.demangled_name, specialized=False, qualified=True)
+        return func_name.split("::")[-1]
+
     def get_unambiguous_name(self, display_name: str | None = None) -> str:
         """
         Get a disambiguated function name.

angr/knowledge_plugins/propagations/states.py

@@ -527,12 +527,14 @@ class Equivalence:
         "atom0",
         "atom1",
         "codeloc",
+        "is_weakassignment",
     )
 
-    def __init__(self, codeloc, atom0, atom1):
+    def __init__(self, codeloc, atom0, atom1, is_weakassignment: bool = False):
         self.codeloc = codeloc
         self.atom0 = atom0
         self.atom1 = atom1
+        self.is_weakassignment = is_weakassignment
 
     def __repr__(self):
         return f"<Eq@{self.codeloc!r}: {self.atom0!r}=={self.atom1!r}>"
@@ -543,7 +545,8 @@ class Equivalence:
             and other.codeloc == self.codeloc
             and other.atom0 == self.atom0
             and other.atom1 == self.atom1
+            and other.is_weakassignment == self.is_weakassignment
         )
 
     def __hash__(self):
-        return hash((Equivalence, self.codeloc, self.atom0, self.atom1))
+        return hash((Equivalence, self.codeloc, self.atom0, self.atom1, self.is_weakassignment))

angr/knowledge_plugins/variables/variable_manager.py

@@ -934,7 +934,7 @@ class VariableManagerInternal(Serializable):
 
         for var in chain(sorted_stack_variables, sorted_reg_variables, phi_only_vars):
             idx = next(var_ctr)
-            if var.name is not None and not reset:
+            if var.name is not None and var.name != var.ident and not reset:
                 continue
             if isinstance(var, (SimStackVariable, SimRegisterVariable)):
                 var.name = f"v{idx}"
@@ -946,7 +946,7 @@ class VariableManagerInternal(Serializable):
         arg_vars = sorted(arg_vars, key=lambda v: _id_from_varident(v.ident))
         for var in arg_vars:
             idx = next(arg_ctr)
-            if var.name is not None and not reset:
+            if var.name is not None and var.name != var.ident and not reset:
                 continue
             var.name = arg_names[idx] if arg_names else f"a{idx}"
             var._hash = None
@@ -1040,7 +1040,7 @@ class VariableManagerInternal(Serializable):
         reg_vars: set[SimRegisterVariable] = set()
 
         # unify stack variables based on their locations
-        for v in self.get_variables():
+        for v in self.get_variables() + list(self._phi_variables):
             if v in self._variables_to_unified_variables:
                 # do not unify twice
                 continue

angr/procedures/definitions/__init__.py

@@ -397,7 +397,7 @@ class SimCppLibrary(SimLibrary):
         stub = super().get_stub(demangled_name, arch)
         # try to determine a prototype from the function name if possible
         if demangled_name != name:
-            # itanium-mangled function name
+            # mangled function name
             stub.prototype = self._proto_from_demangled_name(demangled_name)
             if stub.prototype is not None:
                 stub.prototype = stub.prototype.with_arch(arch)

angr/procedures/definitions/types_stl.py

@@ -0,0 +1,22 @@
+# pylint:disable=line-too-long
+from __future__ import annotations
+from collections import OrderedDict
+
+from angr.procedures.definitions import SimTypeCollection
+from angr.sim_type import SimCppClass, SimTypePointer, SimTypeChar, SimTypeInt
+
+typelib = SimTypeCollection()
+typelib.set_names("cpp::std")
+typelib.types = {
+    "class std::basic_string<char, struct std::char_traits<char>, class std::allocator<char>>": SimCppClass(
+        unique_name="class std::basic_string<char, struct std::char_traits<char>, class std::allocator<char>>",
+        name="std::string",
+        members=OrderedDict(
+            [
+                ("m_data", SimTypePointer(SimTypeChar())),
+                ("m_size", SimTypeInt(signed=False)),
+                ("m_capacity", SimTypeInt(signed=False)),
+            ]
+        ),
+    ),
+}