/** * die_get_call_file - Get callsite file name of inlined function instance * @in_die: a DIE of an inlined function instance * * Get call-site file name of @in_die. This means from which file the inline * function is called. */ const char *die_get_call_file(Dwarf_Die *in_die) { Dwarf_Die cu_die; Dwarf_Files *files; int idx; idx = die_get_call_fileno(in_die); if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) || dwarf_getsrcfiles(&cu_die, &files, NULL) != 0) return NULL; return dwarf_filesrc(files, idx, NULL, NULL); }
/** * 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; }
int sparc_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp) { /* Start with the function's type, and get the DW_AT_type attribute, which is the type of the return value. */ Dwarf_Attribute attr_mem; Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type, &attr_mem); if (attr == NULL) /* The function has no return value, like a `void' function in C. */ return 0; Dwarf_Die die_mem; Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem); int tag = DWARF_TAG_OR_RETURN (typedie); /* Follow typedefs and qualifiers to get to the actual type. */ while (tag == DW_TAG_typedef || tag == DW_TAG_const_type || tag == DW_TAG_volatile_type || tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type) { attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem); typedie = dwarf_formref_die (attr, &die_mem); tag = DWARF_TAG_OR_RETURN (typedie); } Dwarf_Word size; switch (tag) { case -1: return -1; case DW_TAG_subrange_type: if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size)) { attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem); typedie = dwarf_formref_die (attr, &die_mem); tag = DWARF_TAG_OR_RETURN (typedie); } /* Fall through. */ case DW_TAG_base_type: case DW_TAG_enumeration_type: case DW_TAG_pointer_type: case DW_TAG_ptr_to_member_type: if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size, &attr_mem), &size) != 0) { uint8_t asize; Dwarf_Die cudie; if ((tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type) && dwarf_diecu (typedie, &cudie, &asize, NULL) != NULL) size = asize; else return -1; } if (tag == DW_TAG_base_type) { Dwarf_Word encoding; if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding, &attr_mem), &encoding) != 0) return -1; if (encoding == DW_ATE_float) { *locp = loc_fpreg; if (size <= 4) return nloc_fpreg; if (size <= 8) return nloc_fpregpair; if (size <= 16) return nloc_fpregquad; } } if (size <= 8) { intreg: *locp = loc_intreg; return size <= 4 ? nloc_intreg : nloc_intregpair; } aggregate: *locp = loc_aggregate; return nloc_aggregate; case DW_TAG_structure_type: case DW_TAG_class_type: case DW_TAG_union_type: case DW_TAG_array_type: if (dwarf_aggregate_size (typedie, &size) == 0 && size > 0 && size <= 8) goto intreg; goto aggregate; } /* XXX We don't have a good way to return specific errors from ebl calls. This value means we do not understand the type, but it is well-formed DWARF and might be valid. */ return -2; }
/* 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; }