MIRRORS/linux-yocto
1
0
Fork 0
mirror of git://git.yoctoproject.org/linux-yocto.git synced 2025-12-20 17:46:03 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

perf libbfd: Move libbfd functionality to its own file

Browse Source 
Move symbolization and srcline libbfd dependencies to a separate
libbfd.c. This mirrors moving llvm and capstone code. While this code
is deprecated as it is part of BUILD_NONDISTRO license incompatible
code, moving the code to its own file minimizes disruption in the main
files.

disasm_bpf.c is moved to libbfd.c also except for
symbol__disassemble_bpf_image which is currently more of a placeholder
function rather than something that provides disassembly support.

demangle-cxx.cpp code isn't migrated as it is very limited.

Signed-off-by: Ian Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Alexandre Ghiti <alexghiti@rivosinc.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Athira Rajeev <atrajeev@linux.ibm.com>
Cc: Bill Wendling <morbo@google.com>
Cc: Charlie Jenkins <charlie@rivosinc.com>
Cc: Collin Funk <collin.funk1@gmail.com>
Cc: Dmitriy Vyukov <dvyukov@google.com>
Cc: Dr. David Alan Gilbert <linux@treblig.org>
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: Haibo Xu <haibo1.xu@intel.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@linaro.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Justin Stitt <justinstitt@google.com>
Cc: Li Huafei <lihuafei1@huawei.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nick Desaulniers <nick.desaulniers+lkml@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Song Liu <song@kernel.org>
Cc: Stephen Brennan <stephen.s.brennan@oracle.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Ian Rogers 2025-09-29 12:07:54 -07:00 committed by Arnaldo Carvalho de Melo
parent d9007afca0
commit 95931d9a59
11 changed files with 718 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tools/perf/Makefile.config
View File

@ -941,6 +941,7 @@ ifdef BUILD_NONDISTRO
CFLAGS += -DHAVE_LIBBFD_SUPPORT CFLAGS += -DHAVE_LIBBFD_SUPPORT
CXXFLAGS += -DHAVE_LIBBFD_SUPPORT CXXFLAGS += -DHAVE_LIBBFD_SUPPORT
$(call detected,CONFIG_LIBBFD)
$(call feature_check,libbfd-buildid) $(call feature_check,libbfd-buildid)

2
tools/perf/util/Build
View File

@ -14,7 +14,6 @@ perf-util-y += copyfile.o
perf-util-y += ctype.o perf-util-y += ctype.o
perf-util-y += db-export.o perf-util-y += db-export.o
perf-util-y += disasm.o perf-util-y += disasm.o
perf-util-y += disasm_bpf.o
perf-util-y += env.o perf-util-y += env.o
perf-util-y += event.o perf-util-y += event.o
perf-util-y += evlist.o perf-util-y += evlist.o
@ -26,6 +25,7 @@ perf-util-y += evswitch.o
perf-util-y += find_bit.o perf-util-y += find_bit.o
perf-util-y += get_current_dir_name.o perf-util-y += get_current_dir_name.o
perf-util-y += levenshtein.o perf-util-y += levenshtein.o
perf-util-$(CONFIG_LIBBFD) += libbfd.o
perf-util-y += llvm.o perf-util-y += llvm.o
perf-util-y += mmap.o perf-util-y += mmap.o
perf-util-y += memswap.o perf-util-y += memswap.o

19
tools/perf/util/disasm.c
View File

