static int
compare_lines(const void *a_in, const void *b_in)
{
const Dwarf_Line a = *(const Dwarf_Line *)a_in;
const Dwarf_Line b = *(const Dwarf_Line *)b_in;
Dwarf_Addr addr_a, addr_b;
Dwarf_Error de = {0};
if (dwarf_lineaddr(a, &addr_a, &de) != DW_DLV_OK ||
dwarf_lineaddr(b, &addr_b, &de) != DW_DLV_OK)
return 0;
if (addr_a > addr_b)
return 1;
if (addr_a < addr_b)
return -1;
return 0;
}
error_t get_addr(mygdb_info_t *gdb_info, cmd_info_t* cmd_info, Dwarf_Addr* addr){
Dwarf_Error err;
Dwarf_Signed cnt;
Dwarf_Unsigned line_num;
Dwarf_Line *linebuf;
error_t result = E_NONE;
int found = 0;
size_t i;
if(dwarf_srclines(gdb_info->cu_die, &linebuf, &cnt, &err) != DW_DLV_OK){
printf("dwarf_srclines() failed\n");
return E_FATAL;
}
for(i = 0; i < cnt; i++){
if(dwarf_lineno(linebuf[i], &line_num, &err) == DW_DLV_ERROR){
printf("dwarf_lineno() failed\n");
result = E_FATAL;
}
if(line_num == cmd_info->set_breakpoint.line_num){
found = 1;
if( dwarf_lineaddr(linebuf[i], addr, &err) == DW_DLV_ERROR )
result = E_FATAL;
}
}
if(!found){
printf("Not a valid line number: %d\n", (unsigned int)cmd_info->set_breakpoint.line_num);
result = E_NON_FATAL;
}
return result;
}
/**
* Lookup the source location for a given address within a CU,
* assuming that it is contained within an inlined function.
*
* A source location can be found regardless of inlining status for
* this method, but in the case of an inlined function, the returned
* source location will point not to the callsite but rather to the
* definition site of the inline function.
*
* @param cu bt_dwarf_cu instance in which to look for the address
* @param addr The address for which to look for
* @param src_loc Out parameter, the source location (filename and
* line number) for the address
* @returns 0 on success, -1 on failure
*/
static
int bin_info_lookup_cu_src_loc_no_inl(struct bt_dwarf_cu *cu, uint64_t addr,
struct source_location **src_loc)
{
struct source_location *_src_loc = NULL;
struct bt_dwarf_die *die = NULL;
const char *filename = NULL;
Dwarf_Line *line = NULL;
Dwarf_Addr line_addr;
int ret, line_no;
if (!cu || !src_loc) {
goto error;
}
die = bt_dwarf_die_create(cu);
if (!die) {
goto error;
}
line = dwarf_getsrc_die(die->dwarf_die, addr);
if (!line) {
goto error;
}
ret = dwarf_lineaddr(line, &line_addr);
if (ret) {
goto error;
}
filename = dwarf_linesrc(line, NULL, NULL);
if (!filename) {
goto error;
}
if (addr == line_addr) {
_src_loc = g_new0(struct source_location, 1);
if (!_src_loc) {
goto error;
}
ret = dwarf_lineno(line, &line_no);
if (ret) {
goto error;
}
_src_loc->line_no = line_no;
_src_loc->filename = strdup(filename);
}
/**
* cu_find_lineinfo - Get a line number and file name for given address
* @cu_die: a CU DIE
* @addr: An address
* @fname: a pointer which returns the file name string
* @lineno: a pointer which returns the line number
*
* Find a line number and file name for @addr in @cu_die.
*/
int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
const char **fname, int *lineno)
{
Dwarf_Line *line;
Dwarf_Addr laddr;
line = dwarf_getsrc_die(cu_die, (Dwarf_Addr)addr);
if (line && dwarf_lineaddr(line, &laddr) == 0 &&
addr == (unsigned long)laddr && dwarf_lineno(line, lineno) == 0) {
*fname = dwarf_linesrc(line, NULL, NULL);
if (!*fname)
/* line number is useless without filename */
*lineno = 0;
}
return *lineno ?: -ENOENT;
}
unsigned long get_iaddr_of_file_line(const char *file, unsigned line){
Dwarf_Unsigned cu_h_len;
Dwarf_Half verstamp;
Dwarf_Unsigned abbrev_offset;
Dwarf_Half addrsize;
Dwarf_Unsigned next_cu;
Dwarf_Error error;
int found = 0;
while( dwarf_next_cu_header(d,&cu_h_len,&verstamp,&abbrev_offset,&addrsize,&next_cu,&error) == DW_DLV_OK ){
Dwarf_Die cu_die = NULL;
int sibret;
int dieno = 0;
while((sibret =
dwarf_siblingof(d,cu_die,&cu_die,&error)) != DW_DLV_NO_ENTRY &&
sibret != DW_DLV_ERROR){
Dwarf_Signed cnt;
Dwarf_Line *linebuf;
int sres;
if((sres = dwarf_srclines(cu_die, &linebuf, &cnt, &error)) == DW_DLV_OK){
int i;
for(i = 0; i < cnt; i++){
char *lf;
Dwarf_Unsigned ll;
dwarf_linesrc(linebuf[i], &lf, &error);
dwarf_lineno(linebuf[i], &ll, &error);
if(line == ll && strstr(lf,file)){
Dwarf_Addr la;
dwarf_lineaddr(linebuf[i], &la, &error);
return la;
}
dwarf_dealloc(d, linebuf[i], DW_DLA_LINE);
}
dwarf_dealloc(d, linebuf, DW_DLA_LIST);
}
}
}
return 0xffffffffffffffff;
}
struct dwarf_lines * dwarf_get_line_info_from_cu(struct dwarf_compilation_unit * cu){
Dwarf_Signed linecount = 0;
Dwarf_Line *linebuf = NULL;
Dwarf_Unsigned lineno = 0;
Dwarf_Error err;
Dwarf_Addr pc;
int lres = dwarf_srclines(cu->root_die, &linebuf, &linecount, &err);
struct dwarf_line_of_code * lines = malloc(sizeof(struct dwarf_line_of_code) * linecount);
int i=0;
for (; i<linecount; i++) {
Dwarf_Line line = linebuf[i];
dwarf_lineaddr(line, &pc, &err);
lines[i].addr = (unsigned long)pc;
dwarf_lineno(line, &lineno, &err);
lines[i].line_number = (unsigned int)lineno;
}
struct dwarf_lines * dwarf_lines = malloc(sizeof(struct dwarf_lines));
dwarf_lines->lines = lines;
dwarf_lines->number_of_lines = linecount;
return dwarf_lines;
}
/* Find probe point from its line number */
static int find_probe_point_by_line(struct probe_finder *pf)
{
Dwarf_Lines *lines;
Dwarf_Line *line;
size_t nlines, i;
Dwarf_Addr addr;
int lineno;
int ret = 0;
if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
pr_warning("No source lines found in this CU.\n");
return -ENOENT;
}
for (i = 0; i < nlines && ret == 0; i++) {
line = dwarf_onesrcline(lines, i);
if (dwarf_lineno(line, &lineno) != 0 ||
lineno != pf->lno)
continue;
/* TODO: Get fileno from line, but how? */
if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
continue;
if (dwarf_lineaddr(line, &addr) != 0) {
pr_warning("Failed to get the address of the line.\n");
return -ENOENT;
}
pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
(int)i, lineno, (uintmax_t)addr);
pf->addr = addr;
ret = convert_probe_point(NULL, pf);
/* Continuing, because target line might be inlined. */
}
return ret;
}
/**
* die_walk_instances - Walk on instances of given DIE
* @or_die: an abstract original DIE
* @callback: a callback function which is called with instance DIE
* @data: user data
*
* Walk on the instances of give @in_die. @in_die must be an inlined function
* declartion. This returns the return value of @callback if it returns
* non-zero value, or -ENOENT if there is no instance.
*/
int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
void *data)
{
Dwarf_Die cu_die;
Dwarf_Die die_mem;
struct __instance_walk_param iwp = {
.addr = or_die->addr,
.callback = callback,
.data = data,
.retval = -ENOENT,
};
if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
return -ENOENT;
die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
return iwp.retval;
}
/* Line walker internal parameters */
struct __line_walk_param {
bool recursive;
line_walk_callback_t callback;
void *data;
int retval;
};
static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
{
struct __line_walk_param *lw = data;
Dwarf_Addr addr = 0;
const char *fname;
int lineno;
if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
fname = die_get_call_file(in_die);
lineno = die_get_call_lineno(in_die);
if (fname && lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
lw->retval = lw->callback(fname, lineno, addr, lw->data);
if (lw->retval != 0)
return DIE_FIND_CB_END;
}
}
if (!lw->recursive)
/* Don't need to search recursively */
return DIE_FIND_CB_SIBLING;
if (addr) {
fname = dwarf_decl_file(in_die);
if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
lw->retval = lw->callback(fname, lineno, addr, lw->data);
if (lw->retval != 0)
return DIE_FIND_CB_END;
}
}
/* Continue to search nested inlined function call-sites */
return DIE_FIND_CB_CONTINUE;
}
/* Walk on lines of blocks included in given DIE */
static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
line_walk_callback_t callback, void *data)
{
struct __line_walk_param lw = {
.recursive = recursive,
.callback = callback,
.data = data,
.retval = 0,
};
Dwarf_Die die_mem;
Dwarf_Addr addr;
const char *fname;
int lineno;
/* Handle function declaration line */
fname = dwarf_decl_file(sp_die);
if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
dwarf_entrypc(sp_die, &addr) == 0) {
lw.retval = callback(fname, lineno, addr, data);
if (lw.retval != 0)
goto done;
}
die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
done:
return lw.retval;
}
static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
{
struct __line_walk_param *lw = data;
lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
if (lw->retval != 0)
return DWARF_CB_ABORT;
return DWARF_CB_OK;
}
/**
* die_walk_lines - Walk on lines inside given DIE
* @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
* @callback: callback routine
* @data: user data
*
* Walk on all lines inside given @rt_die and call @callback on each line.
* If the @rt_die is a function, walk only on the lines inside the function,
* otherwise @rt_die must be a CU DIE.
* Note that this walks not only dwarf line list, but also function entries
* and inline call-site.
*/
int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
{
Dwarf_Lines *lines;
Dwarf_Line *line;
Dwarf_Addr addr;
const char *fname;
int lineno, ret = 0;
Dwarf_Die die_mem, *cu_die;
size_t nlines, i;
/* Get the CU die */
if (dwarf_tag(rt_die) != DW_TAG_compile_unit)
cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
else
cu_die = rt_die;
if (!cu_die) {
pr_debug2("Failed to get CU from given DIE.\n");
return -EINVAL;
}
/* Get lines list in the CU */
if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
pr_debug2("Failed to get source lines on this CU.\n");
return -ENOENT;
}
pr_debug2("Get %zd lines from this CU\n", nlines);
/* Walk on the lines on lines list */
for (i = 0; i < nlines; i++) {
line = dwarf_onesrcline(lines, i);
if (line == NULL ||
dwarf_lineno(line, &lineno) != 0 ||
dwarf_lineaddr(line, &addr) != 0) {
pr_debug2("Failed to get line info. "
"Possible error in debuginfo.\n");
continue;
}
/* Filter lines based on address */
if (rt_die != cu_die)
/*
* Address filtering
* The line is included in given function, and
* no inline block includes it.
*/
if (!dwarf_haspc(rt_die, addr) ||
die_find_inlinefunc(rt_die, addr, &die_mem))
continue;
/* Get source line */
fname = dwarf_linesrc(line, NULL, NULL);
ret = callback(fname, lineno, addr, data);
if (ret != 0)
return ret;
}
/*
* Dwarf lines doesn't include function declarations and inlined
* subroutines. We have to check functions list or given function.
*/
if (rt_die != cu_die)
/*
* Don't need walk functions recursively, because nested
* inlined functions don't have lines of the specified DIE.
*/
ret = __die_walk_funclines(rt_die, false, callback, data);
else {
struct __line_walk_param param = {
.callback = callback,
.data = data,
.retval = 0,
};
dwarf_getfuncs(cu_die, __die_walk_culines_cb, ¶m, 0);
ret = param.retval;
}
return ret;
}
struct __find_variable_param {
const char *name;
Dwarf_Addr addr;
};
static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
{
struct __find_variable_param *fvp = data;
Dwarf_Attribute attr;
int tag;
tag = dwarf_tag(die_mem);
if ((tag == DW_TAG_formal_parameter ||
tag == DW_TAG_variable) &&
die_compare_name(die_mem, fvp->name) &&
/* Does the DIE have location information or external instance? */
(dwarf_attr(die_mem, DW_AT_external, &attr) ||
dwarf_attr(die_mem, DW_AT_location, &attr)))
return DIE_FIND_CB_END;
if (dwarf_haspc(die_mem, fvp->addr))
return DIE_FIND_CB_CONTINUE;
else
return DIE_FIND_CB_SIBLING;
}
/**
* die_find_variable_at - Find a given name variable at given address
* @sp_die: a function DIE
* @name: variable name
* @addr: address
* @die_mem: a buffer for result DIE
*
* Find a variable DIE called @name at @addr in @sp_die.
*/
Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
Dwarf_Addr addr, Dwarf_Die *die_mem)
{
struct __find_variable_param fvp = { .name = name, .addr = addr};
return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
die_mem);
}
static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
{
const char *name = data;
if (dwarf_tag(die_mem) == DW_TAG_member) {
if (die_compare_name(die_mem, name))
return DIE_FIND_CB_END;
else if (!dwarf_diename(die_mem)) { /* Unnamed structure */
Dwarf_Die type_die, tmp_die;
if (die_get_type(die_mem, &type_die) &&
die_find_member(&type_die, name, &tmp_die))
return DIE_FIND_CB_END;
}
}
return DIE_FIND_CB_SIBLING;
}
/**
* die_find_member - Find a given name member in a data structure
* @st_die: a data structure type DIE
* @name: member name
* @die_mem: a buffer for result DIE
*
* Find a member DIE called @name in @st_die.
*/
Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
Dwarf_Die *die_mem)
{
return die_find_child(st_die, __die_find_member_cb, (void *)name,
die_mem);
}
/**
* die_get_typename - Get the name of given variable DIE
* @vr_die: a variable DIE
* @buf: a buffer for result type name
* @len: a max-length of @buf
*
* Get the name of @vr_die and stores it to @buf. Return the actual length
* of type name if succeeded. Return -E2BIG if @len is not enough long, and
* Return -ENOENT if failed to find type name.
* Note that the result will stores typedef name if possible, and stores
* "*(function_type)" if the type is a function pointer.
*/
int die_get_typename(Dwarf_Die *vr_die, char *buf, int len)
{
Dwarf_Die type;
int tag, ret, ret2;
const char *tmp = "";
if (__die_get_real_type(vr_die, &type) == NULL)
return -ENOENT;
tag = dwarf_tag(&type);
if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
tmp = "*";
else if (tag == DW_TAG_subroutine_type) {
/* Function pointer */
ret = snprintf(buf, len, "(function_type)");
return (ret >= len) ? -E2BIG : ret;
} else {
if (!dwarf_diename(&type))
return -ENOENT;
if (tag == DW_TAG_union_type)
tmp = "union ";
else if (tag == DW_TAG_structure_type)
tmp = "struct ";
else if (tag == DW_TAG_enumeration_type)
tmp = "enum ";
/* Write a base name */
ret = snprintf(buf, len, "%s%s", tmp, dwarf_diename(&type));
return (ret >= len) ? -E2BIG : ret;
}
ret = die_get_typename(&type, buf, len);
if (ret > 0) {
ret2 = snprintf(buf + ret, len - ret, "%s", tmp);
ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
}
return ret;
}
/**
* die_get_varname - Get the name and type of given variable DIE
* @vr_die: a variable DIE
* @buf: a buffer for type and variable name
* @len: the max-length of @buf
*
* Get the name and type of @vr_die and stores it in @buf as "type\tname".
*/
int die_get_varname(Dwarf_Die *vr_die, char *buf, int len)
{
int ret, ret2;
ret = die_get_typename(vr_die, buf, len);
if (ret < 0) {
pr_debug("Failed to get type, make it unknown.\n");
ret = snprintf(buf, len, "(unknown_type)");
}
if (ret > 0) {
ret2 = snprintf(buf + ret, len - ret, "\t%s",
dwarf_diename(vr_die));
ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
}
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) != 0)
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 pc 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 = convert_probe_point(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 kprobe_trace_events specified by perf_probe_event from debuginfo */
int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
struct kprobe_trace_event **tevs, int max_tevs)
{
struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs};
struct perf_probe_point *pp = &pev->point;
Dwarf_Off off, noff;
size_t cuhl;
Dwarf_Die *diep;
Dwarf *dbg;
int ret = 0;
pf.tevs = zalloc(sizeof(struct kprobe_trace_event) * max_tevs);
if (pf.tevs == NULL)
return -ENOMEM;
*tevs = pf.tevs;
pf.ntevs = 0;
dbg = dwarf_begin(fd, DWARF_C_READ);
if (!dbg) {
pr_warning("No dwarf info found in the vmlinux - "
"please rebuild with CONFIG_DEBUG_INFO=y.\n");
free(pf.tevs);
*tevs = NULL;
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) &&
ret >= 0) {
/* 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);
}
}
off = noff;
}
line_list__free(&pf.lcache);
dwarf_end(dbg);
return (ret < 0) ? ret : pf.ntevs;
}
/* Reverse search */
int find_perf_probe_point(int fd, unsigned long addr,
struct perf_probe_point *ppt)
{
Dwarf_Die cudie, spdie, indie;
Dwarf *dbg;
Dwarf_Line *line;
Dwarf_Addr laddr, eaddr;
const char *tmp;
int lineno, ret = 0;
bool found = false;
dbg = dwarf_begin(fd, DWARF_C_READ);
if (!dbg)
return -EBADF;
/* Find cu die */
if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) {
ret = -EINVAL;
goto end;
}
/* Find a corresponding line */
line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
if (line) {
if (dwarf_lineaddr(line, &laddr) == 0 &&
(Dwarf_Addr)addr == laddr &&
dwarf_lineno(line, &lineno) == 0) {
tmp = dwarf_linesrc(line, NULL, NULL);
if (tmp) {
ppt->line = lineno;
ppt->file = strdup(tmp);
if (ppt->file == NULL) {
ret = -ENOMEM;
goto end;
}
found = true;
}
}
}
/* Find a corresponding function */
if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
tmp = dwarf_diename(&spdie);
if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
goto end;
if (ppt->line) {
if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
&indie)) {
/* addr in an inline function */
tmp = dwarf_diename(&indie);
if (!tmp)
goto end;
ret = dwarf_decl_line(&indie, &lineno);
} else {
if (eaddr == addr) { /* Function entry */
lineno = ppt->line;
ret = 0;
} else
ret = dwarf_decl_line(&spdie, &lineno);
}
if (ret == 0) {
/* Make a relative line number */
ppt->line -= lineno;
goto found;
}
}
/* We don't have a line number, let's use offset */
ppt->offset = addr - (unsigned long)eaddr;
found:
ppt->function = strdup(tmp);
if (ppt->function == NULL) {
ret = -ENOMEM;
goto end;
}
found = true;
}
end:
dwarf_end(dbg);
if (ret >= 0)
ret = found ? 1 : 0;
return ret;
}
/* Add a line and store the src path */
static int line_range_add_line(const char *src, unsigned int lineno,
struct line_range *lr)
{
/* Copy real path */
if (!lr->path) {
lr->path = strdup(src);
if (lr->path == NULL)
return -ENOMEM;
}
return line_list__add_line(&lr->line_list, lineno);
}
/* Search function declaration lines */
static int line_range_funcdecl_cb(Dwarf_Die *sp_die, void *data)
{
struct dwarf_callback_param *param = data;
struct line_finder *lf = param->data;
const char *src;
int lineno;
src = dwarf_decl_file(sp_die);
if (src && strtailcmp(src, lf->fname) != 0)
return DWARF_CB_OK;
if (dwarf_decl_line(sp_die, &lineno) != 0 ||
(lf->lno_s > lineno || lf->lno_e < lineno))
return DWARF_CB_OK;
param->retval = line_range_add_line(src, lineno, lf->lr);
if (param->retval < 0)
return DWARF_CB_ABORT;
return DWARF_CB_OK;
}
static int find_line_range_func_decl_lines(struct line_finder *lf)
{
struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
dwarf_getfuncs(&lf->cu_die, line_range_funcdecl_cb, ¶m, 0);
return param.retval;
}
/* Find line range from its line number */
static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
{
Dwarf_Lines *lines;
Dwarf_Line *line;
size_t nlines, i;
Dwarf_Addr addr;
int lineno, ret = 0;
const char *src;
Dwarf_Die die_mem;
line_list__init(&lf->lr->line_list);
if (dwarf_getsrclines(&lf->cu_die, &lines, &nlines) != 0) {
pr_warning("No source lines found in this CU.\n");
return -ENOENT;
}
/* Search probable lines on lines list */
for (i = 0; i < nlines; i++) {
line = dwarf_onesrcline(lines, i);
if (dwarf_lineno(line, &lineno) != 0 ||
(lf->lno_s > lineno || lf->lno_e < lineno))
continue;
if (sp_die) {
/* Address filtering 1: does sp_die include addr? */
if (dwarf_lineaddr(line, &addr) != 0 ||
!dwarf_haspc(sp_die, addr))
continue;
/* Address filtering 2: No child include addr? */
if (die_find_inlinefunc(sp_die, addr, &die_mem))
continue;
}
/* TODO: Get fileno from line, but how? */
src = dwarf_linesrc(line, NULL, NULL);
if (strtailcmp(src, lf->fname) != 0)
continue;
ret = line_range_add_line(src, lineno, lf->lr);
if (ret < 0)
return ret;
}
/*
* Dwarf lines doesn't include function declarations. We have to
* check functions list or given function.
*/
if (sp_die) {
src = dwarf_decl_file(sp_die);
if (src && dwarf_decl_line(sp_die, &lineno) == 0 &&
(lf->lno_s <= lineno && lf->lno_e >= lineno))
ret = line_range_add_line(src, lineno, lf->lr);
} else
ret = find_line_range_func_decl_lines(lf);
/* Update status */
if (ret >= 0)
if (!list_empty(&lf->lr->line_list))
ret = lf->found = 1;
else
ret = 0; /* Lines are not found */
else {
free(lf->lr->path);
lf->lr->path = NULL;
}
return ret;
}
static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
{
struct dwarf_callback_param *param = data;
param->retval = find_line_range_by_line(in_die, param->data);
return DWARF_CB_ABORT; /* No need to find other instances */
}
/* Search function from function name */
static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
{
struct dwarf_callback_param *param = data;
struct line_finder *lf = param->data;
struct line_range *lr = lf->lr;
if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
die_compare_name(sp_die, lr->function) == 0) {
lf->fname = dwarf_decl_file(sp_die);
dwarf_decl_line(sp_die, &lr->offset);
pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
lf->lno_s = lr->offset + lr->start;
if (lf->lno_s < 0) /* Overflow */
lf->lno_s = INT_MAX;
lf->lno_e = lr->offset + lr->end;
if (lf->lno_e < 0) /* Overflow */
lf->lno_e = INT_MAX;
pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
lr->start = lf->lno_s;
lr->end = lf->lno_e;
if (dwarf_func_inline(sp_die)) {
struct dwarf_callback_param _param;
_param.data = (void *)lf;
_param.retval = 0;
dwarf_func_inline_instances(sp_die,
line_range_inline_cb,
&_param);
param->retval = _param.retval;
} else
param->retval = find_line_range_by_line(sp_die, lf);
return DWARF_CB_ABORT;
}
return DWARF_CB_OK;
}
static int find_line_range_by_func(struct line_finder *lf)
{
struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
dwarf_getfuncs(&lf->cu_die, line_range_search_cb, ¶m, 0);
return param.retval;
}
int find_line_range(int fd, struct line_range *lr)
{
struct line_finder lf = {.lr = lr, .found = 0};
int ret = 0;
Dwarf_Off off = 0, noff;
size_t cuhl;
Dwarf_Die *diep;
Dwarf *dbg;
dbg = dwarf_begin(fd, DWARF_C_READ);
if (!dbg) {
pr_warning("No dwarf info found in the vmlinux - "
"please rebuild with CONFIG_DEBUG_INFO=y.\n");
return -EBADF;
}
/* Loop on CUs (Compilation Unit) */
while (!lf.found && ret >= 0) {
if (dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) != 0)
break;
/* Get the DIE(Debugging Information Entry) of this CU */
diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
if (!diep)
continue;
/* Check if target file is included. */
if (lr->file)
lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
else
lf.fname = 0;
if (!lr->file || lf.fname) {
if (lr->function)
ret = find_line_range_by_func(&lf);
else {
lf.lno_s = lr->start;
lf.lno_e = lr->end;
ret = find_line_range_by_line(NULL, &lf);
}
}
off = noff;
}
pr_debug("path: %lx\n", (unsigned long)lr->path);
dwarf_end(dbg);
return (ret < 0) ? ret : lf.found;
}
/* Find probe points from lazy pattern */
static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
{
Dwarf_Lines *lines;
Dwarf_Line *line;
size_t nlines, i;
Dwarf_Addr addr;
Dwarf_Die die_mem;
int lineno;
int ret = 0;
if (list_empty(&pf->lcache)) {
/* Matching lazy line pattern */
ret = find_lazy_match_lines(&pf->lcache, pf->fname,
pf->pev->point.lazy_line);
if (ret == 0) {
pr_debug("No matched lines found in %s.\n", pf->fname);
return 0;
} else if (ret < 0)
return ret;
}
if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
pr_warning("No source lines found in this CU.\n");
return -ENOENT;
}
for (i = 0; i < nlines && ret >= 0; i++) {
line = dwarf_onesrcline(lines, i);
if (dwarf_lineno(line, &lineno) != 0 ||
!line_list__has_line(&pf->lcache, lineno))
continue;
/* TODO: Get fileno from line, but how? */
if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
continue;
if (dwarf_lineaddr(line, &addr) != 0) {
pr_debug("Failed to get the address of line %d.\n",
lineno);
continue;
}
if (sp_die) {
/* Address filtering 1: does sp_die include addr? */
if (!dwarf_haspc(sp_die, addr))
continue;
/* Address filtering 2: No child include addr? */
if (die_find_inlinefunc(sp_die, addr, &die_mem))
continue;
}
pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
(int)i, lineno, (unsigned long long)addr);
pf->addr = addr;
ret = convert_probe_point(sp_die, pf);
/* Continuing, because target line might be inlined. */
}
/* TODO: deallocate lines, but how? */
return ret;
}
static void
process_line_table(Dwarf_Debug dbg,
const char *sec_name,
Dwarf_Line *linebuf, Dwarf_Signed linecount,
Dwarf_Bool is_logicals_table, Dwarf_Bool is_actuals_table)
{
char *padding = 0;
Dwarf_Signed i = 0;
Dwarf_Addr pc = 0;
Dwarf_Unsigned lineno = 0;
Dwarf_Unsigned logicalno = 0;
Dwarf_Unsigned column = 0;
Dwarf_Unsigned call_context = 0;
string subprog_name = 0;
string subprog_filename = 0;
Dwarf_Unsigned subprog_line = 0;
Dwarf_Error err = 0;
Dwarf_Bool newstatement = 0;
Dwarf_Bool lineendsequence = 0;
Dwarf_Bool new_basic_block = 0;
int sres = 0;
int ares = 0;
int lires = 0;
int cores = 0;
Dwarf_Addr elf_max_address = 0;
Dwarf_Bool SkipRecord = FALSE;
current_section_id = DEBUG_LINE;
struct esb_s lastsrc;
/* line_flag is TRUE */
esb_constructor(&lastsrc);
get_address_size_and_max(dbg,0,&elf_max_address,&err);
/* Padding for a nice layout */
padding = line_print_pc ? " " : "";
if (do_print_dwarf) {
/* Check if print of <pc> address is needed. */
printf("\n");
if (is_logicals_table) {
printf("Logicals Table:\n");
printf("%sNS new statement, PE prologue end, "
"EB epilogue begin\n",padding);
printf("%sDI=val discriminator value\n",
padding);
printf("%sCC=val context, SB=val subprogram\n",
padding);
} else if (is_actuals_table) {
printf("Actuals Table:\n");
printf("%sBB new basic block, ET end of text sequence\n"
"%sIS=val ISA number\n",padding,padding);
} else {
/* Standard DWARF line table. */
printf("%sNS new statement, BB new basic block, "
"ET end of text sequence\n",padding);
printf("%sPE prologue end, EB epilogue begin\n",padding);
printf("%sIS=val ISA number, DI=val discriminator value\n",
padding);
}
if (is_logicals_table || is_actuals_table) {
printf("[ row] ");
}
if (line_print_pc) {
printf("<pc> ");
}
if (is_logicals_table) {
printf("[lno,col] NS PE EB DI= CC= SB= uri: \"filepath\"\n");
} else if (is_actuals_table) {
printf("[logical] BB ET IS=\n");
} else {
printf("[row,col] NS BB ET PE EB IS= DI= uri: \"filepath\"\n");
}
}
for (i = 0; i < linecount; i++) {
Dwarf_Line line = linebuf[i];
string filename = 0;
int nsres = 0;
Dwarf_Bool found_line_error = FALSE;
Dwarf_Bool has_is_addr_set = FALSE;
char *where = NULL;
if (check_decl_file && checking_this_compiler()) {
/* A line record with addr=0 was detected */
if (SkipRecord) {
/* Skip records that do not have ís_addr_set' */
ares = dwarf_line_is_addr_set(line, &has_is_addr_set, &err);
if (ares == DW_DLV_OK && has_is_addr_set) {
SkipRecord = FALSE;
}
else {
/* Keep ignoring records until we have
one with 'is_addr_set' */
continue;
}
}
}
if (check_lines && checking_this_compiler()) {
DWARF_CHECK_COUNT(lines_result,1);
}
filename = "<unknown>";
if (!is_actuals_table) {
sres = dwarf_linesrc(line, &filename, &err);
if (sres == DW_DLV_ERROR) {
/* Do not terminate processing */
where = "dwarf_linesrc()";
record_line_error(where,err);
found_line_error = TRUE;
}
}
pc = 0;
ares = dwarf_lineaddr(line, &pc, &err);
if (ares == DW_DLV_ERROR) {
/* Do not terminate processing */
where = "dwarf_lineaddr()";
record_line_error(where,err);
found_line_error = TRUE;
pc = 0;
}
if (ares == DW_DLV_NO_ENTRY) {
pc = 0;
}
if (is_actuals_table) {
lires = dwarf_linelogical(line, &logicalno, &err);
if (lires == DW_DLV_ERROR) {
/* Do not terminate processing */
where = "dwarf_linelogical()";
record_line_error(where,err);
found_line_error = TRUE;
}
if (lires == DW_DLV_NO_ENTRY) {
logicalno = -1LL;
}
column = 0;
} else {
lires = dwarf_lineno(line, &lineno, &err);
if (lires == DW_DLV_ERROR) {
/* Do not terminate processing */
where = "dwarf_lineno()";
record_line_error(where,err);
found_line_error = TRUE;
}
if (lires == DW_DLV_NO_ENTRY) {
lineno = -1LL;
}
cores = dwarf_lineoff_b(line, &column, &err);
if (cores == DW_DLV_ERROR) {
/* Do not terminate processing */
where = "dwarf_lineoff()";
record_line_error(where,err);
found_line_error = TRUE;
}
if (cores == DW_DLV_NO_ENTRY) {
/* Zero was always the correct default, meaning
the left edge. DWARF2/3/4 spec sec 6.2.2 */
column = 0;
}
}
/* Process any possible error condition, though
we won't be at the first such error. */
if (check_decl_file && checking_this_compiler()) {
DWARF_CHECK_COUNT(decl_file_result,1);
if (found_line_error) {
DWARF_CHECK_ERROR2(decl_file_result,where,dwarf_errmsg(err));
} else if (do_check_dwarf) {
/* Check the address lies with a valid [lowPC:highPC]
in the .text section*/
if (IsValidInBucketGroup(pRangesInfo,pc)) {
/* Valid values; do nothing */
} else {
/* At this point may be we are dealing with
a linkonce symbol. The problem we have here
is we have consumed the deug_info section
and we are dealing just with the records
from the .debug_line, so no PU_name is
available and no high_pc. Traverse the linkonce
table if try to match the pc value with
one of those ranges.
*/
if (check_lines && checking_this_compiler()) {
DWARF_CHECK_COUNT(lines_result,1);
}
if (FindAddressInBucketGroup(pLinkonceInfo,pc)){
/* Valid values; do nothing */
} else {
/* The SN Systems Linker generates
line records
with addr=0, when dealing with linkonce
symbols and no stripping */
if (pc) {
char addr_tmp[100];
if (check_lines && checking_this_compiler()) {
snprintf(addr_tmp,sizeof(addr_tmp),
"%s: Address"
" 0x%" DW_PR_XZEROS DW_PR_DUx
" outside a valid .text range",
sec_name,pc);
DWARF_CHECK_ERROR(lines_result,
addr_tmp);
}
} else {
SkipRecord = TRUE;
}
}
}
/* Check the last record for the .debug_line,
the one created by DW_LNE_end_sequence,
is the same as the high_pc
address for the last known user program
unit (PU) */
if ((i + 1 == linecount) &&
seen_PU_high_address &&
!is_logicals_table) {
/* Ignore those PU that have been stripped
by the linker; their low_pc values are
set to -1 (snc linker only) */
/* It is perfectly sensible for a compiler
to leave a few bytes of NOP or other stuff
after the last instruction in a subprogram,
for cache-alignment or other purposes, so
a mismatch here is not necessarily
an error. */
if (check_lines && checking_this_compiler()) {
DWARF_CHECK_COUNT(lines_result,1);
if ((pc != PU_high_address) &&
(PU_base_address != elf_max_address)) {
char addr_tmp[100];
snprintf(addr_tmp,sizeof(addr_tmp),
"%s: Address"
" 0x%" DW_PR_XZEROS DW_PR_DUx
" may be incorrect"
" as DW_LNE_end_sequence address",
sec_name,pc);
DWARF_CHECK_ERROR(lines_result,
addr_tmp);
}
}
}
}
}
/* Display the error information */
if (found_line_error || record_dwarf_error) {
if (check_verbose_mode && PRINTING_UNIQUE) {
/* Print the record number for better error description */
printf("Record = %" DW_PR_DUu
" Addr = 0x%" DW_PR_XZEROS DW_PR_DUx
" [%4" DW_PR_DUu ",%2" DW_PR_DUu "] '%s'\n",
i, pc,lineno,column,filename);
/* The compilation unit was already printed */
if (!check_decl_file) {
PRINT_CU_INFO();
}
}
record_dwarf_error = FALSE;
/* Due to a fatal error, skip current record */
if (found_line_error) {
continue;
}
}
if (do_print_dwarf) {
if (is_logicals_table || is_actuals_table) {
printf("[%4" DW_PR_DUu "] ", i + 1);
}
/* Check if print of <pc> address is needed. */
if (line_print_pc) {
printf("0x%" DW_PR_XZEROS DW_PR_DUx " ", pc);
}
if (is_actuals_table) {
printf("[%7" DW_PR_DUu "]", logicalno);
} else {
printf("[%4" DW_PR_DUu ",%2" DW_PR_DUu "]", lineno, column);
}
}
if (!is_actuals_table) {
nsres = dwarf_linebeginstatement(line, &newstatement, &err);
if (nsres == DW_DLV_OK) {
if (newstatement && do_print_dwarf) {
printf(" %s","NS");
}
} else if (nsres == DW_DLV_ERROR) {
print_error(dbg, "linebeginstatment failed", nsres, err);
}
}
if (!is_logicals_table) {
nsres = dwarf_lineblock(line, &new_basic_block, &err);
if (nsres == DW_DLV_OK) {
if (new_basic_block && do_print_dwarf) {
printf(" %s","BB");
}
} else if (nsres == DW_DLV_ERROR) {
print_error(dbg, "lineblock failed", nsres, err);
}
nsres = dwarf_lineendsequence(line, &lineendsequence, &err);
if (nsres == DW_DLV_OK) {
if (lineendsequence && do_print_dwarf) {
printf(" %s", "ET");
}
} else if (nsres == DW_DLV_ERROR) {
print_error(dbg, "lineendsequence failed", nsres, err);
}
}
if (do_print_dwarf) {
Dwarf_Bool prologue_end = 0;
Dwarf_Bool epilogue_begin = 0;
Dwarf_Unsigned isa = 0;
Dwarf_Unsigned discriminator = 0;
int disres = dwarf_prologue_end_etc(line,
&prologue_end,&epilogue_begin,
&isa,&discriminator,&err);
if (disres == DW_DLV_ERROR) {
print_error(dbg, "dwarf_prologue_end_etc() failed",
disres, err);
}
if (prologue_end && !is_actuals_table) {
printf(" PE");
}
if (epilogue_begin && !is_actuals_table) {
printf(" EB");
}
if (isa && !is_logicals_table) {
printf(" IS=0x%" DW_PR_DUx, isa);
}
if (discriminator && !is_actuals_table) {
printf(" DI=0x%" DW_PR_DUx, discriminator);
}
if (is_logicals_table) {
call_context = 0;
disres = dwarf_linecontext(line, &call_context, &err);
if (disres == DW_DLV_ERROR) {
print_error(dbg, "dwarf_linecontext() failed",
disres, err);
}
if (call_context) {
printf(" CC=%" DW_PR_DUu, call_context);
}
subprog_name = 0;
disres = dwarf_line_subprog(line, &subprog_name,
&subprog_filename, &subprog_line, &err);
if (disres == DW_DLV_ERROR) {
print_error(dbg, "dwarf_line_subprog() failed",
disres, err);
}
if (subprog_name && strlen(subprog_name)) {
/* We do not print an empty name.
Clutters things up. */
printf(" SB=\"%s\"", subprog_name);
}
}
}
if (!is_actuals_table) {
if (i > 0 && verbose < 3 &&
strcmp(filename,esb_get_string(&lastsrc)) == 0) {
/* Do not print name. */
} else {
struct esb_s urs;
esb_constructor(&urs);
esb_append(&urs, " uri: \"");
translate_to_uri(filename,&urs);
esb_append(&urs,"\"");
if (do_print_dwarf) {
printf("%s",esb_get_string(&urs));
}
esb_destructor(&urs);
esb_empty_string(&lastsrc);
esb_append(&lastsrc,filename);
}
if (sres == DW_DLV_OK) {
dwarf_dealloc(dbg, filename, DW_DLA_STRING);
}
}
if (do_print_dwarf) {
printf("\n");
}
}
esb_destructor(&lastsrc);
}
/**
* @brief Process one line number record.
* @param line Line to process.
*/
void DwarfLineContainer::loadLine(Dwarf_Line line)
{
// Address associated with line.
Dwarf_Addr addr = 0;
m_res = dwarf_lineaddr(line, &addr, &m_error);
if (m_res == DW_DLV_ERROR)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
if (m_res == DW_DLV_NO_ENTRY)
{
addr = EMPTY_ADDR;
}
// Source statement line number.
Dwarf_Unsigned lineno;
m_res = dwarf_lineno(line, &lineno, &m_error);
if (m_res == DW_DLV_ERROR)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
if (m_res == DW_DLV_NO_ENTRY)
{
lineno = EMPTY_UNSIGNED;
}
// Column number at which statement represented by line begins.
Dwarf_Unsigned column;
m_res = dwarf_lineoff_b(line, &column, &m_error);
if (m_res == DW_DLV_ERROR)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
if (m_res == DW_DLV_NO_ENTRY)
{
column = EMPTY_UNSIGNED;
}
// Name of src file where line occurs.
char *s = nullptr;
string f;
m_res = dwarf_linesrc(line, &s, &m_error);
if (m_res == DW_DLV_ERROR)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
if (m_res == DW_DLV_NO_ENTRY || s==nullptr)
f = EMPTY_STR;
else
f = s;
dwarf_dealloc(m_parentFile->m_dbg, s, DW_DLA_STRING);
// Is line marked as beginning of the statement?
Dwarf_Bool statBeg;
m_res = dwarf_linebeginstatement(line, &statBeg, &m_error);
if (m_res != DW_DLV_OK)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
// Is line marked as ending a text sequence?
Dwarf_Bool seqEnd;
m_res = dwarf_lineendsequence(line, &seqEnd, &m_error);
if (m_res != DW_DLV_OK)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
// Is line marked as not beginning basic block?
Dwarf_Bool basicBlockBeg;
m_res = dwarf_lineblock(line, &basicBlockBeg, &m_error);
if (m_res != DW_DLV_OK)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
Dwarf_Bool prologueEnd, epilogueBegin;
Dwarf_Unsigned isa, discriminator;
m_res = dwarf_prologue_end_etc(line, &prologueEnd, &epilogueBegin,
&isa, &discriminator, &m_error);
if (m_res != DW_DLV_OK)
{
DWARF_ERROR(getDwarfError(m_error));
return;
}
// Create line record.
DwarfLine *l = new DwarfLine(this, *findSrcFile(f));
l->lineNum = lineno;
l->addr = addr;
l->col = column;
if (statBeg) l->flags += DwarfLine::STAT_BEG;
if (seqEnd) l->flags += DwarfLine::SEQ_END;
if (basicBlockBeg) l->flags += DwarfLine::BASE_BLOCK_BEG;
if (prologueEnd) l->flags += DwarfLine::PROLOGUE_END;
if (epilogueBegin) l->flags += DwarfLine::EPILOGUE_BEGIN;
m_data.push_back(l);
}
int
main (int argc, char *argv[])
{
int cnt;
Dwfl *dwfl = NULL;
(void) argp_parse (dwfl_standard_argp (), argc, argv, 0, &cnt, &dwfl);
assert (dwfl != NULL);
Dwarf_Die *cu = NULL;
Dwarf_Addr bias;
do
{
cu = dwfl_nextcu (dwfl, cu, &bias);
if (cu != NULL)
{
Dwfl_Module *mod = dwfl_cumodule (cu);
const char *modname = (dwfl_module_info (mod, NULL, NULL, NULL,
NULL, NULL, NULL, NULL)
?: "<unknown>");
const char *cuname = (dwarf_diename (cu) ?: "<unknown>");
printf ("mod: %s CU: [%" PRIx64 "] %s\n", modname,
dwarf_dieoffset (cu), cuname);
size_t lines;
if (dwfl_getsrclines (cu, &lines) != 0)
continue; // No lines...
for (size_t i = 0; i < lines; i++)
{
Dwfl_Line *line = dwfl_onesrcline (cu, i);
Dwarf_Addr addr;
int lineno;
int colno;
Dwarf_Word mtime;
Dwarf_Word length;
const char *src = dwfl_lineinfo (line, &addr, &lineno, &colno,
&mtime, &length);
Dwarf_Addr dw_bias;
Dwarf_Line *dw_line = dwfl_dwarf_line (line, &dw_bias);
assert (bias == dw_bias);
Dwarf_Addr dw_addr;
if (dwarf_lineaddr (dw_line, &dw_addr) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineaddr: %s",
dwarf_errmsg (-1));
assert (addr == dw_addr + dw_bias);
unsigned int dw_op_index;
if (dwarf_lineop_index (dw_line, &dw_op_index) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineop_index: %s",
dwarf_errmsg (-1));
int dw_lineno;
if (dwarf_lineno (dw_line, &dw_lineno) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineno: %s",
dwarf_errmsg (-1));
assert (lineno == dw_lineno);
int dw_colno;
if (dwarf_linecol (dw_line, &dw_colno) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineno: %s",
dwarf_errmsg (-1));
assert (colno == dw_colno);
bool begin;
if (dwarf_linebeginstatement (dw_line, &begin) != 0)
error (EXIT_FAILURE, 0, "dwarf_linebeginstatement: %s",
dwarf_errmsg (-1));
bool end;
if (dwarf_lineendsequence (dw_line, &end) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineendsequence: %s",
dwarf_errmsg (-1));
bool pend;
if (dwarf_lineprologueend (dw_line, &pend) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineprologueend: %s",
dwarf_errmsg (-1));
bool ebegin;
if (dwarf_lineepiloguebegin (dw_line, &ebegin) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineepiloguebegin: %s",
dwarf_errmsg (-1));
bool block;
if (dwarf_lineblock (dw_line, &block) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineblock: %s",
dwarf_errmsg (-1));
unsigned int isa;
if (dwarf_lineisa (dw_line, &isa) != 0)
error (EXIT_FAILURE, 0, "dwarf_lineisa: %s",
dwarf_errmsg (-1));
unsigned int disc;
if (dwarf_linediscriminator (dw_line, &disc) != 0)
error (EXIT_FAILURE, 0, "dwarf_linediscriminator: %s",
dwarf_errmsg (-1));
const char *dw_src;
Dwarf_Word dw_mtime;
Dwarf_Word dw_length;
dw_src = dwarf_linesrc (dw_line, &dw_mtime, &dw_length);
assert (strcmp (src, dw_src) == 0);
assert (mtime == dw_mtime);
assert (length == dw_length);
printf ("%zd %#" PRIx64 " %s:%d:%d\n"
" time: %#" PRIX64 ", len: %" PRIu64
", idx: %d, b: %d, e: %d"
", pe: %d, eb: %d, block: %d"
", isa: %d, disc: %d\n",
i, addr, src, lineno, colno, mtime, length,
dw_op_index, begin, end, pend, ebegin, block, isa, disc);
Dwarf_Die *linecu = dwfl_linecu (line);
assert (cu == linecu);
Dwfl_Module *linemod = dwfl_linemodule (line);
assert (mod == linemod);
}
}
}
while (cu != NULL);
dwfl_end (dwfl);
return 0;
}
/* Walk on lines of blocks included in given DIE */
static int __die_walk_funclines(Dwarf_Die *sp_die,
line_walk_handler_t handler, void *data)
{
struct __line_walk_param lw = {
.handler = handler,
.data = data,
.retval = 0,
};
Dwarf_Die die_mem;
Dwarf_Addr addr;
int lineno;
/* Handle function declaration line */
lw.fname = dwarf_decl_file(sp_die);
if (lw.fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
dwarf_entrypc(sp_die, &addr) == 0) {
lw.retval = handler(lw.fname, lineno, addr, data);
if (lw.retval != 0)
goto done;
}
die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
done:
return lw.retval;
}
static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
{
struct __line_walk_param *lw = data;
lw->retval = __die_walk_funclines(sp_die, lw->handler, lw->data);
if (lw->retval != 0)
return DWARF_CB_ABORT;
return DWARF_CB_OK;
}
/*
* Walk on lines inside given PDIE. If the PDIE is subprogram, walk only on
* the lines inside the subprogram, otherwise PDIE must be a CU DIE.
*/
static int die_walk_lines(Dwarf_Die *pdie, line_walk_handler_t handler,
void *data)
{
Dwarf_Lines *lines;
Dwarf_Line *line;
Dwarf_Addr addr;
const char *fname;
int lineno, ret = 0;
Dwarf_Die die_mem, *cu_die;
size_t nlines, i;
/* Get the CU die */
if (dwarf_tag(pdie) == DW_TAG_subprogram)
cu_die = dwarf_diecu(pdie, &die_mem, NULL, NULL);
else
cu_die = pdie;
if (!cu_die) {
pr_debug2("Failed to get CU from subprogram\n");
return -EINVAL;
}
/* Get lines list in the CU */
if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
pr_debug2("Failed to get source lines on this CU.\n");
return -ENOENT;
}
pr_debug2("Get %zd lines from this CU\n", nlines);
/* Walk on the lines on lines list */
for (i = 0; i < nlines; i++) {
line = dwarf_onesrcline(lines, i);
if (line == NULL ||
dwarf_lineno(line, &lineno) != 0 ||
dwarf_lineaddr(line, &addr) != 0) {
pr_debug2("Failed to get line info. "
"Possible error in debuginfo.\n");
continue;
}
/* Filter lines based on address */
if (pdie != cu_die)
/*
* Address filtering
* The line is included in given function, and
* no inline block includes it.
*/
if (!dwarf_haspc(pdie, addr) ||
die_find_inlinefunc(pdie, addr, &die_mem))
continue;
/* Get source line */
fname = dwarf_linesrc(line, NULL, NULL);
ret = handler(fname, lineno, addr, data);
if (ret != 0)
return ret;
}
/*
* Dwarf lines doesn't include function declarations and inlined
* subroutines. We have to check functions list or given function.
*/
if (pdie != cu_die)
ret = __die_walk_funclines(pdie, handler, data);
else {
struct __line_walk_param param = {
.handler = handler,
.data = data,
.retval = 0,
};
dwarf_getfuncs(cu_die, __die_walk_culines_cb, ¶m, 0);
ret = param.retval;
}
return ret;
}
struct __find_variable_param {
const char *name;
Dwarf_Addr addr;
};
static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
{
struct __find_variable_param *fvp = data;
int tag;
tag = dwarf_tag(die_mem);
if ((tag == DW_TAG_formal_parameter ||
tag == DW_TAG_variable) &&
die_compare_name(die_mem, fvp->name))
return DIE_FIND_CB_FOUND;
if (dwarf_haspc(die_mem, fvp->addr))
return DIE_FIND_CB_CONTINUE;
else
return DIE_FIND_CB_SIBLING;
}
/* Find a variable called 'name' at given address */
static Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
Dwarf_Addr addr, Dwarf_Die *die_mem)
{
struct __find_variable_param fvp = { .name = name, .addr = addr};
return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
die_mem);
}
static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
{
const char *name = data;
if ((dwarf_tag(die_mem) == DW_TAG_member) &&
die_compare_name(die_mem, name))
return DIE_FIND_CB_FOUND;
return DIE_FIND_CB_SIBLING;
}
/* Find a member called 'name' */
static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
Dwarf_Die *die_mem)
{
return die_find_child(st_die, __die_find_member_cb, (void *)name,
die_mem);
}
/* Get the name of given variable DIE */
static int die_get_typename(Dwarf_Die *vr_die, char *buf, int len)
{
Dwarf_Die type;
int tag, ret, ret2;
const char *tmp = "";
if (__die_get_real_type(vr_die, &type) == NULL)
return -ENOENT;
tag = dwarf_tag(&type);
if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
tmp = "*";
else if (tag == DW_TAG_subroutine_type) {
/* Function pointer */
ret = snprintf(buf, len, "(function_type)");
return (ret >= len) ? -E2BIG : ret;
} else {
if (!dwarf_diename(&type))
return -ENOENT;
if (tag == DW_TAG_union_type)
tmp = "union ";
else if (tag == DW_TAG_structure_type)
tmp = "struct ";
/* Write a base name */
ret = snprintf(buf, len, "%s%s", tmp, dwarf_diename(&type));
return (ret >= len) ? -E2BIG : ret;
}
ret = die_get_typename(&type, buf, len);
if (ret > 0) {
ret2 = snprintf(buf + ret, len - ret, "%s", tmp);
ret = (ret2 >= len - ret) ? -E2BIG : ret2 + ret;
}
return ret;
}
/* Reverse search */
int find_perf_probe_point(unsigned long addr, struct perf_probe_point *ppt)
{
Dwarf_Die cudie, spdie, indie;
Dwarf *dbg = NULL;
Dwfl *dwfl = NULL;
Dwarf_Line *line;
Dwarf_Addr laddr, eaddr, bias = 0;
const char *tmp;
int lineno, ret = 0;
bool found = false;
/* Open the live linux kernel */
dbg = dwfl_init_live_kernel_dwarf(addr, &dwfl, &bias);
if (!dbg) {
pr_warning("No debug information found in the vmlinux - "
"please rebuild with CONFIG_DEBUG_INFO=y.\n");
ret = -EINVAL;
goto end;
}
/* Adjust address with bias */
addr += bias;
/* Find cu die */
if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr - bias, &cudie)) {
pr_warning("Failed to find debug information for address %lx\n",
addr);
ret = -EINVAL;
goto end;
}
/* Find a corresponding line */
line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
if (line) {
if (dwarf_lineaddr(line, &laddr) == 0 &&
(Dwarf_Addr)addr == laddr &&
dwarf_lineno(line, &lineno) == 0) {
tmp = dwarf_linesrc(line, NULL, NULL);
if (tmp) {
ppt->line = lineno;
ppt->file = strdup(tmp);
if (ppt->file == NULL) {
ret = -ENOMEM;
goto end;
}
found = true;
}
}
}
/* Find a corresponding function */
if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
tmp = dwarf_diename(&spdie);
if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
goto end;
if (ppt->line) {
if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
&indie)) {
/* addr in an inline function */
tmp = dwarf_diename(&indie);
if (!tmp)
goto end;
ret = dwarf_decl_line(&indie, &lineno);
} else {
if (eaddr == addr) { /* Function entry */
lineno = ppt->line;
ret = 0;
} else
ret = dwarf_decl_line(&spdie, &lineno);
}
if (ret == 0) {
/* Make a relative line number */
ppt->line -= lineno;
goto found;
}
}
/* We don't have a line number, let's use offset */
ppt->offset = addr - (unsigned long)eaddr;
found:
ppt->function = strdup(tmp);
if (ppt->function == NULL) {
ret = -ENOMEM;
goto end;
}
found = true;
}
end:
if (dwfl)
dwfl_end(dwfl);
if (ret >= 0)
ret = found ? 1 : 0;
return ret;
}
void mapped_module::parseFileLineInfo() {
/* Determine if we've parsed this file already. */
image * moduleImage = obj()->parse_img();
assert( moduleImage != NULL );
const Object & moduleObject = moduleImage->getObject();
const char * fileName = moduleObject.getFileName();
/* We have not parsed this file already, so wind up libdwarf. */
int fd = open( fileName, O_RDONLY );
if (fd == -1)
return;
Dwarf_Debug dbg;
int status = dwarf_init( fd, DW_DLC_READ, & pd_dwarf_handler,
moduleObject.getErrFunc(),
& dbg, NULL );
if( status != DW_DLV_OK ) { P_close( fd ); return; }
/* Itereate over the CU headers. */
Dwarf_Unsigned header;
while( dwarf_next_cu_header( dbg, NULL, NULL, NULL, NULL, & header, NULL ) == DW_DLV_OK ) {
/* Acquire the CU DIE. */
Dwarf_Die cuDIE;
status = dwarf_siblingof( dbg, NULL, & cuDIE, NULL);
if( status != DW_DLV_OK ) {
/* If we can get no (more) CUs, we're done. */
break;
}
/* Acquire this CU's source lines. */
Dwarf_Line * lineBuffer;
Dwarf_Signed lineCount;
status = dwarf_srclines( cuDIE, & lineBuffer, & lineCount, NULL );
/* See if we can get anything useful out of the next CU
if this one is corrupt. */
if( status == DW_DLV_ERROR ) {
dwarf_printf( "%s[%d]: dwarf_srclines() error.\n" );
}
/* It's OK for a CU not to have line information. */
if( status != DW_DLV_OK ) {
/* Free this CU's DIE. */
dwarf_dealloc( dbg, cuDIE, DW_DLA_DIE );
continue;
}
assert( status == DW_DLV_OK );
/* The 'lines' returned are actually interval markers; the code
generated from lineNo runs from lineAddr up to but not including
the lineAddr of the next line. */
bool isPreviousValid = false;
Dwarf_Unsigned previousLineNo = 0;
Dwarf_Addr previousLineAddr = 0x0;
char * previousLineSource = NULL;
Address baseAddr = obj()->codeBase();
/* Iterate over this CU's source lines. */
for( int i = 0; i < lineCount; i++ ) {
/* Acquire the line number, address, source, and end of sequence flag. */
Dwarf_Unsigned lineNo;
status = dwarf_lineno( lineBuffer[i], & lineNo, NULL );
if( status != DW_DLV_OK ) { continue; }
Dwarf_Addr lineAddr;
status = dwarf_lineaddr( lineBuffer[i], & lineAddr, NULL );
if( status != DW_DLV_OK ) { continue; }
lineAddr += baseAddr;
char * lineSource;
status = dwarf_linesrc( lineBuffer[i], & lineSource, NULL );
if( status != DW_DLV_OK ) { continue; }
Dwarf_Bool isEndOfSequence;
status = dwarf_lineendsequence( lineBuffer[i], & isEndOfSequence, NULL );
if( status != DW_DLV_OK ) { continue; }
if( isPreviousValid ) {
/* If we're talking about the same (source file, line number) tuple,
and it isn't the end of the sequence, we can coalesce the range.
(The end of sequence marker marks discontinuities in the ranges.) */
if( lineNo == previousLineNo && strcmp( lineSource, previousLineSource ) == 0 && ! isEndOfSequence ) {
/* Don't update the prev* values; just keep going until we hit the end of a sequence or
a new sourcefile. */
continue;
} /* end if we can coalesce this range */
/* Determine into which mapped_module this line information should be inserted. */
int_function * currentFunction = obj()->findFuncByAddr( previousLineAddr );
if( currentFunction == NULL ) {
// /* DEBUG */ fprintf( stderr, "%s[%d]: failed to find function containing address 0x%lx; line number information will be lost.\n", __FILE__, __LINE__, lineAddr );
}
else {
mapped_module * currentModule = currentFunction->mod();
assert( currentModule != NULL );
char * canonicalLineSource = strrchr( previousLineSource, '/' );
if( canonicalLineSource == NULL ) { canonicalLineSource = previousLineSource; }
else { ++canonicalLineSource; }
/* The line 'canonicalLineSource:previousLineNo' has an address range of [previousLineAddr, lineAddr). */
currentModule->lineInfo_.addLine( canonicalLineSource, previousLineNo, previousLineAddr, lineAddr );
// /* DEBUG */ fprintf( stderr, "%s[%d]: inserted address range [0x%lx, 0x%lx) for source '%s:%u' into module '%s'.\n", __FILE__, __LINE__, previousLineAddr, lineAddr, canonicalLineSource, previousLineNo, currentModule->fileName().c_str() );
} /* end if we found the function by its address */
} /* end if the previous* variables are valid */
/* If the current line ends the sequence, invalidate previous; otherwise, update. */
if( isEndOfSequence ) {
dwarf_dealloc( dbg, lineSource, DW_DLA_STRING );
isPreviousValid = false;
}
else {
if( isPreviousValid ) { dwarf_dealloc( dbg, previousLineSource, DW_DLA_STRING ); }
previousLineNo = lineNo;
previousLineSource = lineSource;
previousLineAddr = lineAddr;
isPreviousValid = true;
} /* end if line was not the end of a sequence */
} /* end iteration over source line entries. */
/* Free this CU's source lines. */
for( int i = 0; i < lineCount; i++ ) {
dwarf_dealloc( dbg, lineBuffer[i], DW_DLA_LINE );
}
dwarf_dealloc( dbg, lineBuffer, DW_DLA_LIST );
/* Free this CU's DIE. */
dwarf_dealloc( dbg, cuDIE, DW_DLA_DIE );
} /* end CU header iteration */
/* Wind down libdwarf. */
status = dwarf_finish( dbg, NULL );
if( status != DW_DLV_OK ) {
dwarf_printf( "%s[%d]: failed to dwarf_finish()\n" );
}
P_close( fd );
/* Note that we've parsed this file. */
} /* end parseFileLineInfo() */
static void
_dwarf_lineno(Dwarf_Die die)
{
Dwarf_Line *linebuf, ln;
Dwarf_Signed linecount, lineoff;
Dwarf_Unsigned lineno, srcfileno;
Dwarf_Addr lineaddr;
Dwarf_Half tag;
Dwarf_Error de;
Dwarf_Bool linebeginstatement, lineendsequence, lineblock;
char *linesrc;
int r_srclines;
int i;
if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
tet_printf("dwarf_tag failed: %s\n", dwarf_errmsg(de));
result = TET_FAIL;
return;
}
r_srclines = dwarf_srclines(die, &linebuf, &linecount, &de);
TS_CHECK_INT(r_srclines);
if (r_srclines == DW_DLV_ERROR) {
tet_printf("dwarf_srclines should not fail but still failed:",
" %s", dwarf_errmsg(de));
return;
}
if (r_srclines != DW_DLV_OK)
return;
for (i = 0; i < linecount; i++) {
ln = linebuf[i];
if (dwarf_linebeginstatement(ln, &linebeginstatement,
&de) != DW_DLV_OK) {
tet_printf("dwarf_linebeginstatement failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_INT(linebeginstatement);
if (dwarf_linebeginstatement(ln, &linebeginstatement,
&de) != DW_DLV_OK) {
tet_printf("dwarf_linebeginstatement failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_INT(linebeginstatement);
if (dwarf_lineendsequence(ln, &lineendsequence,
&de) != DW_DLV_OK) {
tet_printf("dwarf_lineendsequence failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_INT(lineendsequence);
if (dwarf_lineno(ln, &lineno, &de) != DW_DLV_OK) {
tet_printf("dwarf_lineno failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_UINT(lineno);
if (dwarf_line_srcfileno(ln, &srcfileno, &de) != DW_DLV_OK) {
tet_printf("dwarf_line_srcfileno failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_UINT(srcfileno);
if (dwarf_lineaddr(ln, &lineaddr, &de) != DW_DLV_OK) {
tet_printf("dwarf_lineaddr failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_UINT(lineaddr);
if (dwarf_lineoff(ln, &lineoff, &de) != DW_DLV_OK) {
tet_printf("dwarf_lineoff failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_INT(lineoff);
if (dwarf_linesrc(ln, &linesrc, &de) != DW_DLV_OK) {
tet_printf("dwarf_linesrc failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_STRING(linesrc);
if (dwarf_lineblock(ln, &lineblock, &de) != DW_DLV_OK) {
tet_printf("dwarf_lineblock failed: %s",
dwarf_errmsg(de));
result = TET_FAIL;
}
TS_CHECK_INT(lineblock);
}
}
int
open_dwarf_executable (char *fileName)
{
int dwStatus = -1;
mpiPi_msg_debug ("enter open_dwarf_executable\n");
if (fileName == NULL)
{
mpiPi_msg_warn ("Executable file name is NULL!\n");
mpiPi_msg_warn
("If this is a Fortran application, you may be using the incorrect mpiP library.\n");
}
/* open the executable */
assert (dwFd == -1);
mpiPi_msg_debug ("opening file %s\n", fileName);
dwFd = open (fileName, O_RDONLY);
if (dwFd == -1)
{
mpiPi_msg_warn ("could not open file %s\n", fileName);
return 0;
}
/* initialize the DWARF library */
assert (dwHandle == NULL);
dwStatus = dwarf_init (dwFd, /* exe file descriptor */
DW_DLC_READ, /* desired access */
NULL, /* error handler */
NULL, /* error argument */
&dwHandle, /* session handle */
&dw_err); /* error object */
if (dwStatus == DW_DLV_ERROR)
{
close (dwFd);
dwFd = -1;
mpiPi_abort ("could not initialize DWARF library : %s\n", dwarf_errmsg(dw_err));
}
if (dwStatus == DW_DLV_NO_ENTRY)
{
mpiPi_msg_warn ("No symbols in the executable\n");
return 0;
}
/* initialize our function and addr-to-source mappings */
AddrToSourceMap_Init ();
FunctionMap_Init ();
/* access symbol info */
while (1)
{
Dwarf_Unsigned nextCompilationUnitHeaderOffset = 0;
Dwarf_Die currCompileUnitDIE = NULL;
Dwarf_Line *lineEntries = NULL;
Dwarf_Signed nLineEntries = 0;
Dwarf_Half currDIETag;
Dwarf_Die currChildDIE = NULL;
Dwarf_Die nextChildDIE = NULL;
Dwarf_Die oldChildDIE = NULL;
/* access next compilation unit header */
dwStatus = dwarf_next_cu_header (dwHandle, NULL, /* cu_header_length */
NULL, /* version_stamp */
NULL, /* abbrev_offset */
NULL, /* address_size */
&nextCompilationUnitHeaderOffset, &dw_err); /* error object */
if (dwStatus != DW_DLV_OK)
{
if (dwStatus != DW_DLV_NO_ENTRY)
{
mpiPi_abort ("failed to access next DWARF cu header : %s\n", dwarf_errmsg(dw_err));
}
break;
}
/* access the first debug info entry (DIE) for this computation unit */
dwStatus = dwarf_siblingof (dwHandle, NULL, /* current DIE */
&currCompileUnitDIE, /* sibling DIE */
&dw_err); /* error object */
if (dwStatus != DW_DLV_OK)
{
mpiPi_abort ("failed to access first DWARF DIE : %s\n", dwarf_errmsg(dw_err));
}
/* get line number information for this compilation
* unit, if available
*/
dwStatus = dwarf_srclines (currCompileUnitDIE,
&lineEntries, &nLineEntries, &dw_err);
if (dwStatus == DW_DLV_OK)
{
unsigned int i;
/*
* Extract and save address-to-source line mapping.
*
* NOTE: At least on the Cray X1, we see line number
* information with the same address mapping to different lines.
* It seems like when there are multiple entries for a given
* address, the last one is the correct one. (Needs verification.)
* If we see multiple entries for a given address, we only
* save the last one.
*/
for (i = 0; i < nLineEntries; i++)
{
Dwarf_Unsigned lineNumber = 0;
Dwarf_Addr lineAddress = 0;
char *lineSourceFile = NULL;
int lineNoStatus, lineAddrStatus, lineSrcFileStatus;
lineNoStatus = dwarf_lineno (lineEntries[i],
&lineNumber,
&dw_err);
if (lineNoStatus != DW_DLV_OK)
mpiPi_msg_debug("Failed to get line number : %s\n", dwarf_errmsg(dw_err));
lineAddrStatus = dwarf_lineaddr (lineEntries[i],
&lineAddress,
&dw_err);
if (lineAddrStatus != DW_DLV_OK)
mpiPi_msg_debug("Failed to get line address : %s\n", dwarf_errmsg(dw_err));
lineSrcFileStatus = dwarf_linesrc (lineEntries[i],
&lineSourceFile,
&dw_err);
if (lineSrcFileStatus != DW_DLV_OK)
mpiPi_msg_debug("Failed to get source file status : %s\n", dwarf_errmsg(dw_err));
if ((lineNoStatus == DW_DLV_OK) &&
(lineAddrStatus == DW_DLV_OK)
&& (lineSrcFileStatus == DW_DLV_OK))
{
int saveCurrentEntry = 0; /* bool */
if (i < (nLineEntries - 1))
{
/*
* We're not on the last line number entry -
* check the address associated with the next
* entry to see if it differs from this one.
* Only save the entry if it the next address
* differs.
*/
Dwarf_Addr nextLineAddress = 0;
int nextLineAddrStatus =
dwarf_lineaddr (lineEntries[i + 1],
&nextLineAddress,
&dw_err);
assert (nextLineAddrStatus == DW_DLV_OK);
if (nextLineAddress != lineAddress)
{
saveCurrentEntry = 1;
}
}
else
{
/* we're on the last line number entry */
saveCurrentEntry = 1;
}
if (saveCurrentEntry)
{
/* save the mapping entry */
AddrToSourceMap_Add (lineAddress, lineSourceFile,
lineNumber);
}
}
if (lineSourceFile != NULL)
{
dwarf_dealloc (dwHandle, lineSourceFile, DW_DLA_STRING);
}
}
/* release the line number info */
for (i = 0; i < nLineEntries; i++)
{
dwarf_dealloc (dwHandle, lineEntries[i], DW_DLA_LINE);
}
dwarf_dealloc (dwHandle, lineEntries, DW_DLA_LIST);
}
else if (dwStatus != DW_DLV_ERROR)
{
/*
* no line information for the current DIE -
* not an error, just unfortunate
*/
}
else
{
mpiPi_abort ("failed to obtain line info for the current DIE : %s\n", dwarf_errmsg(dw_err));
}
/* discover function information for the current compilation unit */
/*
* NOTE: DWARF debug information entries can be organized in
* a hierarchy. However, we presume that the function entries are
* all children of the compilation unit DIE.
*/
dwStatus = dwarf_tag (currCompileUnitDIE, &currDIETag, &dw_err);
assert ((dwStatus == DW_DLV_OK) && (currDIETag == DW_TAG_compile_unit));
/* access the first child DIE of the compile unit DIE */
dwStatus = dwarf_child (currCompileUnitDIE, &currChildDIE, &dw_err);
if (dwStatus == DW_DLV_NO_ENTRY)
{
// On some Cray systems, executables are linked with assembly compile units
// with no functions.
// mpiPi_abort ("no child DIEs of compile unit DIE\n");
}
else if (dwStatus != DW_DLV_OK)
{
mpiPi_abort
("failed to access first child DIE of compile unit DIE\n");
}
while (dwStatus == DW_DLV_OK)
{
/* determine the type of the child DIE */
dwStatus = dwarf_tag (currChildDIE, &currDIETag, &dw_err);
if (dwStatus == DW_DLV_OK)
{
if ((currDIETag == DW_TAG_subprogram) ||
(currDIETag == DW_TAG_entry_point))
{
HandleFunctionDIE (dwHandle, currChildDIE);
}
}
else
{
mpiPi_abort ("unable to determine tag of current child DIE : %s \n", dwarf_errmsg(dw_err));
}
/* advance to the next child DIE */
oldChildDIE = currChildDIE;
dwStatus = dwarf_siblingof (dwHandle,
currChildDIE, &nextChildDIE, &dw_err);
if (dwStatus == DW_DLV_OK)
{
currChildDIE = nextChildDIE;
nextChildDIE = NULL;
}
else if (dwStatus != DW_DLV_NO_ENTRY)
{
mpiPi_abort
("unable to access next child DIE of current compilation unit : %s\n", dwarf_errmsg(dw_err));
}
if (oldChildDIE != NULL)
{
dwarf_dealloc (dwHandle, oldChildDIE, DW_DLA_DIE);
}
}
/* release the current compilation unit DIE */
dwarf_dealloc (dwHandle, currCompileUnitDIE, DW_DLA_DIE);
}
/*
* DWARF address-to-source line information does not give
* address ranges, so we need to patch the address ranges
* in our address-to-source map.
*/
AddrToSourceMap_PatchRanges ();
return 1;
}
bool FLinuxCrashContext::GetInfoForAddress(void * Address, const char **OutFunctionNamePtr, const char **OutSourceFilePtr, int *OutLineNumberPtr)
{
if (DebugInfo == NULL)
{
return false;
}
Dwarf_Die Die;
Dwarf_Unsigned Addr = reinterpret_cast< Dwarf_Unsigned >( Address ), LineNumber = 0;
const char * SrcFile = NULL;
checkAtCompileTime(sizeof(Dwarf_Unsigned) >= sizeof(Address), _Dwarf_Unsigned_type_should_be_long_enough_to_represent_pointers_Check_libdwarf_bitness);
int ReturnCode = DW_DLV_OK;
Dwarf_Error ErrorInfo;
bool bExitHeaderLoop = false;
int32 MaxCompileUnitsAllowed = 16 * 1024 * 1024; // safeguard to make sure we never get into an infinite loop
const int32 kMaxBufferLinesAllowed = 16 * 1024 * 1024; // safeguard to prevent too long line loop
for(;;)
{
if (--MaxCompileUnitsAllowed <= 0)
{
fprintf(stderr, "Breaking out from what seems to be an infinite loop during DWARF parsing (too many compile units).\n");
ReturnCode = DW_DLE_DIE_NO_CU_CONTEXT; // invalidate
break;
}
if (bExitHeaderLoop)
break;
ReturnCode = dwarf_next_cu_header(DebugInfo, NULL, NULL, NULL, NULL, NULL, &ErrorInfo);
if (ReturnCode != DW_DLV_OK)
break;
Die = NULL;
while(dwarf_siblingof(DebugInfo, Die, &Die, &ErrorInfo) == DW_DLV_OK)
{
Dwarf_Half Tag;
if (dwarf_tag(Die, &Tag, &ErrorInfo) != DW_DLV_OK)
{
bExitHeaderLoop = true;
break;
}
if (Tag == DW_TAG_compile_unit)
{
break;
}
}
if (Die == NULL)
{
break;
}
// check if address is inside this CU
Dwarf_Unsigned LowerPC, HigherPC;
if (!dwarf_attrval_unsigned(Die, DW_AT_low_pc, &LowerPC, &ErrorInfo) && !dwarf_attrval_unsigned(Die, DW_AT_high_pc, &HigherPC, &ErrorInfo))
{
if (Addr < LowerPC || Addr >= HigherPC)
{
continue;
}
}
Dwarf_Line * LineBuf;
Dwarf_Signed NumLines = kMaxBufferLinesAllowed;
if (dwarf_srclines(Die, &LineBuf, &NumLines, &ErrorInfo) != DW_DLV_OK)
{
// could not get line info for some reason
break;
}
if (NumLines >= kMaxBufferLinesAllowed)
{
fprintf(stderr, "Number of lines associated with a DIE looks unreasonable (%ld), early quitting.\n", NumLines);
ReturnCode = DW_DLE_DIE_NO_CU_CONTEXT; // invalidate
break;
}
// look which line is that
Dwarf_Addr LineAddress, PrevLineAddress = ~0ULL;
Dwarf_Unsigned PrevLineNumber = 0;
const char * PrevSrcFile = NULL;
char * SrcFileTemp = NULL;
for (int Idx = 0; Idx < NumLines; ++Idx)
{
if (dwarf_lineaddr(LineBuf[Idx], &LineAddress, &ErrorInfo) != 0 ||
dwarf_lineno(LineBuf[Idx], &LineNumber, &ErrorInfo) != 0)
{
bExitHeaderLoop = true;
break;
}
if (!dwarf_linesrc(LineBuf[Idx], &SrcFileTemp, &ErrorInfo))
{
SrcFile = SrcFileTemp;
}
// check if we hit the exact line
if (Addr == LineAddress)
{
bExitHeaderLoop = true;
break;
}
else if (PrevLineAddress < Addr && Addr < LineAddress)
{
LineNumber = PrevLineNumber;
SrcFile = PrevSrcFile;
bExitHeaderLoop = true;
break;
}
PrevLineAddress = LineAddress;
PrevLineNumber = LineNumber;
PrevSrcFile = SrcFile;
}
}
const char * FunctionName = NULL;
if (ReturnCode == DW_DLV_OK)
{
FindFunctionNameInDIEAndChildren(DebugInfo, Die, Addr, &FunctionName);
}
if (OutFunctionNamePtr != NULL && FunctionName != NULL)
{
*OutFunctionNamePtr = FunctionName;
}
if (OutSourceFilePtr != NULL && SrcFile != NULL)
{
*OutSourceFilePtr = SrcFile;
if (OutLineNumberPtr != NULL)
{
*OutLineNumberPtr = LineNumber;
}
}
// Resets internal CU pointer, so next time we get here it begins from the start
while (ReturnCode != DW_DLV_NO_ENTRY)
{
if (ReturnCode == DW_DLV_ERROR)
break;
ReturnCode = dwarf_next_cu_header(DebugInfo, NULL, NULL, NULL, NULL, NULL, &ErrorInfo);
}
// if we weren't able to find a function name, don't trust the source file either
return FunctionName != NULL;
}
static void
translate(Dwarf_Debug dbg, const char* addrstr)
{
Dwarf_Die die, ret_die;
Dwarf_Line *lbuf;
Dwarf_Error de;
Dwarf_Half tag;
Dwarf_Unsigned lopc, hipc, addr, lineno, plineno;
Dwarf_Signed lcount;
Dwarf_Addr lineaddr, plineaddr;
char *funcname;
char *file, *file0, *pfile;
char demangled[1024];
int i, ret;
addr = strtoull(addrstr, NULL, 16);
addr += section_base;
lineno = 0;
file = unknown;
die = NULL;
lbuf = NULL;
lcount = 0;
while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
&de)) == DW_DLV_OK) {
die = NULL;
while (dwarf_siblingof(dbg, die, &ret_die, &de) == DW_DLV_OK) {
if (die != NULL)
dwarf_dealloc(dbg, die, DW_DLA_DIE);
die = ret_die;
if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
warnx("dwarf_tag failed: %s",
dwarf_errmsg(de));
goto next_cu;
}
/* XXX: What about DW_TAG_partial_unit? */
if (tag == DW_TAG_compile_unit)
break;
}
if (ret_die == NULL) {
warnx("could not find DW_TAG_compile_unit die");
goto next_cu;
}
if (!dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) &&
!dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de)) {
/*
* Check if the address falls into the PC range of
* this CU.
*/
if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
goto next_cu;
if (addr < lopc || addr >= hipc)
goto next_cu;
}
switch (dwarf_srclines(die, &lbuf, &lcount, &de)) {
case DW_DLV_OK:
break;
case DW_DLV_NO_ENTRY:
/* If a CU lacks debug info, just skip it. */
goto next_cu;
default:
warnx("dwarf_srclines: %s", dwarf_errmsg(de));
goto out;
}
plineaddr = ~0ULL;
plineno = 0;
pfile = unknown;
for (i = 0; i < lcount; i++) {
if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) {
warnx("dwarf_lineaddr: %s",
dwarf_errmsg(de));
goto out;
}
if (dwarf_lineno(lbuf[i], &lineno, &de)) {
warnx("dwarf_lineno: %s",
dwarf_errmsg(de));
goto out;
}
if (dwarf_linesrc(lbuf[i], &file0, &de)) {
warnx("dwarf_linesrc: %s",
dwarf_errmsg(de));
} else
file = file0;
if (addr == lineaddr)
goto out;
else if (addr < lineaddr && addr > plineaddr) {
lineno = plineno;
file = pfile;
goto out;
}
plineaddr = lineaddr;
plineno = lineno;
pfile = file;
}
next_cu:
if (die != NULL) {
dwarf_dealloc(dbg, die, DW_DLA_DIE);
die = NULL;
}
}
out:
funcname = NULL;
if (ret == DW_DLV_OK && func) {
search_func(dbg, die, addr, &funcname);
die = NULL;
}
if (func) {
if (funcname == NULL)
if ((funcname = strdup(unknown)) == NULL)
err(EXIT_FAILURE, "strdup");
if (demangle &&
!elftc_demangle(funcname, demangled, sizeof(demangled), 0))
printf("%s\n", demangled);
else
printf("%s\n", funcname);
free(funcname);
}
(void) printf("%s:%ju\n", base ? basename(file) : file, lineno);
if (die != NULL)
dwarf_dealloc(dbg, die, DW_DLA_DIE);
/*
* Reset internal CU pointer, so we will start from the first CU
* next round.
*/
while (ret != DW_DLV_NO_ENTRY) {
if (ret == DW_DLV_ERROR)
errx(EXIT_FAILURE, "dwarf_next_cu_header: %s",
dwarf_errmsg(de));
ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
&de);
}
}
