// SPDX-License-Identifier: GPL-2.0
#include "dso.h"
#include "libdw.h"
#include "srcline.h"
#include "symbol.h"
#include "dwarf-aux.h"
#include "callchain.h"
#include <fcntl.h>
#include <unistd.h>
#include <elfutils/libdwfl.h>

static const Dwfl_Callbacks offline_callbacks = {
	.find_debuginfo = dwfl_standard_find_debuginfo,
	.section_address = dwfl_offline_section_address,
	.find_elf = dwfl_build_id_find_elf,
};

void dso__free_libdw(struct dso *dso)
{
	Dwfl *dwfl = dso__libdw(dso);

	if (dwfl) {
		dwfl_end(dwfl);
		dso__set_libdw(dso, NULL);
	}
}

struct Dwfl *dso__libdw_dwfl(struct dso *dso)
{
	Dwfl *dwfl = dso__libdw(dso);
	const char *dso_name;
	Dwfl_Module *mod;
	int fd;

	if (dwfl)
		return dwfl;

	dso_name = dso__long_name(dso);
	/*
	 * Initialize Dwfl session.
	 * We need to open the DSO file to report it to libdw.
	 */
	fd = open(dso_name, O_RDONLY);
	if (fd < 0)
		return NULL;

	dwfl = dwfl_begin(&offline_callbacks);
	if (!dwfl) {
		close(fd);
		return NULL;
	}

	/*
	 * If the report is successful, the file descriptor fd is consumed
	 * and closed by the Dwfl. If not, it is not closed.
	 */
	mod = dwfl_report_offline(dwfl, dso_name, dso_name, fd);
	if (!mod) {
		dwfl_end(dwfl);
		close(fd);
		return NULL;
	}

	if (dwfl_report_end(dwfl, /*removed=*/NULL, /*arg=*/NULL) != 0) {
		dwfl_end(dwfl);
		return NULL;
	}
	dso__set_libdw(dso, dwfl);

	return dwfl;
}

struct libdw_a2l_cb_args {
	struct dso *dso;
	struct symbol *sym;
	struct inline_node *node;
	char *leaf_srcline;
	bool leaf_srcline_used;
	int err;
};

static int libdw_a2l_cb(Dwarf_Die *die, void *_args)
{
	struct libdw_a2l_cb_args *args  = _args;
	const char *call_fname = die_get_call_file(die);
	int call_lineno = die_get_call_lineno(die);
	char *call_srcline = srcline__unknown;
	struct symbol *inline_sym;

	if (dwarf_tag(die) == DW_TAG_subprogram && args->sym) {
		/*
		 * cu_walk_functions_at() opens the walk with the
		 * containing DW_TAG_subprogram DIE (the non-inlined outer
		 * function). That's just the base symbol -- use it
		 * directly. Avoids a fragile name-vs-name compare in
		 * new_inline_sym() that misfires when GCC IPA passes
		 * (.isra/.constprop/.part/.cold) rename the ELF symbol
		 * while DWARF keeps the pre-clone linkage name, which
		 * left the outer frame spuriously tagged "(inlined)".
		 */
		inline_sym = args->sym;
	} else {
		/*
		 * Prefer DW_AT_linkage_name so C++ inline frames keep
		 * their namespace/class qualification. new_inline_sym()
		 * runs the name through dso__demangle_sym(), so the
		 * mangled linkage name is turned back into
		 * "Namespace::Class::method". Fall back to DW_AT_name
		 * (unqualified) when no linkage name is present, e.g.
		 * for C code or extern "C" functions.
		 */
		const char *funcname = die_get_linkage_name(die) ?: die_name(die);

		inline_sym = new_inline_sym(args->dso, args->sym, funcname);
		if (!inline_sym)
			goto abort_enomem;
	}

	/* Assign caller information to the parent. */
	if (call_fname)
		call_srcline = srcline_from_fileline(call_fname, call_lineno >= 0 ? call_lineno : 0);

	if (!list_empty(&args->node->val)) {
		struct inline_list *parent;

		if (callchain_param.order == ORDER_CALLEE)
			parent = list_first_entry(&args->node->val, struct inline_list, list);
		else
			parent = list_last_entry(&args->node->val, struct inline_list, list);

		if (args->leaf_srcline == parent->srcline)
			args->leaf_srcline_used = false;
		else if (parent->srcline != srcline__unknown)
			free(parent->srcline);
		parent->srcline = call_srcline;
		call_srcline = NULL;
	}
	if (call_srcline && call_srcline != srcline__unknown)
		free(call_srcline);

	/* Add this symbol to the chain as the leaf. */
	if (!args->leaf_srcline_used) {
		if (inline_list__append_tail(inline_sym, args->leaf_srcline, args->node) != 0)
			goto abort_delete_sym;
		args->leaf_srcline_used = true;
	} else {
		char *srcline = strdup(args->leaf_srcline);

		if (!srcline)
			goto abort_delete_sym;
		if (inline_list__append_tail(inline_sym, srcline, args->node) != 0) {
			free(srcline);
			goto abort_delete_sym;
		}
	}
	return 0;

abort_delete_sym:
	if (symbol__inlined(inline_sym))
		symbol__delete(inline_sym);
abort_enomem:
	args->err = -ENOMEM;
	return DWARF_CB_ABORT;
}

int libdw__addr2line(u64 addr, char **file, unsigned int *line_nr,
		     struct dso *dso, bool unwind_inlines,
		     struct inline_node *node, struct symbol *sym)
{
	Dwfl *dwfl = dso__libdw_dwfl(dso);
	Dwfl_Module *mod;
	Dwfl_Line *dwline;
	Dwarf_Addr bias;
	const char *src;
	int lineno = 0;

	if (!dwfl)
		return 0;

	mod = dwfl_addrmodule(dwfl, addr);
	if (!mod)
		return 0;

	/*
	 * Get/ignore the dwarf information. Determine the bias, difference
	 * between the regular ELF addr2line addresses and those to use with
	 * libdw.
	 */
	if (!dwfl_module_getdwarf(mod, &bias))
		return 0;

	/* Find source line information for the address. */
	dwline = dwfl_module_getsrc(mod, addr + bias);
	if (!dwline)
		return 0;

	/* Get line information. */
	src = dwfl_lineinfo(dwline, /*addr=*/NULL, &lineno, /*col=*/NULL, /*mtime=*/NULL,
			    /*length=*/NULL);

	if (file)
		*file = src ? strdup(src) : NULL;
	if (line_nr)
		*line_nr = lineno;

	/* Optionally unwind inline function call chain. */
	if (unwind_inlines && node) {
		Dwarf_Addr unused_bias;
		Dwarf_Die *cudie = dwfl_module_addrdie(mod, addr + bias, &unused_bias);
		struct libdw_a2l_cb_args args = {
			.dso = dso,
			.sym = sym,
			.node = node,
			.leaf_srcline = srcline_from_fileline(src ?: "<unknown>", lineno),
		};

		if (!args.leaf_srcline) {
			if (file && *file) {
				free(*file);
				*file = NULL;
			}
			return 0;
		}

		/* Walk from the parent down to the leaf. */
		if (cudie)
			cu_walk_functions_at(cudie, addr, libdw_a2l_cb, &args);

		if (!args.leaf_srcline_used)
			free(args.leaf_srcline);

		if (args.err) {
			if (file && *file) {
				free(*file);
				*file = NULL;
			}
			inline_node__clear_frames(node);
			return 0;
		}
	}
	return 1;
}