Commit 4adb2368 authored by Peter Zijlstra's avatar Peter Zijlstra
Browse files

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: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: default avatarJosh Poimboeuf <jpoimboe@redhat.com>
Link: https://lore.kernel.org/r/20220308154319.232019347@infradead.org
parent 53f7109e

tools/objtool/check.c

+43 −0
Original line number Diff line number Diff line
@@ -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;

tools/objtool/elf.c

+60 −0
Original line number Diff line number Diff line
@@ -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;

tools/objtool/include/objtool/elf.h

+1 −0
Original line number Diff line number Diff line
@@ -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);