gendwarfksyms: Add address matching

The compiler may choose not to emit type information in DWARF for all
aliases, but it's possible for each alias to be exported separately.
To ensure we find type information for the aliases as well, read
{section, address} tuples from the symbol table and match symbols also
by address.

Signed-off-by: Sami Tolvanen <samitolvanen@google.com>
Reviewed-by: Petr Pavlu <petr.pavlu@suse.com>
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>

diff --git a/scripts/gendwarfksyms/gendwarfksyms.c b/scripts/gendwarfksyms/gendwarfksyms.c
index a1d13353c6bc7cb5c7bbd0e664d710acfa2018da..cd8bfe973a5cb1d7bb901b3324d82ceef2883339 100644 (file)
--- a/scripts/gendwarfksyms/gendwarfksyms.c
+++ b/scripts/gendwarfksyms/gendwarfksyms.c
@@ -105,6 +105,8 @@ int main(int argc, char **argv)
                        error("open failed for '%s': %s", argv[n],
                              strerror(errno));
 
+               symbol_read_symtab(fd);
+
                dwfl = dwfl_begin(&callbacks);
                if (!dwfl)
                        error("dwfl_begin failed for '%s': %s", argv[n],

diff --git a/scripts/gendwarfksyms/gendwarfksyms.h b/scripts/gendwarfksyms/gendwarfksyms.h
index 5c8288c71fddbc1ac28e21be98cd62d77fcbc21e..cb9fd78a58dacdfb6e7dff2d93028dea9d9e8d15 100644 (file)
--- a/scripts/gendwarfksyms/gendwarfksyms.h
+++ b/scripts/gendwarfksyms/gendwarfksyms.h
@@ -63,14 +63,27 @@ extern int dump_dies;
  * symbols.c
  */
 
+static inline unsigned int addr_hash(uintptr_t addr)
+{
+       return hash_ptr((const void *)addr);
+}
+
+struct symbol_addr {
+       uint32_t section;
+       Elf64_Addr address;
+};
+
 struct symbol {
        const char *name;
+       struct symbol_addr addr;
+       struct hlist_node addr_hash;
        struct hlist_node name_hash;
 };
 
 typedef void (*symbol_callback_t)(struct symbol *, void *arg);
 
 void symbol_read_exports(FILE *file);
+void symbol_read_symtab(int fd);
 struct symbol *symbol_get(const char *name);
 void symbol_free(void);
 

diff --git a/scripts/gendwarfksyms/symbols.c b/scripts/gendwarfksyms/symbols.c
index 592eacf726948dd6efca845dd53edcffabe4c55e..98febb524dd574bf5bf78f89952e93ed4a42f2c8 100644 (file)
--- a/scripts/gendwarfksyms/symbols.c
+++ b/scripts/gendwarfksyms/symbols.c
@@ -7,9 +7,38 @@
 
 #define SYMBOL_HASH_BITS 12
 
+/* struct symbol_addr -> struct symbol */
+static HASHTABLE_DEFINE(symbol_addrs, 1 << SYMBOL_HASH_BITS);
 /* name -> struct symbol */
 static HASHTABLE_DEFINE(symbol_names, 1 << SYMBOL_HASH_BITS);
 
+static inline unsigned int symbol_addr_hash(const struct symbol_addr *addr)
+{
+       return hash_32(addr->section ^ addr_hash(addr->address));
+}
+
+static unsigned int __for_each_addr(struct symbol *sym, symbol_callback_t func,
+                                   void *data)
+{
+       struct hlist_node *tmp;
+       struct symbol *match = NULL;
+       unsigned int processed = 0;
+
+       hash_for_each_possible_safe(symbol_addrs, match, tmp, addr_hash,
+                                   symbol_addr_hash(&sym->addr)) {
+               if (match == sym)
+                       continue; /* Already processed */
+
+               if (match->addr.section == sym->addr.section &&
+                   match->addr.address == sym->addr.address) {
+                       func(match, data);
+                       ++processed;
+               }
+       }
+
+       return processed;
+}
+
 static unsigned int for_each(const char *name, symbol_callback_t func,
                             void *data)
 {
@@ -24,9 +53,13 @@ static unsigned int for_each(const char *name, symbol_callback_t func,
                if (strcmp(match->name, name))
                        continue;
 
+               /* Call func for the match, and all address matches */
                if (func)
                        func(match, data);
 
+               if (match->addr.section != SHN_UNDEF)
+                       return __for_each_addr(match, func, data) + 1;
+
                return 1;
        }
 
@@ -58,6 +91,7 @@ void symbol_read_exports(FILE *file)
 
                sym = xcalloc(1, sizeof(struct symbol));
                sym->name = name;
+               sym->addr.section = SHN_UNDEF;
 
                hash_add(symbol_names, &sym->name_hash, hash_str(sym->name));
                ++nsym;
@@ -84,6 +118,132 @@ struct symbol *symbol_get(const char *name)
        return sym;
 }
 
+typedef void (*elf_symbol_callback_t)(const char *name, GElf_Sym *sym,
+                                     Elf32_Word xndx, void *arg);
+
+static void elf_for_each_global(int fd, elf_symbol_callback_t func, void *arg)
+{
+       size_t sym_size;
+       GElf_Shdr shdr_mem;
+       GElf_Shdr *shdr;
+       Elf_Data *xndx_data = NULL;
+       Elf_Scn *scn;
+       Elf *elf;
+
+       if (elf_version(EV_CURRENT) != EV_CURRENT)
+               error("elf_version failed: %s", elf_errmsg(-1));
+
+       elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+       if (!elf)
+               error("elf_begin failed: %s", elf_errmsg(-1));
+
+       scn = elf_nextscn(elf, NULL);
+
+       while (scn) {
+               shdr = gelf_getshdr(scn, &shdr_mem);
+               if (!shdr)
+                       error("gelf_getshdr failed: %s", elf_errmsg(-1));
+
+               if (shdr->sh_type == SHT_SYMTAB_SHNDX) {
+                       xndx_data = elf_getdata(scn, NULL);
+                       if (!xndx_data)
+                               error("elf_getdata failed: %s", elf_errmsg(-1));
+                       break;
+               }
+
+               scn = elf_nextscn(elf, scn);
+       }
+
+       sym_size = gelf_fsize(elf, ELF_T_SYM, 1, EV_CURRENT);
+       scn = elf_nextscn(elf, NULL);
+
+       while (scn) {
+               shdr = gelf_getshdr(scn, &shdr_mem);
+               if (!shdr)
+                       error("gelf_getshdr failed: %s", elf_errmsg(-1));
+
+               if (shdr->sh_type == SHT_SYMTAB) {
+                       unsigned int nsyms;
+                       unsigned int n;
+                       Elf_Data *data = elf_getdata(scn, NULL);
+
+                       if (!data)
+                               error("elf_getdata failed: %s", elf_errmsg(-1));
+
+                       if (shdr->sh_entsize != sym_size)
+                               error("expected sh_entsize (%lu) to be %zu",
+                                     shdr->sh_entsize, sym_size);
+
+                       nsyms = shdr->sh_size / shdr->sh_entsize;
+
+                       for (n = 1; n < nsyms; ++n) {
+                               const char *name = NULL;
+                               Elf32_Word xndx = 0;
+                               GElf_Sym sym_mem;
+                               GElf_Sym *sym;
+
+                               sym = gelf_getsymshndx(data, xndx_data, n,
+                                                      &sym_mem, &xndx);
+                               if (!sym)
+                                       error("gelf_getsymshndx failed: %s",
+                                             elf_errmsg(-1));
+
+                               if (GELF_ST_BIND(sym->st_info) == STB_LOCAL)
+                                       continue;
+
+                               if (sym->st_shndx != SHN_XINDEX)
+                                       xndx = sym->st_shndx;
+
+                               name = elf_strptr(elf, shdr->sh_link,
+                                                 sym->st_name);
+                               if (!name)
+                                       error("elf_strptr failed: %s",
+                                             elf_errmsg(-1));
+
+                               /* Skip empty symbol names */
+                               if (*name)
+                                       func(name, sym, xndx, arg);
+                       }
+               }
+
+               scn = elf_nextscn(elf, scn);
+       }
+
+       check(elf_end(elf));
+}
+
+static void set_symbol_addr(struct symbol *sym, void *arg)
+{
+       struct symbol_addr *addr = arg;
+
+       if (sym->addr.section == SHN_UNDEF) {
+               sym->addr = *addr;
+               hash_add(symbol_addrs, &sym->addr_hash,
+                        symbol_addr_hash(&sym->addr));
+
+               debug("%s -> { %u, %lx }", sym->name, sym->addr.section,
+                     sym->addr.address);
+       } else if (sym->addr.section != addr->section ||
+                  sym->addr.address != addr->address) {
+               warn("multiple addresses for symbol %s?", sym->name);
+       }
+}
+
+static void elf_set_symbol_addr(const char *name, GElf_Sym *sym,
+                               Elf32_Word xndx, void *arg)
+{
+       struct symbol_addr addr = { .section = xndx, .address = sym->st_value };
+
+       /* Set addresses for exported symbols */
+       if (addr.section != SHN_UNDEF)
+               for_each(name, set_symbol_addr, &addr);
+}
+
+void symbol_read_symtab(int fd)
+{
+       elf_for_each_global(fd, elf_set_symbol_addr, NULL);
+}
+
 void symbol_free(void)
 {
        struct hlist_node *tmp;
@@ -94,5 +254,6 @@ void symbol_free(void)
                free(sym);
        }
 
+       hash_init(symbol_addrs);
        hash_init(symbol_names);
 }