objtool: Ignore extra-symbol code

There's a fun implementation detail on linking STB_WEAK symbols. When
the linker combines two translation units, where one contains a weak
function and the other an override for it. It simply strips the
STB_WEAK symbol from the symbol table, but doesn't actually remove the
code.

The result is that when objtool is ran in a whole-archive kind of way,
it will encounter *heaps* of unused (and unreferenced) code. All
rudiments of weak functions.

Additionally, when a weak implementation is split into a .cold
subfunction that .cold symbol is left in place, even though completely
unused.

Teach objtool to ignore such rudiments by searching for symbol holes;
that is, code ranges that fall outside the given symbol bounds.
Specifically, ignore a sequence of unreachable instruction iff they
occupy a single hole, additionally ignore any .cold subfunctions
referenced.

Both ld.bfd and ld.lld behave like this. LTO builds otoh can (and do)
properly DCE weak functions.

Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Josh Poimboeuf <jpoimboe@redhat.com>
Link: https://lore.kernel.org/r/20220308154319.232019347@infradead.org

diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index ae1d4f9..0e0e5b5 100644 (file)
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -3346,6 +3346,49 @@ static bool ignore_unreachable_insn(struct objtool_file *file, struct instructio
            !strcmp(insn->sec->name, ".altinstr_aux"))
                return true;
 
+       /*
+        * Whole archive runs might encounder dead code from weak symbols.
+        * This is where the linker will have dropped the weak symbol in
+        * favour of a regular symbol, but leaves the code in place.
+        *
+        * In this case we'll find a piece of code (whole function) that is not
+        * covered by a !section symbol. Ignore them.
+        */
+       if (!insn->func && lto) {
+               int size = find_symbol_hole_containing(insn->sec, insn->offset);
+               unsigned long end = insn->offset + size;
+
+               if (!size) /* not a hole */
+                       return false;
+
+               if (size < 0) /* hole until the end */
+                       return true;
+
+               sec_for_each_insn_continue(file, insn) {
+                       /*
+                        * If we reach a visited instruction at or before the
+                        * end of the hole, ignore the unreachable.
+                        */
+                       if (insn->visited)
+                               return true;
+
+                       if (insn->offset >= end)
+                               break;
+
+                       /*
+                        * If this hole jumps to a .cold function, mark it ignore too.
+                        */
+                       if (insn->jump_dest && insn->jump_dest->func &&
+                           strstr(insn->jump_dest->func->name, ".cold")) {
+                               struct instruction *dest = insn->jump_dest;
+                               func_for_each_insn(file, dest->func, dest)
+                                       dest->ignore = true;
+                       }
+               }
+
+               return false;
+       }
+
        if (!insn->func)
                return false;
 

diff --git a/tools/objtool/elf.c b/tools/objtool/elf.c
index 456ac22..d7b99a7 100644 (file)
--- a/tools/objtool/elf.c
+++ b/tools/objtool/elf.c
@@ -83,6 +83,31 @@ static int symbol_by_offset(const void *key, const struct rb_node *node)
        return 0;
 }
 
+struct symbol_hole {
+       unsigned long key;
+       const struct symbol *sym;
+};
+
+/*
+ * Find !section symbol where @offset is after it.
+ */
+static int symbol_hole_by_offset(const void *key, const struct rb_node *node)
+{
+       const struct symbol *s = rb_entry(node, struct symbol, node);
+       struct symbol_hole *sh = (void *)key;
+
+       if (sh->key < s->offset)
+               return -1;
+
+       if (sh->key >= s->offset + s->len) {
+               if (s->type != STT_SECTION)
+                       sh->sym = s;
+               return 1;
+       }
+
+       return 0;
+}
+
 struct section *find_section_by_name(const struct elf *elf, const char *name)
 {
        struct section *sec;
@@ -162,6 +187,41 @@ struct symbol *find_symbol_containing(const struct section *sec, unsigned long o
        return NULL;
 }
 
+/*
+ * Returns size of hole starting at @offset.
+ */
+int find_symbol_hole_containing(const struct section *sec, unsigned long offset)
+{
+       struct symbol_hole hole = {
+               .key = offset,
+               .sym = NULL,
+       };
+       struct rb_node *n;
+       struct symbol *s;
+
+       /*
+        * Find the rightmost symbol for which @offset is after it.
+        */
+       n = rb_find(&hole, &sec->symbol_tree, symbol_hole_by_offset);
+
+       /* found a symbol that contains @offset */
+       if (n)
+               return 0; /* not a hole */
+
+       /* didn't find a symbol for which @offset is after it */
+       if (!hole.sym)
+               return 0; /* not a hole */
+
+       /* @offset >= sym->offset + sym->len, find symbol after it */
+       n = rb_next(&hole.sym->node);
+       if (!n)
+               return -1; /* until end of address space */
+
+       /* hole until start of next symbol */
+       s = rb_entry(n, struct symbol, node);
+       return s->offset - offset;
+}
+
 struct symbol *find_func_containing(struct section *sec, unsigned long offset)
 {
        struct rb_node *node;

diff --git a/tools/objtool/include/objtool/elf.h b/tools/objtool/include/objtool/elf.h
index d223367..22ba7e2 100644 (file)
--- a/tools/objtool/include/objtool/elf.h
+++ b/tools/objtool/include/objtool/elf.h
@@ -152,6 +152,7 @@ struct symbol *find_func_by_offset(struct section *sec, unsigned long offset);
 struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset);
 struct symbol *find_symbol_by_name(const struct elf *elf, const char *name);
 struct symbol *find_symbol_containing(const struct section *sec, unsigned long offset);
+int find_symbol_hole_containing(const struct section *sec, unsigned long offset);
 struct reloc *find_reloc_by_dest(const struct elf *elf, struct section *sec, unsigned long offset);
 struct reloc *find_reloc_by_dest_range(const struct elf *elf, struct section *sec,
                                     unsigned long offset, unsigned int len);