/* Reverse search */
int debuginfo__find_probe_point(struct debuginfo *self, unsigned long addr,
struct perf_probe_point *ppt)
{
Dwarf_Die cudie, spdie, indie;
Dwarf_Addr _addr, baseaddr;
const char *fname = NULL, *func = NULL, *tmp;
int baseline = 0, lineno = 0, ret = 0;
/* Adjust address with bias */
addr += self->bias;
/* Find cu die */
if (!dwarf_addrdie(self->dbg, (Dwarf_Addr)addr - self->bias, &cudie)) {
pr_warning("Failed to find debug information for address %lx\n",
addr);
ret = -EINVAL;
goto end;
}
/* Find a corresponding line (filename and lineno) */
cu_find_lineinfo(&cudie, addr, &fname, &lineno);
/* Don't care whether it failed or not */
/* Find a corresponding function (name, baseline and baseaddr) */
if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
/* Get function entry information */
tmp = dwarf_diename(&spdie);
if (!tmp ||
dwarf_entrypc(&spdie, &baseaddr) != 0 ||
dwarf_decl_line(&spdie, &baseline) != 0)
goto post;
func = tmp;
if (addr == (unsigned long)baseaddr)
/* Function entry - Relative line number is 0 */
lineno = baseline;
else if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
&indie)) {
if (dwarf_entrypc(&indie, &_addr) == 0 &&
_addr == addr)
/*
* addr is at an inline function entry.
* In this case, lineno should be the call-site
* line number.
*/
lineno = die_get_call_lineno(&indie);
else {
/*
* addr is in an inline function body.
* Since lineno points one of the lines
* of the inline function, baseline should
* be the entry line of the inline function.
*/
tmp = dwarf_diename(&indie);
if (tmp &&
dwarf_decl_line(&spdie, &baseline) == 0)
func = tmp;
}
}
}
post:
/* Make a relative line number or an offset */
if (lineno)
ppt->line = lineno - baseline;
else if (func)
ppt->offset = addr - (unsigned long)baseaddr;
/* Duplicate strings */
if (func) {
ppt->function = strdup(func);
if (ppt->function == NULL) {
ret = -ENOMEM;
goto end;
}
}
if (fname) {
ppt->file = strdup(fname);
if (ppt->file == NULL) {
if (ppt->function) {
free(ppt->function);
ppt->function = NULL;
}
ret = -ENOMEM;
goto end;
}
}
end:
if (ret == 0 && (fname || func))
ret = 1; /* Found a point */
return ret;
}
/* Search function from function name */
static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
{
struct dwarf_callback_param *param = data;
struct probe_finder *pf = param->data;
struct perf_probe_point *pp = &pf->pev->point;
/* Check tag and diename */
if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
!die_compare_name(sp_die, pp->function))
return DWARF_CB_OK;
pf->fname = dwarf_decl_file(sp_die);
if (pp->line) { /* Function relative line */
dwarf_decl_line(sp_die, &pf->lno);
pf->lno += pp->line;
param->retval = find_probe_point_by_line(pf);
} else if (!dwarf_func_inline(sp_die)) {
/* Real function */
if (pp->lazy_line)
param->retval = find_probe_point_lazy(sp_die, pf);
else {
if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
pr_warning("Failed to get entry address of "
"%s.\n", dwarf_diename(sp_die));
param->retval = -ENOENT;
return DWARF_CB_ABORT;
}
pf->addr += pp->offset;
/* TODO: Check the address in this function */
param->retval = call_probe_finder(sp_die, pf);
}
} else {
struct dwarf_callback_param _param = {.data = (void *)pf,
.retval = 0};
/* Inlined function: search instances */
dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
&_param);
param->retval = _param.retval;
}
return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
}
static int find_probe_point_by_func(struct probe_finder *pf)
{
struct dwarf_callback_param _param = {.data = (void *)pf,
.retval = 0};
dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
return _param.retval;
}
/* Find probe points from debuginfo */
static int find_probes(int fd, struct probe_finder *pf)
{
struct perf_probe_point *pp = &pf->pev->point;
Dwarf_Off off, noff;
size_t cuhl;
Dwarf_Die *diep;
Dwarf *dbg = NULL;
Dwfl *dwfl;
Dwarf_Addr bias; /* Currently ignored */
int ret = 0;
dbg = dwfl_init_offline_dwarf(fd, &dwfl, &bias);
if (!dbg) {
pr_warning("No debug information found in the vmlinux - "
"please rebuild with CONFIG_DEBUG_INFO=y.\n");
return -EBADF;
}
#if _ELFUTILS_PREREQ(0, 142)
/* Get the call frame information from this dwarf */
pf->cfi = dwarf_getcfi(dbg);
#endif
off = 0;
line_list__init(&pf->lcache);
/* Loop on CUs (Compilation Unit) */
while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
/* Get the DIE(Debugging Information Entry) of this CU */
diep = dwarf_offdie(dbg, off + cuhl, &pf->cu_die);
if (!diep)
continue;
/* Check if target file is included. */
if (pp->file)
pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
else
pf->fname = NULL;
if (!pp->file || pf->fname) {
if (pp->function)
ret = find_probe_point_by_func(pf);
else if (pp->lazy_line)
ret = find_probe_point_lazy(NULL, pf);
else {
pf->lno = pp->line;
ret = find_probe_point_by_line(pf);
}
if (ret < 0)
break;
}
off = noff;
}
line_list__free(&pf->lcache);
if (dwfl)
dwfl_end(dwfl);
return ret;
}
/* Add a found probe point into trace event list */
static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
{
struct trace_event_finder *tf =
container_of(pf, struct trace_event_finder, pf);
struct probe_trace_event *tev;
int ret, i;
/* Check number of tevs */
if (tf->ntevs == tf->max_tevs) {
pr_warning("Too many( > %d) probe point found.\n",
tf->max_tevs);
return -ERANGE;
}
tev = &tf->tevs[tf->ntevs++];
ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
&tev->point);
if (ret < 0)
return ret;
pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
tev->point.offset);
/* Find each argument */
tev->nargs = pf->pev->nargs;
tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
if (tev->args == NULL)
return -ENOMEM;
for (i = 0; i < pf->pev->nargs; i++) {
pf->pvar = &pf->pev->args[i];
pf->tvar = &tev->args[i];
ret = find_variable(sp_die, pf);
if (ret != 0)
return ret;
}
return 0;
}
/* Find probe_trace_events specified by perf_probe_event from debuginfo */
int find_probe_trace_events(int fd, struct perf_probe_event *pev,
struct probe_trace_event **tevs, int max_tevs)
{
struct trace_event_finder tf = {
.pf = {.pev = pev, .callback = add_probe_trace_event},
.max_tevs = max_tevs};
int ret;
/* Allocate result tevs array */
*tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
if (*tevs == NULL)
return -ENOMEM;
tf.tevs = *tevs;
tf.ntevs = 0;
ret = find_probes(fd, &tf.pf);
if (ret < 0) {
free(*tevs);
*tevs = NULL;
return ret;
}
return (ret < 0) ? ret : tf.ntevs;
}
#define MAX_VAR_LEN 64
/* Collect available variables in this scope */
static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
{
struct available_var_finder *af = data;
struct variable_list *vl;
char buf[MAX_VAR_LEN];
int tag, ret;
vl = &af->vls[af->nvls - 1];
tag = dwarf_tag(die_mem);
if (tag == DW_TAG_formal_parameter ||
tag == DW_TAG_variable) {
ret = convert_variable_location(die_mem, af->pf.addr,
af->pf.fb_ops, NULL);
if (ret == 0) {
ret = die_get_varname(die_mem, buf, MAX_VAR_LEN);
pr_debug2("Add new var: %s\n", buf);
if (ret > 0)
strlist__add(vl->vars, buf);
}
}
if (af->child && dwarf_haspc(die_mem, af->pf.addr))
return DIE_FIND_CB_CONTINUE;
else
return DIE_FIND_CB_SIBLING;
}
/* Add a found vars into available variables list */
static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
{
struct available_var_finder *af =
container_of(pf, struct available_var_finder, pf);
struct variable_list *vl;
Dwarf_Die die_mem, *scopes = NULL;
int ret, nscopes;
/* Check number of tevs */
if (af->nvls == af->max_vls) {
pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
return -ERANGE;
}
vl = &af->vls[af->nvls++];
ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
&vl->point);
if (ret < 0)
return ret;
pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
vl->point.offset);
/* Find local variables */
vl->vars = strlist__new(true, NULL);
if (vl->vars == NULL)
return -ENOMEM;
af->child = true;
die_find_child(sp_die, collect_variables_cb, (void *)af, &die_mem);
/* Find external variables */
if (!af->externs)
goto out;
/* Don't need to search child DIE for externs. */
af->child = false;
nscopes = dwarf_getscopes_die(sp_die, &scopes);
while (nscopes-- > 1)
die_find_child(&scopes[nscopes], collect_variables_cb,
(void *)af, &die_mem);
if (scopes)
free(scopes);
out:
if (strlist__empty(vl->vars)) {
strlist__delete(vl->vars);
vl->vars = NULL;
}
return ret;
}
/* Find available variables at given probe point */
int find_available_vars_at(int fd, struct perf_probe_event *pev,
struct variable_list **vls, int max_vls,
bool externs)
{
struct available_var_finder af = {
.pf = {.pev = pev, .callback = add_available_vars},
.max_vls = max_vls, .externs = externs};
int ret;
/* Allocate result vls array */
*vls = zalloc(sizeof(struct variable_list) * max_vls);
if (*vls == NULL)
return -ENOMEM;
af.vls = *vls;
af.nvls = 0;
ret = find_probes(fd, &af.pf);
if (ret < 0) {
/* Free vlist for error */
while (af.nvls--) {
if (af.vls[af.nvls].point.symbol)
free(af.vls[af.nvls].point.symbol);
if (af.vls[af.nvls].vars)
strlist__delete(af.vls[af.nvls].vars);
}
free(af.vls);
*vls = NULL;
return ret;
}
return (ret < 0) ? ret : af.nvls;
}
/* Get all variables and print their value expressions. */
static void
print_varlocs (Dwarf_Die *funcdie)
{
// Display frame base for function if it exists.
// Should be used for DW_OP_fbreg.
has_frame_base = dwarf_hasattr (funcdie, DW_AT_frame_base);
if (has_frame_base)
{
Dwarf_Attribute fb_attr;
if (dwarf_attr (funcdie, DW_AT_frame_base, &fb_attr) == NULL)
error (EXIT_FAILURE, 0, "dwarf_attr fb: %s", dwarf_errmsg (-1));
Dwarf_Op *fb_expr;
size_t fb_exprlen;
if (dwarf_getlocation (&fb_attr, &fb_expr, &fb_exprlen) == 0)
{
// Covers all of function.
Dwarf_Addr entrypc;
if (dwarf_entrypc (funcdie, &entrypc) != 0)
error (EXIT_FAILURE, 0, "dwarf_entrypc: %s", dwarf_errmsg (-1));
printf (" frame_base: ");
if (entrypc == 0)
printf ("XXX zero address"); // XXX bad DWARF?
else
print_expr_block (&fb_attr, fb_expr, fb_exprlen, entrypc);
printf ("\n");
}
else
{
Dwarf_Addr base, start, end;
ptrdiff_t off = 0;
printf (" frame_base:\n");
while ((off = dwarf_getlocations (&fb_attr, off, &base,
&start, &end,
&fb_expr, &fb_exprlen)) > 0)
{
printf (" (%" PRIx64 ",%" PRIx64 ") ", start, end);
print_expr_block (&fb_attr, fb_expr, fb_exprlen, start);
printf ("\n");
}
if (off < 0)
error (EXIT_FAILURE, 0, "dwarf_getlocations fb: %s",
dwarf_errmsg (-1));
}
}
else if (dwarf_tag (funcdie) == DW_TAG_inlined_subroutine)
{
// See whether the subprogram we are inlined into has a frame
// base we should use.
Dwarf_Die *scopes;
int n = dwarf_getscopes_die (funcdie, &scopes);
if (n <= 0)
error (EXIT_FAILURE, 0, "dwarf_getscopes_die: %s", dwarf_errmsg (-1));
while (n-- > 0)
if (dwarf_tag (&scopes[n]) == DW_TAG_subprogram
&& dwarf_hasattr (&scopes[n], DW_AT_frame_base))
{
has_frame_base = true;
break;
}
free (scopes);
}
if (! dwarf_haschildren (funcdie))
return;
Dwarf_Die child;
int res = dwarf_child (funcdie, &child);
if (res < 0)
error (EXIT_FAILURE, 0, "dwarf_child: %s", dwarf_errmsg (-1));
/* We thought there was a child, but the child list was actually
empty. This isn't technically an error in the DWARF, but it is
certainly non-optimimal. */
if (res == 1)
return;
do
{
int tag = dwarf_tag (&child);
if (tag == DW_TAG_variable || tag == DW_TAG_formal_parameter)
{
const char *what = tag == DW_TAG_variable ? "variable" : "parameter";
print_die (&child, what, 2);
if (dwarf_hasattr (&child, DW_AT_location))
{
Dwarf_Attribute attr;
if (dwarf_attr (&child, DW_AT_location, &attr) == NULL)
error (EXIT_FAILURE, 0, "dwarf_attr: %s", dwarf_errmsg (-1));
Dwarf_Op *expr;
size_t exprlen;
if (dwarf_getlocation (&attr, &expr, &exprlen) == 0)
{
// Covers all ranges of the function.
// Evaluate the expression block for each range.
ptrdiff_t offset = 0;
Dwarf_Addr base, begin, end;
do
{
offset = dwarf_ranges (funcdie, offset, &base,
&begin, &end);
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_ranges: %s",
dwarf_errmsg (-1));
if (offset > 0)
{
if (exprlen == 0)
printf (" (%"
PRIx64 ",%" PRIx64
") <empty expression>\n", begin, end);
else
print_expr_block_addrs (&attr, begin, end,
expr, exprlen);
}
}
while (offset > 0);
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_ranges: %s",
dwarf_errmsg (-1));
}
else
{
Dwarf_Addr base, begin, end;
ptrdiff_t offset = 0;
while ((offset = dwarf_getlocations (&attr, offset,
&base, &begin, &end,
&expr, &exprlen)) > 0)
if (begin >= end)
printf (" (%" PRIx64 ",%" PRIx64
") <empty range>\n", begin, end); // XXX report?
else
{
print_expr_block_addrs (&attr, begin, end,
expr, exprlen);
// Extra sanity check for dwarf_getlocation_addr
// Must at least find one range for begin and end-1.
Dwarf_Op *expraddr;
size_t expraddr_len;
int locs = dwarf_getlocation_addr (&attr, begin,
&expraddr,
&expraddr_len, 1);
assert (locs == 1);
locs = dwarf_getlocation_addr (&attr, end - 1,
&expraddr,
&expraddr_len, 1);
assert (locs == 1);
}
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_getlocations: %s",
dwarf_errmsg (-1));
}
}
else if (dwarf_hasattr (&child, DW_AT_const_value))
{
printf (" <constant value>\n"); // Lookup type and print.
}
else
{
printf (" <no value>\n");
}
}
}
while (dwarf_siblingof (&child, &child) == 0);
}