Commit 95931d9a authored by Ian Rogers's avatar Ian Rogers Committed by Arnaldo Carvalho de Melo
Browse files

perf libbfd: Move libbfd functionality to its own file 



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: default avatarIan 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: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent d9007afc

tools/perf/Makefile.config

+1 −0
Original line number Diff line number Diff line
@@ -941,6 +941,7 @@ ifdef BUILD_NONDISTRO 


  CFLAGS += -DHAVE_LIBBFD_SUPPORT

  CXXFLAGS += -DHAVE_LIBBFD_SUPPORT

  $(call detected,CONFIG_LIBBFD)



  $(call feature_check,libbfd-buildid)

tools/perf/util/Build

+1 −1
Original line number Diff line number Diff line
@@ -14,7 +14,6 @@ perf-util-y += copyfile.o 
perf-util-y += ctype.o

perf-util-y += db-export.o

perf-util-y += disasm.o

perf-util-y += disasm_bpf.o

perf-util-y += env.o

perf-util-y += event.o

perf-util-y += evlist.o
@@ -26,6 +25,7 @@ perf-util-y += evswitch.o 
perf-util-y += find_bit.o

perf-util-y += get_current_dir_name.o

perf-util-y += levenshtein.o

perf-util-$(CONFIG_LIBBFD) += libbfd.o

perf-util-y += llvm.o

perf-util-y += mmap.o

perf-util-y += memswap.o

tools/perf/util/disasm.c

+18 −1
Original line number Diff line number Diff line
@@ -17,11 +17,11 @@ 
#include "capstone.h"

#include "debug.h"

#include "disasm.h"

#include "disasm_bpf.h"

#include "dso.h"

#include "dwarf-regs.h"

#include "env.h"

#include "evsel.h"

#include "libbfd.h"

#include "llvm.h"

#include "map.h"

#include "maps.h"
@@ -1480,6 +1480,23 @@ char *expand_tabs(char *line, char **storage, size_t *storage_len) 
	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,

				       struct annotate_args *args)

{

tools/perf/util/disasm_bpf.c

deleted100644 → 0
+0 −195
Original line number Diff line number Diff line 
// 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;

}

tools/perf/util/disasm_bpf.h

deleted100644 → 0
+0 −12
Original line number Diff line number Diff line 
// 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 */