@ -17,11 +17,11 @@
#include "capstone.h" #include "capstone.h"
#include "debug.h" #include "debug.h"
#include "disasm.h" #include "disasm.h"
#include "disasm_bpf.h"
#include "dso.h" #include "dso.h"
#include "dwarf-regs.h" #include "dwarf-regs.h"
#include "env.h" #include "env.h"
#include "evsel.h" #include "evsel.h"
#include "libbfd.h"
#include "llvm.h" #include "llvm.h"
#include "map.h" #include "map.h"
#include "maps.h" #include "maps.h"
@ -1480,6 +1480,23 @@ char *expand_tabs(char *line, char **storage, size_t *storage_len)
return new_line; return new_line;
} }
static int symbol__disassemble_bpf_image(struct symbol *sym, struct annotate_args *args)
{
struct annotation *notes = symbol__annotation(sym);
struct disasm_line *dl;
args->offset = -1;
args->line = strdup("to be implemented");
args->line_nr = 0;
args->fileloc = NULL;
dl = disasm_line__new(args);
if (dl)
annotation_line__add(&dl->al, &notes->src->source);
zfree(&args->line);
return 0;
}
static int symbol__disassemble_objdump(const char *filename, struct symbol *sym, static int symbol__disassemble_objdump(const char *filename, struct symbol *sym,
struct annotate_args *args) struct annotate_args *args)
{ {

195
tools/perf/util/disasm_bpf.c
View File

@ -1,195 +0,0 @@
// SPDX-License-Identifier: GPL-2.0-only
#include "util/annotate.h"
#include "util/disasm_bpf.h"
#include "util/symbol.h"
#include <linux/zalloc.h>
#include <string.h>
#if defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
#define PACKAGE "perf"
#include <bfd.h>
#include <bpf/bpf.h>
#include <bpf/btf.h>
#include <bpf/libbpf.h>
#include <dis-asm.h>
#include <errno.h>
#include <linux/btf.h>
#include <tools/dis-asm-compat.h>
#include "util/bpf-event.h"
#include "util/bpf-utils.h"
#include "util/debug.h"
#include "util/dso.h"
#include "util/map.h"
#include "util/env.h"
#include "util/util.h"
int symbol__disassemble_bpf(struct symbol *sym, struct annotate_args *args)
{
struct annotation *notes = symbol__annotation(sym);
struct bpf_prog_linfo *prog_linfo = NULL;
struct bpf_prog_info_node *info_node;
int len = sym->end - sym->start;
disassembler_ftype disassemble;
struct map *map = args->ms.map;
struct perf_bpil *info_linear;
struct disassemble_info info;
struct dso *dso = map__dso(map);
int pc = 0, count, sub_id;
struct btf *btf = NULL;
char tpath[PATH_MAX];
size_t buf_size;
int nr_skip = 0;
char *buf;
bfd *bfdf;
int ret;
FILE *s;
if (dso__binary_type(dso) != DSO_BINARY_TYPE__BPF_PROG_INFO)
return SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE;
pr_debug("%s: handling sym %s addr %" PRIx64 " len %" PRIx64 "\n", __func__,
sym->name, sym->start, sym->end - sym->start);
memset(tpath, 0, sizeof(tpath));
perf_exe(tpath, sizeof(tpath));
bfdf = bfd_openr(tpath, NULL);
if (bfdf == NULL)
abort();
if (!bfd_check_format(bfdf, bfd_object))
abort();
s = open_memstream(&buf, &buf_size);
if (!s) {
ret = errno;
goto out;
}
init_disassemble_info_compat(&info, s,
(fprintf_ftype) fprintf,
fprintf_styled);
info.arch = bfd_get_arch(bfdf);
info.mach = bfd_get_mach(bfdf);
info_node = perf_env__find_bpf_prog_info(dso__bpf_prog(dso)->env,
dso__bpf_prog(dso)->id);
if (!info_node) {
ret = SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF;
goto out;
}
info_linear = info_node->info_linear;
sub_id = dso__bpf_prog(dso)->sub_id;
info.buffer = (void *)(uintptr_t)(info_linear->info.jited_prog_insns);
info.buffer_length = info_linear->info.jited_prog_len;
if (info_linear->info.nr_line_info)
prog_linfo = bpf_prog_linfo__new(&info_linear->info);
if (info_linear->info.btf_id) {
struct btf_node *node;
node = perf_env__find_btf(dso__bpf_prog(dso)->env,
info_linear->info.btf_id);
if (node)
btf = btf__new((__u8 *)(node->data),
node->data_size);
}
disassemble_init_for_target(&info);
#ifdef DISASM_FOUR_ARGS_SIGNATURE
disassemble = disassembler(info.arch,
bfd_big_endian(bfdf),
info.mach,
bfdf);
#else
disassemble = disassembler(bfdf);
#endif
if (disassemble == NULL)
abort();
fflush(s);
do {
const struct bpf_line_info *linfo = NULL;
struct disasm_line *dl;
size_t prev_buf_size;
const char *srcline;
u64 addr;
addr = pc + ((u64 *)(uintptr_t)(info_linear->info.jited_ksyms))[sub_id];
count = disassemble(pc, &info);
if (prog_linfo)
linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo,
addr, sub_id,
nr_skip);
if (linfo && btf) {
srcline = btf__name_by_offset(btf, linfo->line_off);
nr_skip++;
} else
srcline = NULL;
fprintf(s, "\n");
prev_buf_size = buf_size;
fflush(s);
if (!annotate_opts.hide_src_code && srcline) {
args->offset = -1;
args->line = strdup(srcline);
args->line_nr = 0;
args->fileloc = NULL;
args->ms.sym = sym;
dl = disasm_line__new(args);
if (dl) {
annotation_line__add(&dl->al,
&notes->src->source);
}
}
args->offset = pc;
args->line = buf + prev_buf_size;
args->line_nr = 0;
args->fileloc = NULL;
args->ms.sym = sym;
dl = disasm_line__new(args);
if (dl)
annotation_line__add(&dl->al, &notes->src->source);
pc += count;
} while (count > 0 && pc < len);
ret = 0;
out:
free(prog_linfo);
btf__free(btf);
fclose(s);
bfd_close(bfdf);
return ret;
}
#else // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
int symbol__disassemble_bpf(struct symbol *sym __maybe_unused, struct annotate_args *args __maybe_unused)
{
return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF;
}
#endif // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
int symbol__disassemble_bpf_image(struct symbol *sym, struct annotate_args *args)
{
struct annotation *notes = symbol__annotation(sym);
struct disasm_line *dl;
args->offset = -1;
args->line = strdup("to be implemented");
args->line_nr = 0;
args->fileloc = NULL;
dl = disasm_line__new(args);
if (dl)
annotation_line__add(&dl->al, &notes->src->source);
zfree(&args->line);
return 0;
}

12
tools/perf/util/disasm_bpf.h
View File

@ -1,12 +0,0 @@
// SPDX-License-Identifier: GPL-2.0-only
#ifndef __PERF_DISASM_BPF_H
#define __PERF_DISASM_BPF_H
struct symbol;
struct annotate_args;
int symbol__disassemble_bpf(struct symbol *sym, struct annotate_args *args);
int symbol__disassemble_bpf_image(struct symbol *sym, struct annotate_args *args);
#endif /* __PERF_DISASM_BPF_H */

600
tools/perf/util/libbfd.c Normal file
View File

@ -0,0 +1,600 @@
// SPDX-License-Identifier: GPL-2.0
#include "libbfd.h"
#include "annotate.h"
#include "bpf-event.h"
#include "bpf-utils.h"
#include "debug.h"
#include "dso.h"
#include "env.h"
#include "map.h"
#include "srcline.h"
#include "symbol.h"
#include "symbol_conf.h"
#include "util.h"
#include <tools/dis-asm-compat.h>
#ifdef HAVE_LIBBPF_SUPPORT
#include <bpf/bpf.h>
#include <bpf/btf.h>
#endif
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#define PACKAGE "perf"
#include <bfd.h>
/*
* Implement addr2line using libbfd.
*/
struct a2l_data {
const char *input;
u64 addr;
bool found;
const char *filename;
const char *funcname;
unsigned int line;
bfd *abfd;
asymbol **syms;
};
static int bfd_error(const char *string)
{
const char *errmsg;
errmsg = bfd_errmsg(bfd_get_error());
fflush(stdout);
if (string)
pr_debug("%s: %s\n", string, errmsg);
else
pr_debug("%s\n", errmsg);
return -1;
}
static int slurp_symtab(bfd *abfd, struct a2l_data *a2l)
{
long storage;
long symcount;
asymbol **syms;
bfd_boolean dynamic = FALSE;
if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0)
return bfd_error(bfd_get_filename(abfd));
storage = bfd_get_symtab_upper_bound(abfd);
if (storage == 0L) {
storage = bfd_get_dynamic_symtab_upper_bound(abfd);
dynamic = TRUE;
}
if (storage < 0L)
return bfd_error(bfd_get_filename(abfd));
syms = malloc(storage);
if (dynamic)
symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
else
symcount = bfd_canonicalize_symtab(abfd, syms);
if (symcount < 0) {
free(syms);
return bfd_error(bfd_get_filename(abfd));
}
a2l->syms = syms;
return 0;
}
static void find_address_in_section(bfd *abfd, asection *section, void *data)
{
bfd_vma pc, vma;
bfd_size_type size;
struct a2l_data *a2l = data;
flagword flags;
if (a2l->found)
return;
#ifdef bfd_get_section_flags
flags = bfd_get_section_flags(abfd, section);
#else
flags = bfd_section_flags(section);
#endif
if ((flags & SEC_ALLOC) == 0)
return;
pc = a2l->addr;
#ifdef bfd_get_section_vma
vma = bfd_get_section_vma(abfd, section);
#else
vma = bfd_section_vma(section);
#endif
#ifdef bfd_get_section_size
size = bfd_get_section_size(section);
#else
size = bfd_section_size(section);
#endif
if (pc < vma || pc >= vma + size)
return;
a2l->found = bfd_find_nearest_line(abfd, section, a2l->syms, pc - vma,
&a2l->filename, &a2l->funcname,
&a2l->line);
if (a2l->filename && !strlen(a2l->filename))
a2l->filename = NULL;
}
static struct a2l_data *addr2line_init(const char *path)
{
bfd *abfd;
struct a2l_data *a2l = NULL;
abfd = bfd_openr(path, NULL);
if (abfd == NULL)
return NULL;
if (!bfd_check_format(abfd, bfd_object))
goto out;
a2l = zalloc(sizeof(*a2l));
if (a2l == NULL)
goto out;
a2l->abfd = abfd;
a2l->input = strdup(path);
if (a2l->input == NULL)
goto out;
if (slurp_symtab(abfd, a2l))
goto out;
return a2l;
out:
if (a2l) {
zfree((char **)&a2l->input);
free(a2l);
}
bfd_close(abfd);
return NULL;
}
static void addr2line_cleanup(struct a2l_data *a2l)
{
if (a2l->abfd)
bfd_close(a2l->abfd);
zfree((char **)&a2l->input);
zfree(&a2l->syms);
free(a2l);
}
static int inline_list__append_dso_a2l(struct dso *dso,
struct inline_node *node,
struct symbol *sym)
{
struct a2l_data *a2l = dso__a2l(dso);
struct symbol *inline_sym = new_inline_sym(dso, sym, a2l->funcname);
char *srcline = NULL;
if (a2l->filename)
srcline = srcline_from_fileline(a2l->filename, a2l->line);
return inline_list__append(inline_sym, srcline, node);
}
int libbfd__addr2line(const char *dso_name, u64 addr,
char **file, unsigned int *line, struct dso *dso,
bool unwind_inlines, struct inline_node *node,
struct symbol *sym)
{
int ret = 0;
struct a2l_data *a2l = dso__a2l(dso);
if (!a2l) {
a2l = addr2line_init(dso_name);
dso__set_a2l(dso, a2l);
}
if (a2l == NULL) {
if (!symbol_conf.disable_add2line_warn)
pr_warning("addr2line_init failed for %s\n", dso_name);
return 0;
}
a2l->addr = addr;
a2l->found = false;
bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
if (!a2l->found)
return 0;
if (unwind_inlines) {
int cnt = 0;
if (node && inline_list__append_dso_a2l(dso, node, sym))
return 0;
while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
&a2l->funcname, &a2l->line) &&
cnt++ < MAX_INLINE_NEST) {
if (a2l->filename && !strlen(a2l->filename))
a2l->filename = NULL;
if (node != NULL) {
if (inline_list__append_dso_a2l(dso, node, sym))
return 0;
// found at least one inline frame
ret = 1;
}
}
}
if (file) {
*file = a2l->filename ? strdup(a2l->filename) : NULL;
ret = *file ? 1 : 0;
}
if (line)
*line = a2l->line;
return ret;
}
void dso__free_a2l_libbfd(struct dso *dso)
{
struct a2l_data *a2l = dso__a2l(dso);
if (!a2l)
return;
addr2line_cleanup(a2l);
dso__set_a2l(dso, NULL);
}
static int bfd_symbols__cmpvalue(const void *a, const void *b)
{
const asymbol *as = *(const asymbol **)a, *bs = *(const asymbol **)b;
if (bfd_asymbol_value(as) != bfd_asymbol_value(bs))
return bfd_asymbol_value(as) - bfd_asymbol_value(bs);
return bfd_asymbol_name(as)[0] - bfd_asymbol_name(bs)[0];
}
static int bfd2elf_binding(asymbol *symbol)
{
if (symbol->flags & BSF_WEAK)
return STB_WEAK;
if (symbol->flags & BSF_GLOBAL)
return STB_GLOBAL;
if (symbol->flags & BSF_LOCAL)
return STB_LOCAL;
return -1;
}
int dso__load_bfd_symbols(struct dso *dso, const char *debugfile)
{
int err = -1;
long symbols_size, symbols_count, i;
asection *section;
asymbol **symbols, *sym;
struct symbol *symbol;
bfd *abfd;
u64 start, len;
abfd = bfd_openr(debugfile, NULL);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__,
dso__long_name(dso));
goto out_close;
}
if (bfd_get_flavour(abfd) == bfd_target_elf_flavour)
goto out_close;
symbols_size = bfd_get_symtab_upper_bound(abfd);
if (symbols_size == 0) {
bfd_close(abfd);
return 0;
}
if (symbols_size < 0)
goto out_close;
symbols = malloc(symbols_size);
if (!symbols)
goto out_close;
symbols_count = bfd_canonicalize_symtab(abfd, symbols);
if (symbols_count < 0)
goto out_free;
section = bfd_get_section_by_name(abfd, ".text");
if (section) {
for (i = 0; i < symbols_count; ++i) {
if (!strcmp(bfd_asymbol_name(symbols[i]), "__ImageBase") ||
!strcmp(bfd_asymbol_name(symbols[i]), "__image_base__"))
break;
}
if (i < symbols_count) {
/* PE symbols can only have 4 bytes, so use .text high bits */
u64 text_offset = (section->vma - (u32)section->vma)
+ (u32)bfd_asymbol_value(symbols[i]);
dso__set_text_offset(dso, text_offset);
dso__set_text_end(dso, (section->vma - text_offset) + section->size);
} else {
dso__set_text_offset(dso, section->vma - section->filepos);
dso__set_text_end(dso, section->filepos + section->size);
}
}
qsort(symbols, symbols_count, sizeof(asymbol *), bfd_symbols__cmpvalue);
#ifdef bfd_get_section
#define bfd_asymbol_section bfd_get_section
#endif
for (i = 0; i < symbols_count; ++i) {
sym = symbols[i];
section = bfd_asymbol_section(sym);
if (bfd2elf_binding(sym) < 0)
continue;
while (i + 1 < symbols_count &&
bfd_asymbol_section(symbols[i + 1]) == section &&
bfd2elf_binding(symbols[i + 1]) < 0)
i++;
if (i + 1 < symbols_count &&
bfd_asymbol_section(symbols[i + 1]) == section)
len = symbols[i + 1]->value - sym->value;
else
len = section->size - sym->value;
start = bfd_asymbol_value(sym) - dso__text_offset(dso);
symbol = symbol__new(start, len, bfd2elf_binding(sym), STT_FUNC,
bfd_asymbol_name(sym));
if (!symbol)
goto out_free;
symbols__insert(dso__symbols(dso), symbol);
}
#ifdef bfd_get_section
#undef bfd_asymbol_section
#endif
symbols__fixup_end(dso__symbols(dso), false);
symbols__fixup_duplicate(dso__symbols(dso));
dso__set_adjust_symbols(dso, true);
err = 0;
out_free:
free(symbols);
out_close:
bfd_close(abfd);
return err;
}
int libbfd__read_build_id(const char *filename, struct build_id *bid, bool block)
{
size_t size = sizeof(bid->data);
int err = -1, fd;
bfd *abfd;
fd = open(filename, block ? O_RDONLY : (O_RDONLY | O_NONBLOCK));
if (fd < 0)
return -1;
abfd = bfd_fdopenr(filename, /*target=*/NULL, fd);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
goto out_close;
}
if (!abfd->build_id || abfd->build_id->size > size)
goto out_close;
memcpy(bid->data, abfd->build_id->data, abfd->build_id->size);
memset(bid->data + abfd->build_id->size, 0, size - abfd->build_id->size);
err = bid->size = abfd->build_id->size;
out_close:
bfd_close(abfd);
return err;
}
int libbfd_filename__read_debuglink(const char *filename, char *debuglink,
size_t size)
{
int err = -1;
asection *section;
bfd *abfd;
abfd = bfd_openr(filename, NULL);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
goto out_close;
}
section = bfd_get_section_by_name(abfd, ".gnu_debuglink");
if (!section)
goto out_close;
if (section->size > size)
goto out_close;
if (!bfd_get_section_contents(abfd, section, debuglink, 0,
section->size))
goto out_close;
err = 0;
out_close:
bfd_close(abfd);
return err;
}
int symbol__disassemble_bpf(struct symbol *sym __maybe_unused,
struct annotate_args *args __maybe_unused)
{
#ifdef HAVE_LIBBPF_SUPPORT
struct annotation *notes = symbol__annotation(sym);
struct bpf_prog_linfo *prog_linfo = NULL;
struct bpf_prog_info_node *info_node;
int len = sym->end - sym->start;
disassembler_ftype disassemble;
struct map *map = args->ms.map;
struct perf_bpil *info_linear;
struct disassemble_info info;
struct dso *dso = map__dso(map);
int pc = 0, count, sub_id;
struct btf *btf = NULL;
char tpath[PATH_MAX];
size_t buf_size;
int nr_skip = 0;
char *buf;
bfd *bfdf;
int ret;
FILE *s;
if (dso__binary_type(dso) != DSO_BINARY_TYPE__BPF_PROG_INFO)
return SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE;
pr_debug("%s: handling sym %s addr %" PRIx64 " len %" PRIx64 "\n", __func__,
sym->name, sym->start, sym->end - sym->start);
memset(tpath, 0, sizeof(tpath));
perf_exe(tpath, sizeof(tpath));
bfdf = bfd_openr(tpath, NULL);
if (bfdf == NULL)
abort();
if (!bfd_check_format(bfdf, bfd_object))
abort();
s = open_memstream(&buf, &buf_size);
if (!s) {
ret = errno;
goto out;
}
init_disassemble_info_compat(&info, s,
(fprintf_ftype) fprintf,
fprintf_styled);
info.arch = bfd_get_arch(bfdf);
info.mach = bfd_get_mach(bfdf);
info_node = perf_env__find_bpf_prog_info(dso__bpf_prog(dso)->env,
dso__bpf_prog(dso)->id);
if (!info_node) {
ret = SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF;
goto out;
}
info_linear = info_node->info_linear;
sub_id = dso__bpf_prog(dso)->sub_id;
info.buffer = (void *)(uintptr_t)(info_linear->info.jited_prog_insns);
info.buffer_length = info_linear->info.jited_prog_len;
if (info_linear->info.nr_line_info)
prog_linfo = bpf_prog_linfo__new(&info_linear->info);
if (info_linear->info.btf_id) {
struct btf_node *node;
node = perf_env__find_btf(dso__bpf_prog(dso)->env,
info_linear->info.btf_id);
if (node)
btf = btf__new((__u8 *)(node->data),
node->data_size);
}
disassemble_init_for_target(&info);
#ifdef DISASM_FOUR_ARGS_SIGNATURE
disassemble = disassembler(info.arch,
bfd_big_endian(bfdf),
info.mach,
bfdf);
#else
disassemble = disassembler(bfdf);
#endif
if (disassemble == NULL)
abort();
fflush(s);
do {
const struct bpf_line_info *linfo = NULL;
struct disasm_line *dl;
size_t prev_buf_size;
const char *srcline;
u64 addr;
addr = pc + ((u64 *)(uintptr_t)(info_linear->info.jited_ksyms))[sub_id];
count = disassemble(pc, &info);
if (prog_linfo)
linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo,
addr, sub_id,
nr_skip);
if (linfo && btf) {
srcline = btf__name_by_offset(btf, linfo->line_off);
nr_skip++;
} else
srcline = NULL;
fprintf(s, "\n");
prev_buf_size = buf_size;
fflush(s);
if (!annotate_opts.hide_src_code && srcline) {
args->offset = -1;
args->line = strdup(srcline);
args->line_nr = 0;
args->fileloc = NULL;
args->ms.sym = sym;
dl = disasm_line__new(args);
if (dl) {
annotation_line__add(&dl->al,
&notes->src->source);
}
}
args->offset = pc;
args->line = buf + prev_buf_size;
args->line_nr = 0;
args->fileloc = NULL;
args->ms.sym = sym;
dl = disasm_line__new(args);
if (dl)
annotation_line__add(&dl->al, &notes->src->source);
pc += count;
} while (count > 0 && pc < len);
ret = 0;
out:
free(prog_linfo);
btf__free(btf);
fclose(s);
bfd_close(bfdf);
return ret;
#else
return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF;
#endif
}

