[PATCH 04/15] gendwarfksyms: Expand base_type

Sami Tolvanen
2024-06-17T17:58:33Z

Add support for expanding basic DWARF attributes and DW_TAG_base_type
types.

Example usage:

$ nm -p --defined-only vmlinux.o | \
awk '/ (T|R|D) / {printf "%s %s\n",$1, $3}' | \
grep loops_per_jiffy | \
./tools/gendwarfksyms/gendwarfksyms --debug vmlinux.o

Output:

gendwarfksyms: symbol_read_list: adding { 4b0, "loops_per_jiffy" }
gendwarfksyms: process_modules: vmlinux.o
gendwarfksyms: process_exported_symbols: loops_per_jiffy (@ 4b0)
variable base_type unsigned long byte_size(8);
#SYMVER loops_per_jiffy 0xc694aefc

Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
---
tools/gendwarfksyms/types.c | 109 +++++++++++++++++++++++++++++++++++-
1 file changed, 108 insertions(+), 1 deletion(-)

diff --git a/tools/gendwarfksyms/types.c b/tools/gendwarfksyms/types.c
index 47ae967d42ee..7508d0fb8b80 100644
--- a/tools/gendwarfksyms/types.c
+++ b/tools/gendwarfksyms/types.c
@@ -16,6 +16,7 @@
}

DEFINE_GET_ATTR(addr, Dwarf_Addr)
+DEFINE_GET_ATTR(udata, Dwarf_Word)

static bool get_ref_die_attr(Dwarf_Die *die, unsigned int id, Dwarf_Die *value)
{
@@ -82,6 +83,73 @@ static int process(struct state *state, const char *s)
return 0;
}

+#define MAX_FMT_BUFFER_SIZE 128
+
+static int process_fmt(struct state *state, const char *fmt, ...)
+{
+ char buf[MAX_FMT_BUFFER_SIZE];
+ va_list args;
+ int res;
+
+ va_start(args, fmt);
+
+ res = check(vsnprintf(buf, sizeof(buf), fmt, args));
+ if (res >= MAX_FMT_BUFFER_SIZE - 1) {
+ error("vsnprintf overflow: increase MAX_FMT_BUFFER_SIZE");
+ res = -1;
+ } else {
+ check(process(state, buf));
+ }
+
+ va_end(args);
+ return res;
+}
+
+/* Process a fully qualified name from DWARF scopes */
+static int process_fqn(struct state *state, Dwarf_Die *die)
+{
+ Dwarf_Die *scopes = NULL;
+ const char *name;
+ int res;
+ int i;
+
+ res = check(dwarf_getscopes_die(die, &scopes));
+ if (!res) {
+ name = get_name(die);
+ name = name ?: "<unnamed>";
+ return check(process(state, name));
+ }
+
+ for (i = res - 1; i >= 0; i--) {
+ if (dwarf_tag(&scopes[i]) == DW_TAG_compile_unit)
+ continue;
+
+ name = get_name(&scopes[i]);
+ name = name ?: "<unnamed>";
+ check(process(state, name));
+ if (i > 0)
+ check(process(state, "::"));
+ }
+
+ free(scopes);
+ return 0;
+}
+
+#define DEFINE_PROCESS_UDATA_ATTRIBUTE(attribute) \
+ static int process_##attribute##_attr(struct state *state, \
+ Dwarf_Die *die) \
+ { \
+ Dwarf_Word value; \
+ if (get_udata_attr(die, DW_AT_##attribute, &value)) \
+ check(process_fmt(state, \
+ " " #attribute "(%" PRIu64 ")", \
+ value)); \
+ return 0; \
+ }
+
+DEFINE_PROCESS_UDATA_ATTRIBUTE(alignment)
+DEFINE_PROCESS_UDATA_ATTRIBUTE(byte_size)
+
bool match_all(Dwarf_Die *die)
{
return true;
@@ -103,11 +171,48 @@ int process_die_container(struct state *state, Dwarf_Die *die,
return 0;
}

+static int process_type(struct state *state, Dwarf_Die *die);
+
+static int process_type_attr(struct state *state, Dwarf_Die *die)
+{
+ Dwarf_Die type;
+
+ if (get_ref_die_attr(die, DW_AT_type, &type))
+ return check(process_type(state, &type));
+
+ /* Compilers can omit DW_AT_type -- print out 'void' to clarify */
+ return check(process(state, "base_type void"));
+}
+
+static int process_base_type(struct state *state, Dwarf_Die *die)
+{
+ check(process(state, "base_type "));
+ check(process_fqn(state, die));
+ check(process_byte_size_attr(state, die));
+ return check(process_alignment_attr(state, die));
+}
+
static void state_init(struct state *state)
{
state->crc = 0xffffffff;
}

+static int process_type(struct state *state, Dwarf_Die *die)
+{
+ int tag = dwarf_tag(die);
+
+ switch (tag) {
+ case DW_TAG_base_type:
+ check(process_base_type(state, die));
+ break;
+ default:
+ debug("unimplemented type: %x", tag);
+ break;
+ }
+
+ return 0;
+}
+
/*
* Exported symbol processing
*/
@@ -118,7 +223,9 @@ static int process_subprogram(struct state *state, Dwarf_Die *die)

static int process_variable(struct state *state, Dwarf_Die *die)
{
- return check(process(state, "variable;\n"));
+ check(process(state, "variable "));
+ check(process_type_attr(state, die));
+ return check(process(state, ";\n"));
}

static int process_exported_symbols(struct state *state, Dwarf_Die *die)
--
2.45.2.627.g7a2c4fd464-goog