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()