83
tools/perf/util/libbfd.h Normal file
View File

@ -0,0 +1,83 @@
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __PERF_LIBBFD_H
#define __PERF_LIBBFD_H
#include <linux/compiler.h>
#include <linux/types.h>
#include <stdbool.h>
#include <stddef.h>
struct annotate_args;
struct build_id;
struct dso;
struct inline_node;
struct symbol;
#ifdef HAVE_LIBBFD_SUPPORT
int libbfd__addr2line(const char *dso_name, u64 addr,
char **file, unsigned int *line, struct dso *dso,
bool unwind_inlines, struct inline_node *node,
struct symbol *sym);
void dso__free_a2l_libbfd(struct dso *dso);
int symbol__disassemble_libbfd(const char *filename, struct symbol *sym,
struct annotate_args *args);
int libbfd__read_build_id(const char *filename, struct build_id *bid, bool block);
int libbfd_filename__read_debuglink(const char *filename, char *debuglink, size_t size);
int symbol__disassemble_bpf(struct symbol *sym, struct annotate_args *args);
#else // !defined(HAVE_LIBBFD_SUPPORT)
#include "annotate.h"
static inline int libbfd__addr2line(const char *dso_name __always_unused,
u64 addr __always_unused,
char **file __always_unused,
unsigned int *line __always_unused,
struct dso *dso __always_unused,
bool unwind_inlines __always_unused,
struct inline_node *node __always_unused,
struct symbol *sym __always_unused)
{
return -1;
}
static inline void dso__free_a2l_libbfd(struct dso *dso __always_unused)
{
}
static inline int symbol__disassemble_libbfd(const char *filename __always_unused,
struct symbol *sym __always_unused,
struct annotate_args *args __always_unused)
{
return -1;
}
static inline int libbfd__read_build_id(const char *filename __always_unused,
struct build_id *bid __always_unused,
bool block __always_unused)
{
return -1;
}
static inline int libbfd_filename__read_debuglink(const char *filename __always_unused,
char *debuglink __always_unused,
size_t size __always_unused)
{
return -1;
}
static inline int symbol__disassemble_bpf(struct symbol *sym __always_unused,
struct annotate_args *args __always_unused)
{
return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF;
}
#endif // defined(HAVE_LIBBFD_SUPPORT)
#endif /* __PERF_LIBBFD_H */

