Commit 5d859dff authored by Alexandre Chartre's avatar Alexandre Chartre Committed by Peter Zijlstra
Browse files

objtool: Print symbol during disassembly 



Print symbols referenced during disassembly instead of just printing
raw addresses. Also handle address relocation.

Signed-off-by: default avatarAlexandre Chartre <alexandre.chartre@oracle.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: default avatarJosh Poimboeuf <jpoimboe@kernel.org>
Link: https://patch.msgid.link/20251121095340.464045-6-alexandre.chartre@oracle.com
parent f348a44c

tools/objtool/check.c

+0 −9
Original line number Diff line number Diff line
@@ -134,15 +134,6 @@ static struct instruction *prev_insn_same_sym(struct objtool_file *file, 
	for (insn = next_insn_same_sec(file, insn); insn;		\

	     insn = next_insn_same_sec(file, insn))



static inline struct symbol *insn_call_dest(struct instruction *insn)

{

	if (insn->type == INSN_JUMP_DYNAMIC ||

	    insn->type == INSN_CALL_DYNAMIC)

		return NULL;



	return insn->_call_dest;

}



static inline struct reloc *insn_jump_table(struct instruction *insn)

{

	if (insn->type == INSN_JUMP_DYNAMIC ||

tools/objtool/disas.c

+134 −0
Original line number Diff line number Diff line
@@ -14,13 +14,144 @@ 


struct disas_context {

	struct objtool_file *file;

	struct instruction *insn;

	disassembler_ftype disassembler;

	struct disassemble_info info;

};



static int sprint_name(char *str, const char *name, unsigned long offset)

{

	int len;



	if (offset)

		len = sprintf(str, "%s+0x%lx", name, offset);

	else

		len = sprintf(str, "%s", name);



	return len;

}



#define DINFO_FPRINTF(dinfo, ...)	\

	((*(dinfo)->fprintf_func)((dinfo)->stream, __VA_ARGS__))



static void disas_print_addr_sym(struct section *sec, struct symbol *sym,

				 bfd_vma addr, struct disassemble_info *dinfo)

{

	char symstr[1024];

	char *str;



	if (sym) {

		sprint_name(symstr, sym->name, addr - sym->offset);

		DINFO_FPRINTF(dinfo, "0x%lx <%s>", addr, symstr);

	} else {

		str = offstr(sec, addr);

		DINFO_FPRINTF(dinfo, "0x%lx <%s>", addr, str);

		free(str);

	}

}



static void disas_print_addr_noreloc(bfd_vma addr,

				     struct disassemble_info *dinfo)

{

	struct disas_context *dctx = dinfo->application_data;

	struct instruction *insn = dctx->insn;

	struct symbol *sym = NULL;



	if (insn->sym && addr >= insn->sym->offset &&

	    addr < insn->sym->offset + insn->sym->len) {

		sym = insn->sym;

	}



	disas_print_addr_sym(insn->sec, sym, addr, dinfo);

}



static void disas_print_addr_reloc(bfd_vma addr, struct disassemble_info *dinfo)

{

	struct disas_context *dctx = dinfo->application_data;

	struct instruction *insn = dctx->insn;

	unsigned long offset;

	struct reloc *reloc;

	char symstr[1024];

	char *str;



	reloc = find_reloc_by_dest_range(dctx->file->elf, insn->sec,

					 insn->offset, insn->len);

	if (!reloc) {

		/*

		 * There is no relocation for this instruction although

		 * the address to resolve points to the next instruction.

		 * So this is an effective reference to the next IP, for

		 * example: "lea 0x0(%rip),%rdi". The kernel can reference

		 * the next IP with _THIS_IP_ macro.

		 */

		DINFO_FPRINTF(dinfo, "0x%lx <_THIS_IP_>", addr);

		return;

	}



	offset = arch_insn_adjusted_addend(insn, reloc);



	/*

	 * If the relocation symbol is a section name (for example ".bss")

	 * then we try to further resolve the name.

	 */

	if (reloc->sym->type == STT_SECTION) {

		str = offstr(reloc->sym->sec, reloc->sym->offset + offset);

		DINFO_FPRINTF(dinfo, "0x%lx <%s>", addr, str);

		free(str);

	} else {

		sprint_name(symstr, reloc->sym->name, offset);

		DINFO_FPRINTF(dinfo, "0x%lx <%s>", addr, symstr);

	}

}



/*

 * Resolve an address into a "<symbol>+<offset>" string.

 */

static void disas_print_address(bfd_vma addr, struct disassemble_info *dinfo)

{

	struct disas_context *dctx = dinfo->application_data;

	struct instruction *insn = dctx->insn;

	struct instruction *jump_dest;

	struct symbol *sym;

	bool is_reloc;



	/*

	 * If the instruction is a call/jump and it references a

	 * destination then this is likely the address we are looking

	 * up. So check it first.

	 */

	jump_dest = insn->jump_dest;

	if (jump_dest && jump_dest->sym && jump_dest->offset == addr) {

		disas_print_addr_sym(jump_dest->sec, jump_dest->sym,

				     addr, dinfo);

		return;

	}



	/*

	 * If the address points to the next instruction then there is

	 * probably a relocation. It can be a false positive when the

	 * current instruction is referencing the address of the next

	 * instruction. This particular case will be handled in

	 * disas_print_addr_reloc().

	 */

	is_reloc = (addr == insn->offset + insn->len);



	/*

	 * The call destination offset can be the address we are looking

	 * up, or 0 if there is a relocation.

	 */

	sym = insn_call_dest(insn);

	if (sym && (sym->offset == addr || (sym->offset == 0 && is_reloc))) {

		DINFO_FPRINTF(dinfo, "0x%lx <%s>", addr, sym->name);

		return;

	}



	if (!is_reloc)

		disas_print_addr_noreloc(addr, dinfo);

	else

		disas_print_addr_reloc(addr, dinfo);

}



/*

 * Initialize disassemble info arch, mach (32 or 64-bit) and options.

 */
@@ -69,6 +200,7 @@ struct disas_context *disas_context_create(struct objtool_file *file) 
				     fprintf_styled);



	dinfo->read_memory_func = buffer_read_memory;

	dinfo->print_address_func = disas_print_address;

	dinfo->application_data = dctx;



	/*
@@ -121,6 +253,8 @@ static size_t disas_insn(struct disas_context *dctx, 
	disassembler_ftype disasm = dctx->disassembler;

	struct disassemble_info *dinfo = &dctx->info;



	dctx->insn = insn;



	if (insn->type == INSN_NOP) {

		DINFO_FPRINTF(dinfo, "nop%d", insn->len);

		return insn->len;

tools/objtool/include/objtool/check.h

+9 −0
Original line number Diff line number Diff line
@@ -117,6 +117,15 @@ static inline bool is_jump(struct instruction *insn) 
	return is_static_jump(insn) || is_dynamic_jump(insn);

}



static inline struct symbol *insn_call_dest(struct instruction *insn)

{

	if (insn->type == INSN_JUMP_DYNAMIC ||

	    insn->type == INSN_CALL_DYNAMIC)

		return NULL;



	return insn->_call_dest;

}



struct instruction *find_insn(struct objtool_file *file,

			      struct section *sec, unsigned long offset);