angr 9.2.174__cp310-abi3-win_amd64.whl → 9.2.176__cp310-abi3-win_amd64.whl

angr/analyses/typehoon/simple_solver.py

@@ -179,8 +179,11 @@ class RecursiveRefNode(SketchNodeBase):
     This is equivalent to sketches.LabelNode in the reference implementation of retypd.
     """
 
-    def __init__(self, target: DerivedTypeVariable):
-        self.target: DerivedTypeVariable = target
+    def __init__(self, target: TypeVariable | DerivedTypeVariable):
+        self.target: TypeVariable | DerivedTypeVariable = target
+
+    def __repr__(self):
+        return f"Ref({self.target})"
 
     def __hash__(self):
         return hash((RecursiveRefNode, self.target))
@@ -265,7 +268,7 @@ class Sketch:
             basetype = supertype
             assert basetype.size is not None
             max_size = self.solver.stackvar_max_sizes.get(subtype, None)
-            if max_size not in {0, None} and max_size // basetype.size > 0:  # type: ignore
+            if max_size not in {0, None} and basetype.size > 0 and max_size // basetype.size > 0:  # type: ignore
                 supertype = Array(element=basetype, count=max_size // basetype.size)  # type: ignore
 
         if SimpleSolver._typevar_inside_set(subtype, PRIMITIVE_TYPES) and not SimpleSolver._typevar_inside_set(
@@ -328,7 +331,7 @@ class ConstraintGraphNode:
 
     def __init__(
         self,
-        typevar: TypeVariable | DerivedTypeVariable,
+        typevar: TypeVariable | DerivedTypeVariable | TypeConstant,
         variance: Variance,
         tag: ConstraintGraphTag,
         forgotten: FORGOTTEN,
@@ -512,10 +515,21 @@ class SimpleSolver:
                     typevars.add(repl)
 
         constraints = set()
+
         for tv in typevars:
             if tv in self._constraints:
                 constraints |= self._constraints[tv]
 
+        equiv_classes, sketches = self.infer_shapes(typevars, constraints)
+
+        # only create sketches for the type variables representing their equivalence classes
+        tv_to_reptvs = {}
+        for tv_or_dtv, reptv in equiv_classes.items():
+            if not isinstance(tv_or_dtv, DerivedTypeVariable) and tv_or_dtv is not reptv:
+                tv_to_reptvs[tv_or_dtv] = reptv
+        # rewrite constraints to only use representative type variables
+        constraints = self._rewrite_constraints_with_replacements(constraints, tv_to_reptvs)
+
         # collect typevars used in the constraint set
         constrained_typevars = set()
         for constraint in constraints:
@@ -527,7 +541,6 @@ class SimpleSolver:
                     elif isinstance(t, TypeVariable) and t in typevars:
                         constrained_typevars.add(t)
 
-        _, sketches = self.infer_shapes(typevars, constraints)
         constraintset2tvs = defaultdict(set)
         tvs_seen = set()
         for idx, tv in enumerate(constrained_typevars):
@@ -579,6 +592,10 @@ class SimpleSolver:
                     filtered_constraint_subset, tvs | PRIMITIVE_TYPES
                 )
                 primitive_constraints = self._generate_primitive_constraints(tvs, base_constraint_graph)
+                if len(tvs) > 1:
+                    primitive_constraints |= self._generate_transitive_subtype_constraints(
+                        tvs, filtered_constraint_subset, primitive_constraints
+                    )
                 tvs_with_primitive_constraints = set()
                 for primitive_constraint in primitive_constraints:
                     tv = self._typevar_from_primitive_constraint(primitive_constraint)
@@ -586,7 +603,9 @@ class SimpleSolver:
                     assert tv is not None, f"Cannot find type variable in primitive constraint {primitive_constraint}"
                     sketches[tv].add_constraint(primitive_constraint)
                 solutions = {}
-                self.determine(sketches, tvs_with_primitive_constraints, solutions)
+                self.determine(
+                    sketches, sorted(tvs_with_primitive_constraints, key=lambda x: x.idx), equiv_classes, solutions
+                )
                 _l.debug("Determined solutions for %d type variable(s).", len(tvs_with_primitive_constraints))
 
                 leaf_solutions = 0
@@ -614,7 +633,12 @@ class SimpleSolver:
                 constraint_subset = self._filter_constraints(new_constraint_subset)
 
         # set the solution for missing type vars to TOP
-        self.determine(sketches, set(sketches).difference(set(self.solution)), self.solution)
+        self.determine(sketches, set(sketches).difference(set(self.solution)), equiv_classes, self.solution)
+
+        # set solutions for non-representative type variables
+        for tv, reptv in equiv_classes.items():
+            if reptv in self.solution and tv not in self.solution:
+                self.solution[tv] = self.solution[reptv]
 
     def infer_shapes(
         self, typevars: set[TypeVariable], constraints: set[TypeConstraint]
@@ -627,14 +651,19 @@ class SimpleSolver:
 
         sketches: dict[TypeVariable, Sketch] = {}
         for tv in typevars:
+            if tv in equivalence_classes and equivalence_classes[tv] != tv:
+                # skip non-representative type variables
+                continue
             sketches[tv] = Sketch(self, tv)
 
         for tv, sketch in sketches.items():
             sketch_node = sketch.lookup(tv)
             graph_node = equivalence_classes.get(tv, None)
             # assert graph_node is not None
-            if graph_node is None:
+            if graph_node is None or sketch_node is None:
                 continue
+            assert isinstance(graph_node, TypeVariable)
+            assert isinstance(sketch_node, SketchNode)
             visited = {graph_node: sketch_node}
             self._get_all_paths(quotient_graph, sketch, graph_node, visited)
         return equivalence_classes, sketches
@@ -654,6 +683,7 @@ class SimpleSolver:
             last_node = tv
             prefix = tv
             while isinstance(prefix, DerivedTypeVariable) and prefix.labels:
+                assert isinstance(last_node, DerivedTypeVariable)
                 prefix = prefix.longest_prefix()
                 if prefix is None:
                     continue
@@ -683,8 +713,8 @@ class SimpleSolver:
         out_graph = networkx.MultiDiGraph()  # there can be multiple edges between two nodes, each edge is associated
         # with a different label
         for src, dst, data in g.edges(data=True):
-            src_cls = equivalence_classes[src]
-            dst_cls = equivalence_classes[dst]
+            src_cls = equivalence_classes.get(src, src)
+            dst_cls = equivalence_classes.get(dst, dst)
             label = None if not data else data["label"]
             if label is not None and out_graph.has_edge(src_cls, dst_cls):
                 # do not add the same edge twice
@@ -708,6 +738,41 @@ class SimpleSolver:
         constraints_1 = self._solve_constraints_between(constraint_graph, PRIMITIVE_TYPES, non_primitive_endpoints)
         return constraints_0 | constraints_1
 
+    @staticmethod
+    def _generate_transitive_subtype_constraints(
+        typevars: set[TypeVariable | DerivedTypeVariable],
+        constraints: set[TypeConstraint],
+        primitive_constraints: set[TypeConstraint],
+    ) -> set[TypeConstraint]:
+        """
+        Handling multiple type variables at once means we may miss some subtyping relationships between a type variable
+        and a primitive type (e.g., tv_1 <: tv_2 and tv_2 <: int, we may not see tv_1 <: int). This method attempts to
+        recover some of these missing constraints.
+        """
+
+        tv_supertype = defaultdict(set)
+        for constraint in primitive_constraints:
+            if isinstance(constraint, Subtype) and SimpleSolver._typevar_inside_set(
+                constraint.super_type, PRIMITIVE_TYPES
+            ):
+                tv_supertype[constraint.sub_type].add(constraint.super_type)
+
+        additional_constraints = set()
+        for constraint in constraints:
+            if (
+                isinstance(constraint, Subtype)
+                and isinstance(constraint.sub_type, TypeVariable)
+                and (
+                    (isinstance(constraint.sub_type, DerivedTypeVariable) and constraint.sub_type.type_var in typevars)
+                    or (not isinstance(constraint.sub_type, DerivedTypeVariable) and constraint.sub_type in typevars)
+                )
+                and constraint.super_type in tv_supertype
+            ):
+                for supertype in tv_supertype[constraint.super_type]:
+                    additional_constraints.add(Subtype(constraint.sub_type, supertype))
+
+        return additional_constraints
+
     @staticmethod
     def _typevars_from_constraints(constraints: set[TypeConstraint]) -> set[TypeVariable | DerivedTypeVariable]:
         """