232
tools/perf/util/srcline.c
View File

@ -129,8 +129,6 @@ struct symbol *new_inline_sym(struct dso *dso,
return inline_sym; return inline_sym;
} }
#define MAX_INLINE_NEST 1024
#ifdef HAVE_LIBLLVM_SUPPORT #ifdef HAVE_LIBLLVM_SUPPORT
#include "llvm.h" #include "llvm.h"
@ -147,243 +145,19 @@ void dso__free_a2l(struct dso *dso)
dso__free_a2l_llvm(dso); dso__free_a2l_llvm(dso);
} }
#elif defined(HAVE_LIBBFD_SUPPORT) #elif defined(HAVE_LIBBFD_SUPPORT)
#include "libbfd.h"
/*
* Implement addr2line using libbfd.
*/
#define PACKAGE "perf"
#include <bfd.h>
struct a2l_data {
const char *input;
u64 addr;
bool found;
const char *filename;
const char *funcname;
unsigned line;
bfd *abfd;
asymbol **syms;
};
static int bfd_error(const char *string)
{
const char *errmsg;
errmsg = bfd_errmsg(bfd_get_error());
fflush(stdout);
if (string)
pr_debug("%s: %s\n", string, errmsg);
else
pr_debug("%s\n", errmsg);
return -1;
}
static int slurp_symtab(bfd *abfd, struct a2l_data *a2l)
{
long storage;
long symcount;
asymbol **syms;
bfd_boolean dynamic = FALSE;
if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0)
return bfd_error(bfd_get_filename(abfd));
storage = bfd_get_symtab_upper_bound(abfd);
if (storage == 0L) {
storage = bfd_get_dynamic_symtab_upper_bound(abfd);
dynamic = TRUE;
}
if (storage < 0L)
return bfd_error(bfd_get_filename(abfd));
syms = malloc(storage);
if (dynamic)
symcount = bfd_canonicalize_dynamic_symtab(abfd, syms);
else
symcount = bfd_canonicalize_symtab(abfd, syms);
if (symcount < 0) {
free(syms);
return bfd_error(bfd_get_filename(abfd));
}
a2l->syms = syms;
return 0;
}
static void find_address_in_section(bfd *abfd, asection *section, void *data)
{
bfd_vma pc, vma;
bfd_size_type size;
struct a2l_data *a2l = data;
flagword flags;
if (a2l->found)
return;
#ifdef bfd_get_section_flags
flags = bfd_get_section_flags(abfd, section);
#else
flags = bfd_section_flags(section);
#endif
if ((flags & SEC_ALLOC) == 0)
return;
pc = a2l->addr;
#ifdef bfd_get_section_vma
vma = bfd_get_section_vma(abfd, section);
#else
vma = bfd_section_vma(section);
#endif
#ifdef bfd_get_section_size
size = bfd_get_section_size(section);
#else
size = bfd_section_size(section);
#endif
if (pc < vma || pc >= vma + size)
return;
a2l->found = bfd_find_nearest_line(abfd, section, a2l->syms, pc - vma,
&a2l->filename, &a2l->funcname,
&a2l->line);
if (a2l->filename && !strlen(a2l->filename))
a2l->filename = NULL;
}
static struct a2l_data *addr2line_init(const char *path)
{
bfd *abfd;
struct a2l_data *a2l = NULL;
abfd = bfd_openr(path, NULL);
if (abfd == NULL)
return NULL;
if (!bfd_check_format(abfd, bfd_object))
goto out;
a2l = zalloc(sizeof(*a2l));
if (a2l == NULL)
goto out;
a2l->abfd = abfd;
a2l->input = strdup(path);
if (a2l->input == NULL)
goto out;
if (slurp_symtab(abfd, a2l))
goto out;
return a2l;
out:
if (a2l) {
zfree((char **)&a2l->input);
free(a2l);
}
bfd_close(abfd);
return NULL;
}
static void addr2line_cleanup(struct a2l_data *a2l)
{
if (a2l->abfd)
bfd_close(a2l->abfd);
zfree((char **)&a2l->input);
zfree(&a2l->syms);
free(a2l);
}
static int inline_list__append_dso_a2l(struct dso *dso,
struct inline_node *node,
struct symbol *sym)
{
struct a2l_data *a2l = dso__a2l(dso);
struct symbol *inline_sym = new_inline_sym(dso, sym, a2l->funcname);
char *srcline = NULL;
if (a2l->filename)
srcline = srcline_from_fileline(a2l->filename, a2l->line);
return inline_list__append(inline_sym, srcline, node);
}
static int addr2line(const char *dso_name, u64 addr, static int addr2line(const char *dso_name, u64 addr,
char **file, unsigned int *line, struct dso *dso, char **file, unsigned int *line, struct dso *dso,
bool unwind_inlines, struct inline_node *node, bool unwind_inlines, struct inline_node *node,
struct symbol *sym) struct symbol *sym)
{ {
int ret = 0; return libbfd__addr2line(dso_name, addr, file, line, dso, unwind_inlines, node, sym);
struct a2l_data *a2l = dso__a2l(dso);
if (!a2l) {
a2l = addr2line_init(dso_name);
dso__set_a2l(dso, a2l);
}
if (a2l == NULL) {
if (!symbol_conf.disable_add2line_warn)
pr_warning("addr2line_init failed for %s\n", dso_name);
return 0;
}
a2l->addr = addr;
a2l->found = false;
bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
if (!a2l->found)
return 0;
if (unwind_inlines) {
int cnt = 0;
if (node && inline_list__append_dso_a2l(dso, node, sym))
return 0;
while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
&a2l->funcname, &a2l->line) &&
cnt++ < MAX_INLINE_NEST) {
if (a2l->filename && !strlen(a2l->filename))
a2l->filename = NULL;
if (node != NULL) {
if (inline_list__append_dso_a2l(dso, node, sym))
return 0;
// found at least one inline frame
ret = 1;
}
}
}
if (file) {
*file = a2l->filename ? strdup(a2l->filename) : NULL;
ret = *file ? 1 : 0;
}
if (line)
*line = a2l->line;
return ret;
} }
void dso__free_a2l(struct dso *dso) void dso__free_a2l(struct dso *dso)
{ {
struct a2l_data *a2l = dso__a2l(dso); dso__free_a2l_libbfd(dso);
if (!a2l)
return;
addr2line_cleanup(a2l);
dso__set_a2l(dso, NULL);
} }
#else /* HAVE_LIBBFD_SUPPORT */ #else /* HAVE_LIBBFD_SUPPORT */

