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: Namhyung 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: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/annotate-data.c b/tools/perf/util/annotate-data.c
index 1f921971174d2f48275663a5a1e907eba3e4d1ff..5269c6630e0452ec4136ea6199251fdb2c1326d0 100644 (file)
--- a/tools/perf/util/annotate-data.c
+++ b/tools/perf/util/annotate-data.c
@@ -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);
        }
 }

diff --git a/tools/perf/util/annotate-data.h b/tools/perf/util/annotate-data.h
index 6efdd7e21b286bf758380294c992929393be3712..33748222e6aa4d5300771963c3ca2cb9a60f935a 100644 (file)
--- a/tools/perf/util/annotate-data.h
+++ b/tools/perf/util/annotate-data.h
@@ -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;

diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index e647f0117bb568537f1156f41e8abbc094fbf02e..a41209e242ae423719d091b2e8a5475c2d0e94d2 100644 (file)
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -2135,7 +2135,10 @@ struct sort_entry sort_addr = {
 /* --sort type */
 
 struct annotated_data_type unknown_type = {
-       .type_name = (char *)"(unknown)",
+       .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 = {