def all_type_tags(gdb_type: gdb.Type, names=None, ops=None, seen=None) -> set: name_list = list(names or []) if isinstance(names, set) else names or [] seen = seen or set([]) ops = ops or [] prev_type = None while prev_type != gdb_type: prev_type = gdb_type gdb_type = gdb_type.unqualified() if str(gdb_type) in seen: break seen.add(str(gdb_type)) if gdb_type.tag is not None: print(" .. : <tag=%s>" % str(gdb_type.tag)) name_list.append(gdb_type.tag) if gdb_type.name is not None: print(" .. : <name=%s>" % str(gdb_type.name)) name_list.append(gdb_type.name) if gdb_type.code in \ (gdb.TYPE_CODE_PTR, gdb.TYPE_CODE_REF, gdb.TYPE_CODE_RVALUE_REF, gdb.TYPE_CODE_ARRAY): print(" .. [%s].target() -> %s" % (str(gdb_type), str(gdb_type.target()))) gdb_type = gdb_type.target() ops.append(gdb.Value.referenced_value) elif gdb_type.code in \ (gdb.TYPE_CODE_UNION, gdb.TYPE_CODE_STRUCT): next_base = next = None for field in gdb_type.fields(): if field.type in (prev_type, gdb_type, None if prev_type is None else prev_type.pointer(), gdb_type.pointer()): continue if field.is_base_class: print( f" [%s].{field.name} ***BASE_CLASS*** {str(field.type)}"\ % (str(field.parent_type))) all_type_tags( field.type, names=name_list, ops=(ops + [(lambda v: v.cast(field.parent_type)[field])]), seen=seen) elif gdb_type.code == gdb.TYPE_CODE_TYPEDEF: print(" [%s] typedef -> %s" % (str(gdb_type), str(gdb_type.strip_typedefs()))) ops.append(lambda v: v.cast(v.type.strip_typedefs())) gdb_type = gdb_type.strip_typedefs() return (set(name_list), ops)
def _process_type(self, parent_type: TypeWrapper, t: gdb.Type, agg: TypeAggregator, process_fields: bool): t = t.strip_typedefs() if t.code == gdb.TYPE_CODE_PTR or t.code == gdb.TYPE_CODE_REF: basic = utils.get_basic_type(t) if basic.code == gdb.TYPE_CODE_FUNC: self._process_type(parent_type, basic.target(), agg, False) self._process_type_fields(parent_type, basic, agg) else: basic = utils.get_struct_type(t) if basic is not None: agg.add_work_item(basic) return t = utils.get_struct_type(t) if t is None: # Not a struct type return if process_fields or utils.get_type_name_or_tag(t) is None: # Unnamed types are not added to the type graph self._process_type_fields(parent_type, t, agg) else: field_wrapper = agg.add_work_item(t) agg.add_type_reference(field_wrapper, parent_type)
def get_basic_type(type_: gdb.Type) -> gdb.Type: """Return the "basic" type of a type. Arguments: type_: The type to reduce to its basic type. Returns: type_ with const/volatile is stripped away, and typedefs/references converted to the underlying type. """ while (type_.code == gdb.TYPE_CODE_REF or type_.code == gdb.TYPE_CODE_RVALUE_REF or type_.code == gdb.TYPE_CODE_TYPEDEF or type_.code == gdb.TYPE_CODE_PTR): if (type_.code == gdb.TYPE_CODE_REF or type_.code == gdb.TYPE_CODE_RVALUE_REF or type_.code == gdb.TYPE_CODE_PTR): type_ = type_.target() else: type_ = type_.strip_typedefs() return type_.unqualified()
def get_struct_type(t: gdb.Type) -> Optional[gdb.Type]: """Return the "basic" type of a type. Arguments: type_: The type to reduce to its basic type. Returns: type_ with const/volatile is stripped away, and typedefs/references converted to the underlying type. """ t = t.strip_typedefs() while True: if t.code == gdb.TYPE_CODE_PTR or t.code == gdb.TYPE_CODE_REF or t.code == gdb.TYPE_CODE_RVALUE_REF: t = t.target() elif t.code == gdb.TYPE_CODE_ARRAY: t = t.target() elif t.code == gdb.TYPE_CODE_TYPEDEF: t = t.target() else: break if t.code != gdb.TYPE_CODE_STRUCT and t.code != gdb.TYPE_CODE_UNION: return None else: return t while (type_.code == gdb.TYPE_CODE_REF or type_.code == gdb.TYPE_CODE_RVALUE_REF or type_.code == gdb.TYPE_CODE_TYPEDEF or type_.code == gdb.TYPE_CODE_PTR): if (type_.code == gdb.TYPE_CODE_REF or type_.code == gdb.TYPE_CODE_RVALUE_REF or type_.code == gdb.TYPE_CODE_PTR): type_ = type_.target() else: type_ = type_.strip_typedefs() return type_.unqualified()