Commit 4a111cad authored by Namhyung Kim's avatar Namhyung Kim Committed by Arnaldo Carvalho de Melo
Browse files

perf annotate-data: Add member field in the data type 



Add child member field if the current type is a composite type like a
struct or union.  The member fields are linked in the children list and
do the same recursively if the child itself is a composite type.

Add 'self' member to the annotated_data_type to handle the members in
the same way.

Signed-off-by: default avatarNamhyung Kim <namhyung@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Cc: linux-toolchains@vger.kernel.org
Cc: linux-trace-devel@vger.kernel.org
Link: https://lore.kernel.org/r/20231213001323.718046-11-namhyung@kernel.org


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 81e57dee

tools/perf/util/annotate-data.c

+90 −11
Original line number Diff line number Diff line
@@ -31,9 +31,9 @@ static int data_type_cmp(const void *_key, const struct rb_node *node) 


	type = rb_entry(node, struct annotated_data_type, node);



	if (key->type_size != type->type_size)

		return key->type_size - type->type_size;

	return strcmp(key->type_name, type->type_name);

	if (key->self.size != type->self.size)

		return key->self.size - type->self.size;

	return strcmp(key->self.type_name, type->self.type_name);

}



static bool data_type_less(struct rb_node *node_a, const struct rb_node *node_b)
@@ -43,9 +43,80 @@ static bool data_type_less(struct rb_node *node_a, const struct rb_node *node_b) 
	a = rb_entry(node_a, struct annotated_data_type, node);

	b = rb_entry(node_b, struct annotated_data_type, node);



	if (a->type_size != b->type_size)

		return a->type_size < b->type_size;

	return strcmp(a->type_name, b->type_name) < 0;

	if (a->self.size != b->self.size)

		return a->self.size < b->self.size;

	return strcmp(a->self.type_name, b->self.type_name) < 0;

}



/* Recursively add new members for struct/union */

static int __add_member_cb(Dwarf_Die *die, void *arg)

{

	struct annotated_member *parent = arg;

	struct annotated_member *member;

	Dwarf_Die member_type, die_mem;

	Dwarf_Word size, loc;

	Dwarf_Attribute attr;

	struct strbuf sb;

	int tag;



	if (dwarf_tag(die) != DW_TAG_member)

		return DIE_FIND_CB_SIBLING;



	member = zalloc(sizeof(*member));

	if (member == NULL)

		return DIE_FIND_CB_END;



	strbuf_init(&sb, 32);

	die_get_typename(die, &sb);



	die_get_real_type(die, &member_type);

	if (dwarf_aggregate_size(&member_type, &size) < 0)

		size = 0;



	if (!dwarf_attr_integrate(die, DW_AT_data_member_location, &attr))

		loc = 0;

	else

		dwarf_formudata(&attr, &loc);



	member->type_name = strbuf_detach(&sb, NULL);

	/* member->var_name can be NULL */

	if (dwarf_diename(die))

		member->var_name = strdup(dwarf_diename(die));

	member->size = size;

	member->offset = loc + parent->offset;

	INIT_LIST_HEAD(&member->children);

	list_add_tail(&member->node, &parent->children);



	tag = dwarf_tag(&member_type);

	switch (tag) {

	case DW_TAG_structure_type:

	case DW_TAG_union_type:

		die_find_child(&member_type, __add_member_cb, member, &die_mem);

		break;

	default:

		break;

	}

	return DIE_FIND_CB_SIBLING;

}



static void add_member_types(struct annotated_data_type *parent, Dwarf_Die *type)

{

	Dwarf_Die die_mem;



	die_find_child(type, __add_member_cb, &parent->self, &die_mem);

}



static void delete_members(struct annotated_member *member)

{

	struct annotated_member *child, *tmp;



	list_for_each_entry_safe(child, tmp, &member->children, node) {

		list_del(&child->node);

		delete_members(child);

		free(child->type_name);

		free(child->var_name);

		free(child);

	}

}



static struct annotated_data_type *dso__findnew_data_type(struct dso *dso,
@@ -65,8 +136,8 @@ static struct annotated_data_type *dso__findnew_data_type(struct dso *dso, 
	dwarf_aggregate_size(type_die, &size);



	/* Check existing nodes in dso->data_types tree */

	key.type_name = type_name;

	key.type_size = size;

	key.self.type_name = type_name;

	key.self.size = size;

	node = rb_find(&key, &dso->data_types, data_type_cmp);

	if (node) {

		result = rb_entry(node, struct annotated_data_type, node);
@@ -81,8 +152,15 @@ static struct annotated_data_type *dso__findnew_data_type(struct dso *dso, 
		return NULL;

	}



	result->type_name = type_name;

	result->type_size = size;

	result->self.type_name = type_name;

	result->self.size = size;

	INIT_LIST_HEAD(&result->self.children);



	/*

	 * Fill member info unconditionally for now,

	 * later perf annotate would need it.

	 */

	add_member_types(result, type_die);



	rb_add(&result->node, &dso->data_types, data_type_less);

	return result;
@@ -233,7 +311,8 @@ void annotated_data_type__tree_delete(struct rb_root *root) 


		rb_erase(node, root);

		pos = rb_entry(node, struct annotated_data_type, node);

		free(pos->type_name);

		delete_members(&pos->self);

		free(pos->self.type_name);

		free(pos);

	}

}

tools/perf/util/annotate-data.h

+23 −4
Original line number Diff line number Diff line
@@ -9,17 +9,36 @@ 


struct map_symbol;



/**

 * struct annotated_member - Type of member field

 * @node: List entry in the parent list

 * @children: List head for child nodes

 * @type_name: Name of the member type

 * @var_name: Name of the member variable

 * @offset: Offset from the outer data type

 * @size: Size of the member field

 *

 * This represents a member type in a data type.

 */

struct annotated_member {

	struct list_head node;

	struct list_head children;

	char *type_name;

	char *var_name;

	int offset;

	int size;

};



/**

 * struct annotated_data_type - Data type to profile

 * @type_name: Name of the data type

 * @type_size: Size of the data type

 * @node: RB-tree node for dso->type_tree

 * @self: Actual type information

 *

 * This represents a data type accessed by samples in the profile data.

 */

struct annotated_data_type {

	struct rb_node node;

	char *type_name;

	int type_size;

	struct annotated_member self;

};



extern struct annotated_data_type unknown_type;

tools/perf/util/sort.c

+6 −3
Original line number Diff line number Diff line
@@ -2135,7 +2135,10 @@ struct sort_entry sort_addr = { 
/* --sort type */



struct annotated_data_type unknown_type = {

	.self = {

		.type_name = (char *)"(unknown)",

		.children = LIST_HEAD_INIT(unknown_type.self.children),

	},

};



static int64_t
@@ -2170,7 +2173,7 @@ sort__type_collapse(struct hist_entry *left, struct hist_entry *right) 
		right_type = right->mem_type;

	}



	return strcmp(left_type->type_name, right_type->type_name);

	return strcmp(left_type->self.type_name, right_type->self.type_name);

}



static int64_t
@@ -2182,7 +2185,7 @@ sort__type_sort(struct hist_entry *left, struct hist_entry *right) 
static int hist_entry__type_snprintf(struct hist_entry *he, char *bf,

				     size_t size, unsigned int width)

{

	return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->type_name);

	return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->self.type_name);

}



struct sort_entry sort_type = {