2
tools/perf/util/srcline.h
View File

@ -29,6 +29,8 @@ void srcline__tree_delete(struct rb_root_cached *tree);
extern char *srcline__unknown; extern char *srcline__unknown;
#define SRCLINE_UNKNOWN srcline__unknown #define SRCLINE_UNKNOWN srcline__unknown
#define MAX_INLINE_NEST 1024
struct inline_list { struct inline_list {
struct symbol *symbol; struct symbol *symbol;
char *srcline; char *srcline;

100
tools/perf/util/symbol-elf.c
View File

@ -9,6 +9,7 @@
#include "compress.h" #include "compress.h"
#include "dso.h" #include "dso.h"
#include "libbfd.h"
#include "map.h" #include "map.h"
#include "maps.h" #include "maps.h"
#include "symbol.h" #include "symbol.h"
@ -24,18 +25,6 @@
#include <symbol/kallsyms.h> #include <symbol/kallsyms.h>
#include <internal/lib.h> #include <internal/lib.h>
#ifdef HAVE_LIBBFD_SUPPORT
#define PACKAGE 'perf'
#include <bfd.h>
#endif
#if defined(HAVE_LIBBFD_SUPPORT) || defined(HAVE_CPLUS_DEMANGLE_SUPPORT)
#ifndef DMGL_PARAMS
#define DMGL_PARAMS (1 << 0) /* Include function args */
#define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */
#endif
#endif
#ifndef EM_AARCH64 #ifndef EM_AARCH64
#define EM_AARCH64 183 /* ARM 64 bit */ #define EM_AARCH64 183 /* ARM 64 bit */
#endif #endif
@ -871,47 +860,16 @@ out:
return err; return err;
} }
#ifdef HAVE_LIBBFD_BUILDID_SUPPORT
static int read_build_id(const char *filename, struct build_id *bid, bool block) static int read_build_id(const char *filename, struct build_id *bid, bool block)
{ {
size_t size = sizeof(bid->data); size_t size = sizeof(bid->data);
int err = -1, fd; int fd, err;
bfd *abfd;
fd = open(filename, block ? O_RDONLY : (O_RDONLY | O_NONBLOCK));
if (fd < 0)
return -1;
abfd = bfd_fdopenr(filename, /*target=*/NULL, fd);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
goto out_close;
}
if (!abfd->build_id || abfd->build_id->size > size)
goto out_close;
memcpy(bid->data, abfd->build_id->data, abfd->build_id->size);
memset(bid->data + abfd->build_id->size, 0, size - abfd->build_id->size);
err = bid->size = abfd->build_id->size;
out_close:
bfd_close(abfd);
return err;
}
#else // HAVE_LIBBFD_BUILDID_SUPPORT
static int read_build_id(const char *filename, struct build_id *bid, bool block)
{
size_t size = sizeof(bid->data);
int fd, err = -1;
Elf *elf; Elf *elf;
err = libbfd__read_build_id(filename, bid, block);
if (err >= 0)
goto out;
if (size < BUILD_ID_SIZE) if (size < BUILD_ID_SIZE)
goto out; goto out;
@ -936,8 +894,6 @@ out:
return err; return err;
} }
#endif // HAVE_LIBBFD_BUILDID_SUPPORT
int filename__read_build_id(const char *filename, struct build_id *bid, bool block) int filename__read_build_id(const char *filename, struct build_id *bid, bool block)
{ {
struct kmod_path m = { .name = NULL, }; struct kmod_path m = { .name = NULL, };
@ -1022,44 +978,6 @@ out:
return err; return err;
} }
#ifdef HAVE_LIBBFD_SUPPORT
int filename__read_debuglink(const char *filename, char *debuglink,
size_t size)
{
int err = -1;
asection *section;
bfd *abfd;
abfd = bfd_openr(filename, NULL);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__, filename);
goto out_close;
}
section = bfd_get_section_by_name(abfd, ".gnu_debuglink");
if (!section)
goto out_close;
if (section->size > size)
goto out_close;
if (!bfd_get_section_contents(abfd, section, debuglink, 0,
section->size))
goto out_close;
err = 0;
out_close:
bfd_close(abfd);
return err;
}
#else
int filename__read_debuglink(const char *filename, char *debuglink, int filename__read_debuglink(const char *filename, char *debuglink,
size_t size) size_t size)
{ {
@ -1071,6 +989,10 @@ int filename__read_debuglink(const char *filename, char *debuglink,
Elf_Scn *sec; Elf_Scn *sec;
Elf_Kind ek; Elf_Kind ek;
err = libbfd_filename__read_debuglink(filename, debuglink, size);
if (err >= 0)
goto out;
fd = open(filename, O_RDONLY); fd = open(filename, O_RDONLY);
if (fd < 0) if (fd < 0)
goto out; goto out;
@ -1112,8 +1034,6 @@ out:
return err; return err;
} }
#endif
bool symsrc__possibly_runtime(struct symsrc *ss) bool symsrc__possibly_runtime(struct symsrc *ss)
{ {
return ss->dynsym || ss->opdsec; return ss->dynsym || ss->opdsec;

131
tools/perf/util/symbol.c
View File

@ -1589,137 +1589,6 @@ out_failure:
return -1; return -1;
} }
#ifdef HAVE_LIBBFD_SUPPORT
#define PACKAGE 'perf'
#include <bfd.h>
static int bfd_symbols__cmpvalue(const void *a, const void *b)
{
const asymbol *as = *(const asymbol **)a, *bs = *(const asymbol **)b;
if (bfd_asymbol_value(as) != bfd_asymbol_value(bs))
return bfd_asymbol_value(as) - bfd_asymbol_value(bs);
return bfd_asymbol_name(as)[0] - bfd_asymbol_name(bs)[0];
}
static int bfd2elf_binding(asymbol *symbol)
{
if (symbol->flags & BSF_WEAK)
return STB_WEAK;
if (symbol->flags & BSF_GLOBAL)
return STB_GLOBAL;
if (symbol->flags & BSF_LOCAL)
return STB_LOCAL;
return -1;
}
int dso__load_bfd_symbols(struct dso *dso, const char *debugfile)
{
int err = -1;
long symbols_size, symbols_count, i;
asection *section;
asymbol **symbols, *sym;
struct symbol *symbol;
bfd *abfd;
u64 start, len;
abfd = bfd_openr(debugfile, NULL);
if (!abfd)
return -1;
if (!bfd_check_format(abfd, bfd_object)) {
pr_debug2("%s: cannot read %s bfd file.\n", __func__,
dso__long_name(dso));
goto out_close;
}
if (bfd_get_flavour(abfd) == bfd_target_elf_flavour)
goto out_close;
symbols_size = bfd_get_symtab_upper_bound(abfd);
if (symbols_size == 0) {
bfd_close(abfd);
return 0;
}
if (symbols_size < 0)
goto out_close;
symbols = malloc(symbols_size);
if (!symbols)
goto out_close;
symbols_count = bfd_canonicalize_symtab(abfd, symbols);
if (symbols_count < 0)
goto out_free;
section = bfd_get_section_by_name(abfd, ".text");
if (section) {
for (i = 0; i < symbols_count; ++i) {
if (!strcmp(bfd_asymbol_name(symbols[i]), "__ImageBase") ||
!strcmp(bfd_asymbol_name(symbols[i]), "__image_base__"))
break;
}
if (i < symbols_count) {
/* PE symbols can only have 4 bytes, so use .text high bits */
u64 text_offset = (section->vma - (u32)section->vma)
+ (u32)bfd_asymbol_value(symbols[i]);
dso__set_text_offset(dso, text_offset);
dso__set_text_end(dso, (section->vma - text_offset) + section->size);
} else {
dso__set_text_offset(dso, section->vma - section->filepos);
dso__set_text_end(dso, section->filepos + section->size);
}
}
qsort(symbols, symbols_count, sizeof(asymbol *), bfd_symbols__cmpvalue);
#ifdef bfd_get_section
#define bfd_asymbol_section bfd_get_section
#endif
for (i = 0; i < symbols_count; ++i) {
sym = symbols[i];
section = bfd_asymbol_section(sym);
if (bfd2elf_binding(sym) < 0)
continue;
while (i + 1 < symbols_count &&
bfd_asymbol_section(symbols[i + 1]) == section &&
bfd2elf_binding(symbols[i + 1]) < 0)
i++;
if (i + 1 < symbols_count &&
bfd_asymbol_section(symbols[i + 1]) == section)
len = symbols[i + 1]->value - sym->value;
else
len = section->size - sym->value;
start = bfd_asymbol_value(sym) - dso__text_offset(dso);
symbol = symbol__new(start, len, bfd2elf_binding(sym), STT_FUNC,
bfd_asymbol_name(sym));
if (!symbol)
goto out_free;
symbols__insert(dso__symbols(dso), symbol);
}
#ifdef bfd_get_section
#undef bfd_asymbol_section
#endif
symbols__fixup_end(dso__symbols(dso), false);
symbols__fixup_duplicate(dso__symbols(dso));
dso__set_adjust_symbols(dso, true);
err = 0;
out_free:
free(symbols);
out_close:
bfd_close(abfd);
return err;
}
#endif
static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod, static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
enum dso_binary_type type) enum dso_binary_type type)
{ {