@@ -717,8 +782,10 @@ class SimpleSolver:
         typevars: set[TypeVariable | DerivedTypeVariable] = set()
         for constraint in constraints:
             if isinstance(constraint, Subtype):
-                typevars.add(constraint.sub_type)
-                typevars.add(constraint.super_type)
+                if not isinstance(constraint.sub_type, TypeConstant):
+                    typevars.add(constraint.sub_type)
+                if not isinstance(constraint.super_type, TypeConstant):
+                    typevars.add(constraint.super_type)
             # TODO: Other types of constraints?
         return typevars
 
@@ -745,7 +812,7 @@ class SimpleSolver:
     def _get_all_paths(
         graph: networkx.DiGraph[TypeVariable | DerivedTypeVariable],
         sketch: Sketch,
-        node: DerivedTypeVariable,
+        node: TypeVariable,
         visited: dict[TypeVariable | DerivedTypeVariable, SketchNode],
     ):
         if node not in graph:
@@ -779,29 +846,45 @@ class SimpleSolver:
 
     @staticmethod
     def _unify(
-        equivalence_classes: dict, cls0: DerivedTypeVariable, cls1: DerivedTypeVariable, graph: networkx.DiGraph
+        equivalence_classes: dict,
+        cls0: TypeConstant | TypeVariable,
+        cls1: TypeConstant | TypeVariable,
+        graph: networkx.DiGraph,
     ) -> None:
         # first convert cls0 and cls1 to their equivalence classes
-        cls0 = equivalence_classes[cls0]
-        cls1 = equivalence_classes[cls1]
+        cls0 = equivalence_classes.get(cls0, cls0)
+        cls1 = equivalence_classes.get(cls1, cls1)
 
         # unify if needed
         if cls0 != cls1:
             # MakeEquiv
-            existing_elements = {key for key, item in equivalence_classes.items() if item in {cls0, cls1}}
-            rep_cls = cls0
+            cls0_elems = {key for key, item in equivalence_classes.items() if item is cls0}
+            cls1_elems = {key for key, item in equivalence_classes.items() if item is cls1}
+            existing_elements = cls0_elems | cls1_elems
+            # pick a representative type variable and prioritize non-derived type variables
+            if not isinstance(cls0, DerivedTypeVariable):
+                rep_cls = cls0
+            elif not isinstance(cls1, DerivedTypeVariable):
+                rep_cls = cls1
+            else:
+                rep_cls = next(
+                    iter(elem for elem in existing_elements if not isinstance(elem, DerivedTypeVariable)), cls0
+                )
             for elem in existing_elements:
                 equivalence_classes[elem] = rep_cls
             # the logic below refers to the retypd reference implementation. it is different from Algorithm E.1
             # note that graph is used read-only in this method, so we do not need to make copy of edges
-            for _, dst0, data0 in graph.out_edges(cls0, data=True):
+            for _, dst0, data0 in graph.out_edges(cls0_elems, data=True):
                 if "label" in data0 and data0["label"] is not None:
-                    for _, dst1, data1 in graph.out_edges(cls1, data=True):
+                    for _, dst1, data1 in graph.out_edges(cls1_elems, data=True):
                         if data0["label"] == data1["label"] or (
                             isinstance(data0["label"], Load) and isinstance(data1["label"], Store)
                         ):
                             SimpleSolver._unify(
-                                equivalence_classes, equivalence_classes[dst0], equivalence_classes[dst1], graph
+                                equivalence_classes,
+                                equivalence_classes.get(dst0, dst0),
+                                equivalence_classes.get(dst1, dst1),
+                                graph,
                             )
 
     def _eq_constraints_from_add(self, typevar: TypeVariable):
@@ -898,9 +981,12 @@ class SimpleSolver:
 
     @staticmethod
     def _rewrite_constraints_with_replacements(
-        constraints: set[TypeConstraint], replacements: dict[TypeVariable, TypeVariable]
+        constraints: set[TypeConstraint], replacements: dict[TypeVariable, TypeVariable | TypeConstant]
     ) -> set[TypeConstraint]:
         # replace constraints according to a dictionary of type variable replacements
+        if not replacements:
+            return constraints
+
         replaced_constraints = set()
         for constraint in constraints:
             if isinstance(constraint, Existence):
@@ -966,9 +1052,9 @@ class SimpleSolver:
                 if isinstance(constraint.sub_type, TypeVariable):
                     sub_typevars[constraint.sub_type].add(constraint.super_type)
                 for tv in [constraint.sub_type, constraint.super_type]:
-                    if isinstance(tv, DerivedTypeVariable):
+                    if isinstance(tv, DerivedTypeVariable) and not isinstance(constraint.sub_type, TypeConstant):
                         tv_to_dtvs[tv.type_var].add(constraint.sub_type)
-                    elif isinstance(tv, TypeVariable):
+                    elif isinstance(tv, TypeVariable) and not isinstance(constraint.sub_type, TypeConstant):
                         tv_to_dtvs[tv].add(constraint.sub_type)
 
         ub_subtypes: dict[TypeVariable, TypeVariable] = {}
@@ -980,8 +1066,11 @@ class SimpleSolver:
 
         filtered_constraints = set()
         for constraint in constraints:
-            if isinstance(constraint, Subtype) and constraint.sub_type in ub_subtypes:
-                continue
+            if isinstance(constraint, Subtype):
+                if constraint.sub_type in ub_subtypes:
+                    continue
+                if constraint.sub_type == constraint.super_type:
+                    continue
             filtered_constraints.add(constraint)
 
         return filtered_constraints, ub_subtypes
@@ -1136,9 +1225,9 @@ class SimpleSolver:
     def _constraint_graph_add_edges(
         self,
         graph: networkx.DiGraph,
-        subtype: TypeVariable | DerivedTypeVariable,
-        supertype: TypeVariable | DerivedTypeVariable,
-        interesting_variables: set[DerivedTypeVariable],
+        subtype: TypeVariable | DerivedTypeVariable | TypeConstant,
+        supertype: TypeVariable | DerivedTypeVariable | TypeConstant,
+        interesting_variables: set[TypeVariable | DerivedTypeVariable | TypeConstant],
     ):
         # left and right tags
         if self._typevar_inside_set(self._to_typevar_or_typeconst(subtype), interesting_variables):
@@ -1173,7 +1262,7 @@ class SimpleSolver:
 
         # initialize the reaching-push sets R(x)
         for x, y, data in graph.edges(data=True):
-            if "label" in data and data.get("label")[1] == "forget":
+            if "label" in data and data.get("label")[1] == "forget":  # type:ignore
                 d = data["label"][0], x
                 R[y].add(d)
 
@@ -1191,7 +1280,7 @@ class SimpleSolver:
                 lbl = data.get("label")
                 if lbl and lbl[1] == "recall":
                     for _label, z in R[x]:
-                        if not graph.has_edge(z, y):
+                        if lbl[0] == _label and not graph.has_edge(z, y):
                             changed = True
                             graph.add_edge(z, y)
             v_contravariant = []
@@ -1376,6 +1465,7 @@ class SimpleSolver:
         self,
         sketches,
         tvs,
+        equivalence_classes: dict[TypeVariable, TypeVariable],
         solution: dict,
         nodes: set[SketchNode] | None = None,
     ) -> None:
@@ -1389,13 +1479,21 @@ class SimpleSolver:
         """
 
         for typevar in tvs:
-            self._determine(typevar, sketches[typevar], solution, nodes=nodes)
+            self._solution_cache = {}
+            self._determine(typevar, sketches[typevar], equivalence_classes, solution, nodes=nodes)
 
         for v, eq in self._equivalence.items():
             if v not in solution and eq in solution:
                 solution[v] = solution[eq]
 
-    def _determine(self, the_typevar, sketch, solution: dict, nodes: set[SketchNode] | None = None):
+    def _determine(
+        self,
+        the_typevar,
+        sketch,
+        equivalence_classes: dict[TypeVariable, TypeVariable],
+        solution: dict,
+        nodes: set[SketchNode] | None = None,
+    ):
         """
         Return the solution from sketches
         """
@@ -1409,8 +1507,9 @@ class SimpleSolver:
         # consult the cache
         cached_results = set()
         for node in nodes:
-            if node.typevar in self._solution_cache:
-                cached_results.add(self._solution_cache[node.typevar])
+            repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+            if repr_tv in self._solution_cache:
+                cached_results.add(self._solution_cache[repr_tv])
         if len(cached_results) == 1:
             return next(iter(cached_results))
         if len(cached_results) > 1:
@@ -1434,7 +1533,8 @@ class SimpleSolver:
             func_type = Function([], [])
             result = self._pointer_class()(basetype=func_type)
             for node in nodes:
-                self._solution_cache[node.typevar] = result
+                repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                self._solution_cache[repr_tv] = result
 
             # this is a function variable
             func_inputs = defaultdict(set)
@@ -1455,7 +1555,7 @@ class SimpleSolver:
             for vals, out in [(func_inputs, input_args), (func_outputs, output_values)]:
                 for idx in range(max(vals) + 1):
                     if idx in vals:
-                        sol = self._determine(the_typevar, sketch, solution, nodes=vals[idx])
+                        sol = self._determine(the_typevar, sketch, equivalence_classes, solution, nodes=vals[idx])
                         out.append(sol)
                     else:
                         out.append(None)
@@ -1483,15 +1583,19 @@ class SimpleSolver:
                         else the_node.upper_bound
                     )
                     for node in nodes:
+                        repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                        self._solution_cache[repr_tv] = result
                         solution[node.typevar] = result
-                        self._solution_cache[node.typevar] = result
                     return result
 
             # create a dummy result and shove it into the cache
             struct_type = Struct(fields={})
             result = self._pointer_class()(struct_type)
+            # print(f"Creating a struct type: {struct_type} for {the_typevar}")
             for node in nodes:
-                self._solution_cache[node.typevar] = result
+                # print(f"... assigned it to {node.typevar}")
+                repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                self._solution_cache[repr_tv] = result
 
             # this might be a struct
             fields = {}
@@ -1528,21 +1632,21 @@ class SimpleSolver:
                     offset_to_maxsize[base] = max(offset_to_maxsize[base], (last_label.offset - base) + access_size)
                     offset_to_sizes[base].add(access_size)
 
-            idx_to_base = {}
+            array_idx_to_base = {}
 
             for idx, (labels, _) in enumerate(path_and_successors):
                 last_label = labels[-1] if labels else None
-                if isinstance(last_label, HasField):
+                if isinstance(last_label, HasField) and last_label.elem_count > 1:
                     prev_offset = next(offset_to_base.irange(maximum=last_label.offset, reverse=True))
-                    idx_to_base[idx] = offset_to_base[prev_offset]
+                    array_idx_to_base[idx] = offset_to_base[prev_offset]
 
             node_by_offset = defaultdict(set)
 
             for idx, (labels, succ) in enumerate(path_and_successors):
                 last_label = labels[-1] if labels else None
                 if isinstance(last_label, HasField):
-                    if idx in idx_to_base:
-                        node_by_offset[idx_to_base[idx]].add(succ)
+                    if idx in array_idx_to_base:
+                        node_by_offset[array_idx_to_base[idx]].add(succ)
                     else:
                         node_by_offset[last_label.offset].add(succ)
 
@@ -1551,8 +1655,8 @@ class SimpleSolver:
                 offset = sorted_offsets[i]
 
                 child_nodes = node_by_offset[offset]
-                sol = self._determine(the_typevar, sketch, solution, nodes=child_nodes)
-                if isinstance(sol, TopType):
+                sol = self._determine(the_typevar, sketch, equivalence_classes, solution, nodes=child_nodes)
+                if isinstance(sol, TopType) and offset in offset_to_sizes:
                     # make it an array if possible
                     elem_size = min(offset_to_sizes[offset])
                     array_size = offset_to_maxsize[offset]
@@ -1566,12 +1670,14 @@ class SimpleSolver:
             if not fields:
                 result = Top_
                 for node in nodes:
-                    self._solution_cache[node.typevar] = result
+                    repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                    self._solution_cache[repr_tv] = result
                     solution[node.typevar] = result
-            elif any(off < 0 for off in fields):
+            elif any(off < 0 for off in fields) or any(fld is Bottom_ for fld in fields.values()):
                 result = self._pointer_class()(Bottom_)
                 for node in nodes:
-                    self._solution_cache[node.typevar] = result
+                    repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                    self._solution_cache[repr_tv] = result
                     solution[node.typevar] = result
             else:
                 # back-patch
@@ -1599,8 +1705,9 @@ class SimpleSolver:
                 result = lower_bound if not isinstance(lower_bound, BottomType) else upper_bound
 
             for node in nodes:
+                repr_tv = equivalence_classes.get(node.typevar, node.typevar)
+                self._solution_cache[repr_tv] = result
                 solution[node.typevar] = result
-                self._solution_cache[node.typevar] = result
 
         # import pprint
 

angr/analyses/typehoon/translator.py

@@ -85,7 +85,7 @@ class TypeTranslator:
             internal = sim_type.SimTypeBottom(label="void").with_arch(self.arch)
         else:
             internal = self._tc2simtype(tc.basetype)
-        return sim_type.SimTypePointer(internal).with_arch(self.arch)
+        return sim_type.SimTypePointer(internal, label=tc.name).with_arch(self.arch)
 
     def _translate_Pointer32(self, tc):
         if isinstance(tc.basetype, typeconsts.BottomType):
@@ -93,11 +93,11 @@ class TypeTranslator:
             internal = sim_type.SimTypeBottom(label="void").with_arch(self.arch)
         else:
             internal = self._tc2simtype(tc.basetype)
-        return sim_type.SimTypePointer(internal).with_arch(self.arch)
+        return sim_type.SimTypePointer(internal, label=tc.name).with_arch(self.arch)
 
     def _translate_Array(self, tc: typeconsts.Array) -> sim_type.SimTypeArray:
         elem_type = self._tc2simtype(tc.element)
-        return sim_type.SimTypeArray(elem_type, length=tc.count).with_arch(self.arch)
+        return sim_type.SimTypeArray(elem_type, length=tc.count, label=tc.name).with_arch(self.arch)
 
     def _translate_Struct(self, tc: typeconsts.Struct):
         if tc in self.structs:
@@ -136,26 +136,26 @@ class TypeTranslator:
 
         return s
 
-    def _translate_Int8(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeChar(signed=False).with_arch(self.arch)
+    def _translate_Int8(self, tc):
+        return sim_type.SimTypeChar(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int16(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeShort(signed=False).with_arch(self.arch)
+    def _translate_Int16(self, tc):
+        return sim_type.SimTypeShort(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int32(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeInt(signed=False).with_arch(self.arch)
+    def _translate_Int32(self, tc):
+        return sim_type.SimTypeInt(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int64(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeLongLong(signed=False).with_arch(self.arch)
+    def _translate_Int64(self, tc):
+        return sim_type.SimTypeLongLong(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int128(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeInt128(signed=False).with_arch(self.arch)
+    def _translate_Int128(self, tc):
+        return sim_type.SimTypeInt128(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int256(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeInt256(signed=False).with_arch(self.arch)
+    def _translate_Int256(self, tc):
+        return sim_type.SimTypeInt256(signed=False, label=tc.name).with_arch(self.arch)
 
-    def _translate_Int512(self, tc):  # pylint:disable=unused-argument
-        return sim_type.SimTypeInt512(signed=False).with_arch(self.arch)
+    def _translate_Int512(self, tc):
+        return sim_type.SimTypeInt512(signed=False, label=tc.name).with_arch(self.arch)
 
     def _translate_TypeVariableReference(self, tc):
         if tc.typevar in self.translated:
@@ -164,11 +164,11 @@ class TypeTranslator:
         self._has_nonexistent_ref = True
         return SimTypeTempRef(tc.typevar)
 
-    def _translate_Float32(self, tc: typeconsts.Float32) -> sim_type.SimTypeFloat:  # pylint:disable=unused-argument
-        return sim_type.SimTypeFloat().with_arch(self.arch)
+    def _translate_Float32(self, tc: typeconsts.Float32) -> sim_type.SimTypeFloat:
+        return sim_type.SimTypeFloat(label=tc.name).with_arch(self.arch)
 
-    def _translate_Float64(self, tc: typeconsts.Float64) -> sim_type.SimTypeDouble:  # pylint:disable=unused-argument
-        return sim_type.SimTypeDouble().with_arch(self.arch)
+    def _translate_Float64(self, tc: typeconsts.Float64) -> sim_type.SimTypeDouble:
+        return sim_type.SimTypeDouble(label=tc.name).with_arch(self.arch)
 
     #
     # Backpatching
@@ -197,25 +197,25 @@ class TypeTranslator:
     #
 
     def _translate_SimTypeInt128(self, st: sim_type.SimTypeChar) -> typeconsts.Int128:
-        return typeconsts.Int128()
+        return typeconsts.Int128(name=st.label)
 
     def _translate_SimTypeInt256(self, st: sim_type.SimTypeChar) -> typeconsts.Int256:
-        return typeconsts.Int256()
+        return typeconsts.Int256(name=st.label)
 
     def _translate_SimTypeInt512(self, st: sim_type.SimTypeChar) -> typeconsts.Int512:
-        return typeconsts.Int512()
+        return typeconsts.Int512(name=st.label)
 
     def _translate_SimTypeInt(self, st: sim_type.SimTypeInt) -> typeconsts.Int32:
-        return typeconsts.Int32()
+        return typeconsts.Int32(name=st.label)
 
     def _translate_SimTypeLong(self, st: sim_type.SimTypeLong) -> typeconsts.Int32:
-        return typeconsts.Int32()
+        return typeconsts.Int32(name=st.label)
 
     def _translate_SimTypeLongLong(self, st: sim_type.SimTypeLongLong) -> typeconsts.Int64:
-        return typeconsts.Int64()
+        return typeconsts.Int64(name=st.label)
 
     def _translate_SimTypeChar(self, st: sim_type.SimTypeChar) -> typeconsts.Int8:
-        return typeconsts.Int8()
+        return typeconsts.Int8(name=st.label)
 
     def _translate_SimStruct(self, st: sim_type.SimStruct) -> typeconsts.Struct:
         fields = {}
@@ -224,25 +224,25 @@ class TypeTranslator:
             offset = offsets[name]
             fields[offset] = self._simtype2tc(ty)
 
-        return typeconsts.Struct(fields=fields)
+        return typeconsts.Struct(fields=fields, name=st.label)
 
     def _translate_SimTypeArray(self, st: sim_type.SimTypeArray) -> typeconsts.Array:
         elem_type = self._simtype2tc(st.elem_type)
-        return typeconsts.Array(elem_type, count=st.length)
+        return typeconsts.Array(elem_type, count=st.length, name=st.label)
 
     def _translate_SimTypePointer(self, st: sim_type.SimTypePointer) -> typeconsts.Pointer32 | typeconsts.Pointer64:
         base = self._simtype2tc(st.pts_to)
         if self.arch.bits == 32:
-            return typeconsts.Pointer32(base)
+            return typeconsts.Pointer32(base, name=st.label)
         if self.arch.bits == 64:
-            return typeconsts.Pointer64(base)
+            return typeconsts.Pointer64(base, name=st.label)
         raise TypeError(f"Unsupported pointer size {self.arch.bits}")
 
     def _translate_SimTypeFloat(self, st: sim_type.SimTypeFloat) -> typeconsts.Float32:
-        return typeconsts.Float32()
+        return typeconsts.Float32(name=st.label)
 
     def _translate_SimTypeDouble(self, st: sim_type.SimTypeDouble) -> typeconsts.Float64:
-        return typeconsts.Float64()
+        return typeconsts.Float64(name=st.label)
 
 
 TypeConstHandlers = {