angr 9.2.121__py3-none-win_amd64.whl → 9.2.123__py3-none-win_amd64.whl

angr/engines/vex/heavy/concretizers.py

@@ -23,7 +23,7 @@ def concretize_2xm1(state, args):
     # 2xm1(x) = 2 ** x - 1. Concretize 2**x part alone since only that cannot be modelled in Z3.
     arg_x = state.solver.eval(args[1])
     if -1 <= arg_x <= 1:
-        return state.solver.FPV(math.pow(2, arg_x) - 1, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.pow(2, arg_x) - 1, claripy.FSORT_DOUBLE)
 
     # If x is outside range [-1.0, 1.0], result is undefined. We return argument itself as observed on an Intel CPU.
     return args[1]
@@ -31,26 +31,26 @@ def concretize_2xm1(state, args):
 
 def concretize_abs_float64(state, args):
     arg_val = state.solver.eval(args[0])
-    return state.solver.FPV(abs(arg_val), args[0].sort)
+    return claripy.FPV(abs(arg_val), args[0].sort)
 
 
 def concretize_add_float64(state, args):
     arg0 = state.solver.eval(args[1])
     arg1 = state.solver.eval(args[2])
-    return state.solver.FPV(arg0 + arg1, claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg0 + arg1, claripy.FSORT_DOUBLE)
 
 
 def concretize_add32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 + fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 + fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_add64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 + fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 + fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -71,18 +71,18 @@ def concretize_divf64(state, args):
     arg1 = state.solver.eval(args[1])
     arg2 = state.solver.eval(args[2])
     if arg2 == 0:
-        return state.solver.FPV(math.inf, args[1].sort)
+        return claripy.FPV(math.inf, args[1].sort)
 
-    return state.solver.FPV(arg1 / arg2, args[1].sort)
+    return claripy.FPV(arg1 / arg2, args[1].sort)
 
 
 def concretize_div32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
     if fp_arg1 == 0:
-        result = state.solver.FPV(math.inf, claripy.FSORT_FLOAT).raw_to_bv()
+        result = claripy.FPV(math.inf, claripy.FSORT_FLOAT).raw_to_bv()
     else:
-        result = state.solver.FPV(fp_arg0 / fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+        result = claripy.FPV(fp_arg0 / fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
 
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
@@ -91,21 +91,21 @@ def concretize_div64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
     if fp_arg1 == 0:
-        result = state.solver.FPV(math.inf, claripy.FSORT_DOUBLE).raw_to_bv()
+        result = claripy.FPV(math.inf, claripy.FSORT_DOUBLE).raw_to_bv()
     else:
-        result = state.solver.FPV(fp_arg0 / fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+        result = claripy.FPV(fp_arg0 / fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
 
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_float32_to_float64(state, args):
     arg0 = state.solver.eval(args[0])
-    return state.solver.FPV(arg0, claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg0, claripy.FSORT_DOUBLE)
 
 
 def concretize_float64_to_float32(state, args):
     arg = state.solver.eval(args[1])
-    return state.solver.FPV(arg, claripy.FSORT_FLOAT)
+    return claripy.FPV(arg, claripy.FSORT_FLOAT)
 
 
 def concretize_float64_to_int64s(state, args):
@@ -127,20 +127,20 @@ def concretize_int64s_to_float64(state, args):
 def concretize_mulf64(state, args):
     arg1 = state.solver.eval(args[1])
     arg2 = state.solver.eval(args[2])
-    return state.solver.FPV(arg1 / arg2, args[1].sort)
+    return claripy.FPV(arg1 / arg2, args[1].sort)
 
 
 def concretize_mul32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 * fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 * fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_mul64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 * fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 * fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -149,24 +149,24 @@ def concretize_fscale(state, args):
     arg_x = state.solver.eval(args[1])
     arg_y = math.floor(state.solver.eval(args[2]))
     if math.isnan(arg_x) or math.isnan(arg_y):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs(arg_x) == math.inf and arg_y == -1 * math.inf:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if arg_x == 0.0 and arg_y == math.inf:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(arg_x * math.pow(2, arg_y), claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg_x * math.pow(2, arg_y), claripy.FSORT_DOUBLE)
 
 
 def concretize_fsqrt(state, args):
     # Concretize floating point square root. Z3 does support square root but unsure if that includes floating point
     arg_1 = state.solver.eval(args[1])
     if arg_1 < 0 or math.isnan(arg_1):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(math.sqrt(arg_1), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.sqrt(arg_1), claripy.FSORT_DOUBLE)
 
 
 def concretize_prem(state, args):
@@ -175,7 +175,7 @@ def concretize_prem(state, args):
     dividend = state.solver.eval(args[1])
     divisor = state.solver.eval(args[2])
     if math.isnan(dividend) or math.isnan(divisor) or abs(dividend) == math.inf or divisor == 0.0:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs(divisor) == math.inf or dividend == 0.0:
         return args[1]
@@ -194,9 +194,9 @@ def concretize_prem(state, args):
 
     if result == 0.0 and math.copysign(1.0, dividend) < 0:
         # According to Intel manual, if result is 0, its sign should be same as that of dividend.
-        return state.solver.FPV(-0.0, claripy.FSORT_DOUBLE)
+        return claripy.FPV(-0.0, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(result, claripy.FSORT_DOUBLE)
+    return claripy.FPV(result, claripy.FSORT_DOUBLE)
 
 
 def concretize_prem_flags(state, args):
@@ -241,20 +241,20 @@ def concretize_prem_flags(state, args):
 
 
 def concretize_reinterp_float64_as_int64(state, args):
-    return state.solver.FPV(state.solver.eval(args[0]), args[0].sort).raw_to_bv()
+    return claripy.FPV(state.solver.eval(args[0]), args[0].sort).raw_to_bv()
 
 
 def concretize_sub32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 - fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 - fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_sub64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 - fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 - fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -265,18 +265,18 @@ def concretize_trig_cos(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.cos(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.cos(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_trig_sin(state, args):
@@ -286,18 +286,18 @@ def concretize_trig_sin(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.sin(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.sin(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_trig_tan(state, args):
@@ -307,18 +307,18 @@ def concretize_trig_tan(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.tan(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.tan(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_yl2x(state, args):
@@ -330,35 +330,35 @@ def concretize_yl2x(state, args):
     arg_y = state.solver.eval(args[1])
     if arg_x < 0:
         # TODO: Indicate floating-point invalid-operation exception
-        return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+        return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
     if arg_x == 0:
         if abs(arg_y) == math.inf:
-            return state.solver.FPV(-1 * arg_y, claripy.FSORT_DOUBLE)
+            return claripy.FPV(-1 * arg_y, claripy.FSORT_DOUBLE)
         if arg_y == 0:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
         # TODO: Indicate floating-point zero-division exception
-        return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+        return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
     if arg_x == 1:
         if abs(arg_y) == math.inf:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
         # TODO: How to distinguish between +0 and -0?
-        return state.solver.FPV(0, claripy.FSORT_DOUBLE)
+        return claripy.FPV(0, claripy.FSORT_DOUBLE)
 
     if arg_x == math.inf:
         if arg_y == 0:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
         if arg_y < 0:
-            return state.solver.FPV(-1 * math.inf, claripy.FSORT_DOUBLE)
+            return claripy.FPV(-1 * math.inf, claripy.FSORT_DOUBLE)
 
-        return state.solver.FPV(math.inf, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.inf, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(arg_y * math.log2(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg_y * math.log2(arg_x), claripy.FSORT_DOUBLE)
 
 
 concretizers = {

angr/engines/vex/heavy/dirty.py

@@ -19,12 +19,12 @@ l = logging.getLogger(name=__name__)
 # http://www-inteng.fnal.gov/Integrated_Eng/GoodwinDocs/pdf/Sys%20docs/PowerPC/PowerPC%20Elapsed%20Time.pdf
 # and
 # http://www.cap-lore.com/code/TB/
-def ppcg_dirtyhelper_MFTB(state):
+def ppcg_dirtyhelper_MFTB(state):  # pylint:disable=unused-argument
     # TODO: This is an incorrect implementation. Fix it later!
     return claripy.BVV(0x200, 64), []
 
 
-def ppc32g_dirtyhelper_MFSPR_287(state):
+def ppc32g_dirtyhelper_MFSPR_287(state):  # pylint:disable=unused-argument
     return claripy.BVV(0x200, 32), []
 
 
@@ -119,8 +119,8 @@ EmWarn_S390X_fpext_rounding = 10
 EmWarn_S390X_invalid_rounding = 11
 
 
-def amd64g_check_ldmxcsr(state, mxcsr):
-    rmode = state.solver.LShR(mxcsr, 13) & 3
+def amd64g_check_ldmxcsr(state, mxcsr):  # pylint:disable=unused-argument
+    rmode = claripy.LShR(mxcsr, 13) & 3
 
     ew = claripy.If(
         (mxcsr & 0x1F80) != 0x1F80,

angr/procedures/java_lang/getsimplename.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
+
 import logging
 
+import claripy
+
 from angr.procedures.java import JavaSimProcedure
 from angr.engines.soot.values.strref import SimSootValue_StringRef
 
@@ -12,4 +15,4 @@ class GetSimpleName(JavaSimProcedure):
 
     def run(self, this):  # pylint: disable=arguments-differ
         class_simple_name = this.type.split(".")[-1]
-        return SimSootValue_StringRef.new_string(self.state, self.state.solver.StringV(class_simple_name))
+        return SimSootValue_StringRef.new_string(self.state, claripy.StringV(class_simple_name))

angr/procedures/linux_kernel/iovec.py

@@ -1,4 +1,7 @@
 from __future__ import annotations
+
+import claripy
+
 import angr
 from angr.procedures.posix.read import read
 from angr.procedures.posix.write import write
@@ -24,7 +27,7 @@ class readv(angr.SimProcedure):
         res = 0
         for element in self.state.mem[iovec].struct.iovec.array(iovcnt).resolved:
             tmpres = self.inline_call(read, fd, element.iov_base, element.iov_len).ret_expr
-            if self.state.solver.is_true(self.state.solver.SLT(tmpres, 0)):
+            if self.state.solver.is_true(claripy.SLT(tmpres, 0)):
                 return tmpres
 
         return res
@@ -38,7 +41,7 @@ class writev(angr.SimProcedure):
         res = 0
         for element in self.state.mem[iovec].struct.iovec.array(iovcnt).resolved:
             tmpres = self.inline_call(write, fd, element.iov_base, element.iov_len).ret_expr
-            if self.state.solver.is_true(self.state.solver.SLT(tmpres, 0)):
+            if self.state.solver.is_true(claripy.SLT(tmpres, 0)):
                 return tmpres
 
         return res

angr/sim_type.py

@@ -1,4 +1,4 @@
-# pylint:disable=abstract-method,line-too-long,missing-class-docstring,wrong-import-position
+# pylint:disable=abstract-method,line-too-long,missing-class-docstring,wrong-import-position,too-many-positional-arguments
 from __future__ import annotations
 
 import contextlib
@@ -19,7 +19,6 @@ from angr.sim_state import SimState
 from .misc.ux import deprecated
 
 if TYPE_CHECKING:
-    import pycparser
     from angr.procedures.definitions import SimTypeCollection
     from angr.storage.memory_mixins import _Coerce
 
@@ -120,7 +119,8 @@ class SimType:
         if self._arch is None:
             raise ValueError("Can't tell my alignment without an arch!")
         if self.size is None:
-            raise AngrTypeError("Cannot compute the alignment of a type with no size")
+            l.debug("The size of the type %r is unknown; assuming word size of the arch.", self)
+            return self._arch.bytes
         return self.size // self._arch.byte_width
 
     def with_arch(self, arch: Arch | None):
@@ -214,7 +214,9 @@ class TypeRef(SimType):
         self.type = self.type.with_arch(arch)
         return self
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if not full:
             if name is not None:
                 return f"{self.name} {name}"
@@ -265,7 +267,9 @@ class SimTypeBottom(SimType):
     def __repr__(self):
         return self.label or "BOT"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if name is None:
             return "int"
         return f'{"int" if self.label is None else self.label} {name}'
@@ -408,7 +412,9 @@ class SimTypeInt(SimTypeReg):
         super().__init__(None, label=label)
         self.signed = signed
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         out = self._base_name
         if not self.signed:
             out = "unsigned " + out
@@ -736,7 +742,9 @@ class SimTypePointer(SimTypeReg):
     def __repr__(self):
         return f"{self.pts_to}*"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         # if pts_to is SimTypeBottom, we return a void*
         if isinstance(self.pts_to, SimTypeBottom):
             out = "void*"
@@ -803,7 +811,9 @@ class SimTypeReference(SimTypeReg):
     def __repr__(self):
         return f"{self.refs}&"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         name = "&" if name is None else f"&{name}"
         return self.refs.c_repr(name, full, memo, indent)
 
@@ -869,7 +879,9 @@ class SimTypeArray(SimType):
     def __repr__(self):
         return "{}[{}]".format(self.elem_type, "" if self.length is None else self.length)
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if name is None:
             return repr(self)
 
@@ -958,7 +970,9 @@ class SimTypeString(NamedTypeMixin, SimType):
     def __repr__(self):
         return "string_t"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if name is None:
             return repr(self)
 
@@ -1034,7 +1048,9 @@ class SimTypeWString(NamedTypeMixin, SimType):
     def __repr__(self):
         return "wstring_t"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if name is None:
             return repr(self)
 
@@ -1339,15 +1355,27 @@ class SimTypeDouble(SimTypeFloat):
 
 
 class SimStruct(NamedTypeMixin, SimType):
-    _fields = ("name", "fields")
+    _fields = ("name", "fields", "anonymous")
 
-    def __init__(self, fields: dict[str, SimType] | OrderedDict[str, SimType], name=None, pack=False, align=None):
+    def __init__(
+        self,
+        fields: dict[str, SimType] | OrderedDict[str, SimType],
+        name=None,
+        pack=False,
+        align=None,
+        anonymous: bool = False,
+    ):
         super().__init__(None, name="<anon>" if name is None else name)
 
         self._pack = pack
         self._align = align
+        self.anonymous = anonymous
         self.fields: OrderedDict[str, SimType] = OrderedDict(fields)
 
+        # FIXME: Hack for supporting win32 struct definitions
+        if self.name == "_Anonymous_e__Struct":
+            self.anonymous = True
+
         self._arch_memo = {}
 
     @property
@@ -1363,7 +1391,7 @@ class SimStruct(NamedTypeMixin, SimType):
         offset_so_far = 0
         for name, ty in self.fields.items():
             if ty.size is None:
-                l.warning(
+                l.debug(
                     "Found a bottom field in struct %s. Ignore and increment the offset using the default "
                     "element size.",
                     self.name,
@@ -1418,7 +1446,9 @@ class SimStruct(NamedTypeMixin, SimType):
     def __repr__(self):
         return f"struct {self.name}"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if not full or (memo is not None and self in memo):
             return super().c_repr(name, full, memo, indent)
 
@@ -1599,7 +1629,9 @@ class SimUnion(NamedTypeMixin, SimType):
 
     @property
     def size(self):
-        return max(ty.size for ty in self.members.values() if not isinstance(ty, SimTypeBottom))
+        member_sizes = [ty.size for ty in self.members.values() if not isinstance(ty, SimTypeBottom)]
+        # fall back to word size in case all members are SimTypeBottom
+        return max(member_sizes) if member_sizes else self._arch.bytes
 
     @property
     def alignment(self):
@@ -1632,7 +1664,9 @@ class SimUnion(NamedTypeMixin, SimType):
             self.name, "\n\t".join(f"{name} {ty!s};" for name, ty in self.members.items())
         )
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ):  # pylint: disable=unused-argument
         if not full or (memo is not None and self in memo):
             return super().c_repr(name, full, memo, indent)
 
@@ -1875,7 +1909,9 @@ class SimTypeRef(SimType):
     def set_size(self, v: int):
         self._size = v
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0) -> str:
+    def c_repr(
+        self, name=None, full=0, memo=None, indent=0, name_parens: bool = True
+    ) -> str:  # pylint: disable=unused-argument
         prefix = "unknown"
         if self.original_type is SimStruct:
             prefix = "struct"
@@ -3537,7 +3573,8 @@ def dereference_simtype(
             return memo[t.name]
 
         real_type = t.copy()
-        memo[t.name] = real_type
+        if not t.anonymous:
+            memo[t.name] = real_type
         fields = OrderedDict((k, dereference_simtype(v, type_collections, memo=memo)) for k, v in t.fields.items())
         real_type.fields = fields
     elif isinstance(t, SimTypePointer):

{angr-9.2.121.dist-info → angr-9.2.123.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.121
+Version: 9.2.123
 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
@@ -10,18 +10,19 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.121
-Requires-Dist: archinfo==9.2.121
+Requires-Dist: ailment==9.2.123
+Requires-Dist: archinfo==9.2.123
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.121
-Requires-Dist: cle==9.2.121
+Requires-Dist: claripy==9.2.123
+Requires-Dist: cle==9.2.123
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
 Requires-Dist: nampa
@@ -30,7 +31,7 @@ Requires-Dist: protobuf>=5.28.2
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.121
+Requires-Dist: pyvex==9.2.123
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy