2 * dwarf-aux.c : libdw auxiliary interfaces
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 #include "dwarf-aux.h"
29 * cu_find_realpath - Find the realpath of the target file
30 * @cu_die: A DIE(dwarf information entry) of CU(compilation Unit)
31 * @fname: The tail filename of the target file
33 * Find the real(long) path of @fname in @cu_die.
35 const char *cu_find_realpath(Dwarf_Die
*cu_die
, const char *fname
)
39 const char *src
= NULL
;
45 ret
= dwarf_getsrcfiles(cu_die
, &files
, &nfiles
);
49 for (i
= 0; i
< nfiles
; i
++) {
50 src
= dwarf_filesrc(files
, i
, NULL
, NULL
);
51 if (strtailcmp(src
, fname
) == 0)
60 * cu_get_comp_dir - Get the path of compilation directory
63 * Get the path of compilation directory of given @cu_die.
64 * Since this depends on DW_AT_comp_dir, older gcc will not
65 * embedded it. In that case, this returns NULL.
67 const char *cu_get_comp_dir(Dwarf_Die
*cu_die
)
70 if (dwarf_attr(cu_die
, DW_AT_comp_dir
, &attr
) == NULL
)
72 return dwarf_formstring(&attr
);
76 * cu_find_lineinfo - Get a line number and file name for given address
79 * @fname: a pointer which returns the file name string
80 * @lineno: a pointer which returns the line number
82 * Find a line number and file name for @addr in @cu_die.
84 int cu_find_lineinfo(Dwarf_Die
*cu_die
, unsigned long addr
,
85 const char **fname
, int *lineno
)
90 line
= dwarf_getsrc_die(cu_die
, (Dwarf_Addr
)addr
);
91 if (line
&& dwarf_lineaddr(line
, &laddr
) == 0 &&
92 addr
== (unsigned long)laddr
&& dwarf_lineno(line
, lineno
) == 0) {
93 *fname
= dwarf_linesrc(line
, NULL
, NULL
);
95 /* line number is useless without filename */
99 return *lineno
?: -ENOENT
;
102 static int __die_find_inline_cb(Dwarf_Die
*die_mem
, void *data
);
105 * cu_walk_functions_at - Walk on function DIEs at given address
108 * @callback: A callback which called with found DIEs
111 * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
112 * should be subprogram or inlined-subroutines.
114 int cu_walk_functions_at(Dwarf_Die
*cu_die
, Dwarf_Addr addr
,
115 int (*callback
)(Dwarf_Die
*, void *), void *data
)
121 /* Inlined function could be recursive. Trace it until fail */
122 for (sc_die
= die_find_realfunc(cu_die
, addr
, &die_mem
);
124 sc_die
= die_find_child(sc_die
, __die_find_inline_cb
, &addr
,
126 ret
= callback(sc_die
, data
);
136 * die_get_linkage_name - Get the linkage name of the object
137 * @dw_die: A DIE of the object
139 * Get the linkage name attiribute of given @dw_die.
140 * For C++ binary, the linkage name will be the mangled symbol.
142 const char *die_get_linkage_name(Dwarf_Die
*dw_die
)
144 Dwarf_Attribute attr
;
146 if (dwarf_attr_integrate(dw_die
, DW_AT_linkage_name
, &attr
) == NULL
)
148 return dwarf_formstring(&attr
);
152 * die_compare_name - Compare diename and tname
154 * @tname: a string of target name
156 * Compare the name of @dw_die and @tname. Return false if @dw_die has no name.
158 bool die_compare_name(Dwarf_Die
*dw_die
, const char *tname
)
162 name
= dwarf_diename(dw_die
);
163 return name
? (strcmp(tname
, name
) == 0) : false;
167 * die_match_name - Match diename/linkage name and glob
169 * @glob: a string of target glob pattern
171 * Glob matching the name of @dw_die and @glob. Return false if matching fail.
172 * This also match linkage name.
174 bool die_match_name(Dwarf_Die
*dw_die
, const char *glob
)
178 name
= dwarf_diename(dw_die
);
179 if (name
&& strglobmatch(name
, glob
))
181 /* fall back to check linkage name */
182 name
= die_get_linkage_name(dw_die
);
183 if (name
&& strglobmatch(name
, glob
))
190 * die_get_call_lineno - Get callsite line number of inline-function instance
191 * @in_die: a DIE of an inlined function instance
193 * Get call-site line number of @in_die. This means from where the inline
194 * function is called.
196 int die_get_call_lineno(Dwarf_Die
*in_die
)
198 Dwarf_Attribute attr
;
201 if (!dwarf_attr(in_die
, DW_AT_call_line
, &attr
))
204 dwarf_formudata(&attr
, &ret
);
209 * die_get_type - Get type DIE
210 * @vr_die: a DIE of a variable
211 * @die_mem: where to store a type DIE
213 * Get a DIE of the type of given variable (@vr_die), and store
214 * it to die_mem. Return NULL if fails to get a type DIE.
216 Dwarf_Die
*die_get_type(Dwarf_Die
*vr_die
, Dwarf_Die
*die_mem
)
218 Dwarf_Attribute attr
;
220 if (dwarf_attr_integrate(vr_die
, DW_AT_type
, &attr
) &&
221 dwarf_formref_die(&attr
, die_mem
))
227 /* Get a type die, but skip qualifiers */
228 static Dwarf_Die
*__die_get_real_type(Dwarf_Die
*vr_die
, Dwarf_Die
*die_mem
)
233 vr_die
= die_get_type(vr_die
, die_mem
);
236 tag
= dwarf_tag(vr_die
);
237 } while (tag
== DW_TAG_const_type
||
238 tag
== DW_TAG_restrict_type
||
239 tag
== DW_TAG_volatile_type
||
240 tag
== DW_TAG_shared_type
);
246 * die_get_real_type - Get a type die, but skip qualifiers and typedef
247 * @vr_die: a DIE of a variable
248 * @die_mem: where to store a type DIE
250 * Get a DIE of the type of given variable (@vr_die), and store
251 * it to die_mem. Return NULL if fails to get a type DIE.
252 * If the type is qualifiers (e.g. const) or typedef, this skips it
253 * and tries to find real type (structure or basic types, e.g. int).
255 Dwarf_Die
*die_get_real_type(Dwarf_Die
*vr_die
, Dwarf_Die
*die_mem
)
258 vr_die
= __die_get_real_type(vr_die
, die_mem
);
259 } while (vr_die
&& dwarf_tag(vr_die
) == DW_TAG_typedef
);
264 /* Get attribute and translate it as a udata */
265 static int die_get_attr_udata(Dwarf_Die
*tp_die
, unsigned int attr_name
,
268 Dwarf_Attribute attr
;
270 if (dwarf_attr(tp_die
, attr_name
, &attr
) == NULL
||
271 dwarf_formudata(&attr
, result
) != 0)
277 /* Get attribute and translate it as a sdata */
278 static int die_get_attr_sdata(Dwarf_Die
*tp_die
, unsigned int attr_name
,
281 Dwarf_Attribute attr
;
283 if (dwarf_attr(tp_die
, attr_name
, &attr
) == NULL
||
284 dwarf_formsdata(&attr
, result
) != 0)
291 * die_is_signed_type - Check whether a type DIE is signed or not
292 * @tp_die: a DIE of a type
294 * Get the encoding of @tp_die and return true if the encoding
297 bool die_is_signed_type(Dwarf_Die
*tp_die
)
301 if (die_get_attr_udata(tp_die
, DW_AT_encoding
, &ret
))
304 return (ret
== DW_ATE_signed_char
|| ret
== DW_ATE_signed
||
305 ret
== DW_ATE_signed_fixed
);
309 * die_is_func_def - Ensure that this DIE is a subprogram and definition
312 * Ensure that this DIE is a subprogram and NOT a declaration. This
313 * returns true if @dw_die is a function definition.
315 bool die_is_func_def(Dwarf_Die
*dw_die
)
317 Dwarf_Attribute attr
;
319 return (dwarf_tag(dw_die
) == DW_TAG_subprogram
&&
320 dwarf_attr(dw_die
, DW_AT_declaration
, &attr
) == NULL
);
324 * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
327 * Ensure that this DIE is an instance (which has an entry address).
328 * This returns true if @dw_die is a function instance. If not, you need to
329 * call die_walk_instances() to find actual instances.
331 bool die_is_func_instance(Dwarf_Die
*dw_die
)
335 /* Actually gcc optimizes non-inline as like as inlined */
336 return !dwarf_func_inline(dw_die
) && dwarf_entrypc(dw_die
, &tmp
) == 0;
339 * die_get_data_member_location - Get the data-member offset
340 * @mb_die: a DIE of a member of a data structure
341 * @offs: The offset of the member in the data structure
343 * Get the offset of @mb_die in the data structure including @mb_die, and
344 * stores result offset to @offs. If any error occurs this returns errno.
346 int die_get_data_member_location(Dwarf_Die
*mb_die
, Dwarf_Word
*offs
)
348 Dwarf_Attribute attr
;
353 if (dwarf_attr(mb_die
, DW_AT_data_member_location
, &attr
) == NULL
)
356 if (dwarf_formudata(&attr
, offs
) != 0) {
357 /* DW_AT_data_member_location should be DW_OP_plus_uconst */
358 ret
= dwarf_getlocation(&attr
, &expr
, &nexpr
);
359 if (ret
< 0 || nexpr
== 0)
362 if (expr
[0].atom
!= DW_OP_plus_uconst
|| nexpr
!= 1) {
363 pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
364 expr
[0].atom
, nexpr
);
367 *offs
= (Dwarf_Word
)expr
[0].number
;
372 /* Get the call file index number in CU DIE */
373 static int die_get_call_fileno(Dwarf_Die
*in_die
)
377 if (die_get_attr_sdata(in_die
, DW_AT_call_file
, &idx
) == 0)
383 /* Get the declared file index number in CU DIE */
384 static int die_get_decl_fileno(Dwarf_Die
*pdie
)
388 if (die_get_attr_sdata(pdie
, DW_AT_decl_file
, &idx
) == 0)
395 * die_get_call_file - Get callsite file name of inlined function instance
396 * @in_die: a DIE of an inlined function instance
398 * Get call-site file name of @in_die. This means from which file the inline
399 * function is called.
401 const char *die_get_call_file(Dwarf_Die
*in_die
)
407 idx
= die_get_call_fileno(in_die
);
408 if (idx
< 0 || !dwarf_diecu(in_die
, &cu_die
, NULL
, NULL
) ||
409 dwarf_getsrcfiles(&cu_die
, &files
, NULL
) != 0)
412 return dwarf_filesrc(files
, idx
, NULL
, NULL
);
417 * die_find_child - Generic DIE search function in DIE tree
418 * @rt_die: a root DIE
419 * @callback: a callback function
420 * @data: a user data passed to the callback function
421 * @die_mem: a buffer for result DIE
423 * Trace DIE tree from @rt_die and call @callback for each child DIE.
424 * If @callback returns DIE_FIND_CB_END, this stores the DIE into
425 * @die_mem and returns it. If @callback returns DIE_FIND_CB_CONTINUE,
426 * this continues to trace the tree. Optionally, @callback can return
427 * DIE_FIND_CB_CHILD and DIE_FIND_CB_SIBLING, those means trace only
428 * the children and trace only the siblings respectively.
429 * Returns NULL if @callback can't find any appropriate DIE.
431 Dwarf_Die
*die_find_child(Dwarf_Die
*rt_die
,
432 int (*callback
)(Dwarf_Die
*, void *),
433 void *data
, Dwarf_Die
*die_mem
)
438 ret
= dwarf_child(rt_die
, die_mem
);
443 ret
= callback(die_mem
, data
);
444 if (ret
== DIE_FIND_CB_END
)
447 if ((ret
& DIE_FIND_CB_CHILD
) &&
448 die_find_child(die_mem
, callback
, data
, &child_die
)) {
449 memcpy(die_mem
, &child_die
, sizeof(Dwarf_Die
));
452 } while ((ret
& DIE_FIND_CB_SIBLING
) &&
453 dwarf_siblingof(die_mem
, die_mem
) == 0);
458 struct __addr_die_search_param
{
463 static int __die_search_func_tail_cb(Dwarf_Die
*fn_die
, void *data
)
465 struct __addr_die_search_param
*ad
= data
;
468 if (dwarf_tag(fn_die
) == DW_TAG_subprogram
&&
469 !dwarf_highpc(fn_die
, &addr
) &&
471 memcpy(ad
->die_mem
, fn_die
, sizeof(Dwarf_Die
));
472 return DWARF_CB_ABORT
;
478 * die_find_tailfunc - Search for a non-inlined function with tail call at
480 * @cu_die: a CU DIE which including @addr
481 * @addr: target address
482 * @die_mem: a buffer for result DIE
484 * Search for a non-inlined function DIE with tail call at @addr. Stores the
485 * DIE to @die_mem and returns it if found. Returns NULL if failed.
487 Dwarf_Die
*die_find_tailfunc(Dwarf_Die
*cu_die
, Dwarf_Addr addr
,
490 struct __addr_die_search_param ad
;
492 ad
.die_mem
= die_mem
;
493 /* dwarf_getscopes can't find subprogram. */
494 if (!dwarf_getfuncs(cu_die
, __die_search_func_tail_cb
, &ad
, 0))
500 /* die_find callback for non-inlined function search */
501 static int __die_search_func_cb(Dwarf_Die
*fn_die
, void *data
)
503 struct __addr_die_search_param
*ad
= data
;
506 * Since a declaration entry doesn't has given pc, this always returns
507 * function definition entry.
509 if (dwarf_tag(fn_die
) == DW_TAG_subprogram
&&
510 dwarf_haspc(fn_die
, ad
->addr
)) {
511 memcpy(ad
->die_mem
, fn_die
, sizeof(Dwarf_Die
));
512 return DWARF_CB_ABORT
;
518 * die_find_realfunc - Search a non-inlined function at given address
519 * @cu_die: a CU DIE which including @addr
520 * @addr: target address
521 * @die_mem: a buffer for result DIE
523 * Search a non-inlined function DIE which includes @addr. Stores the
524 * DIE to @die_mem and returns it if found. Returns NULL if failed.
526 Dwarf_Die
*die_find_realfunc(Dwarf_Die
*cu_die
, Dwarf_Addr addr
,
529 struct __addr_die_search_param ad
;
531 ad
.die_mem
= die_mem
;
532 /* dwarf_getscopes can't find subprogram. */
533 if (!dwarf_getfuncs(cu_die
, __die_search_func_cb
, &ad
, 0))
539 /* die_find callback for inline function search */
540 static int __die_find_inline_cb(Dwarf_Die
*die_mem
, void *data
)
542 Dwarf_Addr
*addr
= data
;
544 if (dwarf_tag(die_mem
) == DW_TAG_inlined_subroutine
&&
545 dwarf_haspc(die_mem
, *addr
))
546 return DIE_FIND_CB_END
;
548 return DIE_FIND_CB_CONTINUE
;
552 * die_find_top_inlinefunc - Search the top inlined function at given address
553 * @sp_die: a subprogram DIE which including @addr
554 * @addr: target address
555 * @die_mem: a buffer for result DIE
557 * Search an inlined function DIE which includes @addr. Stores the
558 * DIE to @die_mem and returns it if found. Returns NULL if failed.
559 * Even if several inlined functions are expanded recursively, this
560 * doesn't trace it down, and returns the topmost one.
562 Dwarf_Die
*die_find_top_inlinefunc(Dwarf_Die
*sp_die
, Dwarf_Addr addr
,
565 return die_find_child(sp_die
, __die_find_inline_cb
, &addr
, die_mem
);
569 * die_find_inlinefunc - Search an inlined function at given address
570 * @sp_die: a subprogram DIE which including @addr
571 * @addr: target address
572 * @die_mem: a buffer for result DIE
574 * Search an inlined function DIE which includes @addr. Stores the
575 * DIE to @die_mem and returns it if found. Returns NULL if failed.
576 * If several inlined functions are expanded recursively, this trace
577 * it down and returns deepest one.
579 Dwarf_Die
*die_find_inlinefunc(Dwarf_Die
*sp_die
, Dwarf_Addr addr
,
584 sp_die
= die_find_child(sp_die
, __die_find_inline_cb
, &addr
, &tmp_die
);
588 /* Inlined function could be recursive. Trace it until fail */
590 memcpy(die_mem
, sp_die
, sizeof(Dwarf_Die
));
591 sp_die
= die_find_child(sp_die
, __die_find_inline_cb
, &addr
,
598 struct __instance_walk_param
{
600 int (*callback
)(Dwarf_Die
*, void *);
605 static int __die_walk_instances_cb(Dwarf_Die
*inst
, void *data
)
607 struct __instance_walk_param
*iwp
= data
;
608 Dwarf_Attribute attr_mem
;
609 Dwarf_Die origin_mem
;
610 Dwarf_Attribute
*attr
;
614 attr
= dwarf_attr(inst
, DW_AT_abstract_origin
, &attr_mem
);
616 return DIE_FIND_CB_CONTINUE
;
618 origin
= dwarf_formref_die(attr
, &origin_mem
);
619 if (origin
== NULL
|| origin
->addr
!= iwp
->addr
)
620 return DIE_FIND_CB_CONTINUE
;
622 /* Ignore redundant instances */
623 if (dwarf_tag(inst
) == DW_TAG_inlined_subroutine
) {
624 dwarf_decl_line(origin
, &tmp
);
625 if (die_get_call_lineno(inst
) == tmp
) {
626 tmp
= die_get_decl_fileno(origin
);
627 if (die_get_call_fileno(inst
) == tmp
)
628 return DIE_FIND_CB_CONTINUE
;
632 iwp
->retval
= iwp
->callback(inst
, iwp
->data
);
634 return (iwp
->retval
) ? DIE_FIND_CB_END
: DIE_FIND_CB_CONTINUE
;
638 * die_walk_instances - Walk on instances of given DIE
639 * @or_die: an abstract original DIE
640 * @callback: a callback function which is called with instance DIE
643 * Walk on the instances of give @in_die. @in_die must be an inlined function
644 * declartion. This returns the return value of @callback if it returns
645 * non-zero value, or -ENOENT if there is no instance.
647 int die_walk_instances(Dwarf_Die
*or_die
, int (*callback
)(Dwarf_Die
*, void *),
652 struct __instance_walk_param iwp
= {
653 .addr
= or_die
->addr
,
654 .callback
= callback
,
659 if (dwarf_diecu(or_die
, &cu_die
, NULL
, NULL
) == NULL
)
662 die_find_child(&cu_die
, __die_walk_instances_cb
, &iwp
, &die_mem
);
667 /* Line walker internal parameters */
668 struct __line_walk_param
{
670 line_walk_callback_t callback
;
675 static int __die_walk_funclines_cb(Dwarf_Die
*in_die
, void *data
)
677 struct __line_walk_param
*lw
= data
;
682 if (dwarf_tag(in_die
) == DW_TAG_inlined_subroutine
) {
683 fname
= die_get_call_file(in_die
);
684 lineno
= die_get_call_lineno(in_die
);
685 if (fname
&& lineno
> 0 && dwarf_entrypc(in_die
, &addr
) == 0) {
686 lw
->retval
= lw
->callback(fname
, lineno
, addr
, lw
->data
);
688 return DIE_FIND_CB_END
;
692 /* Don't need to search recursively */
693 return DIE_FIND_CB_SIBLING
;
696 fname
= dwarf_decl_file(in_die
);
697 if (fname
&& dwarf_decl_line(in_die
, &lineno
) == 0) {
698 lw
->retval
= lw
->callback(fname
, lineno
, addr
, lw
->data
);
700 return DIE_FIND_CB_END
;
704 /* Continue to search nested inlined function call-sites */
705 return DIE_FIND_CB_CONTINUE
;
708 /* Walk on lines of blocks included in given DIE */
709 static int __die_walk_funclines(Dwarf_Die
*sp_die
, bool recursive
,
710 line_walk_callback_t callback
, void *data
)
712 struct __line_walk_param lw
= {
713 .recursive
= recursive
,
714 .callback
= callback
,
723 /* Handle function declaration line */
724 fname
= dwarf_decl_file(sp_die
);
725 if (fname
&& dwarf_decl_line(sp_die
, &lineno
) == 0 &&
726 dwarf_entrypc(sp_die
, &addr
) == 0) {
727 lw
.retval
= callback(fname
, lineno
, addr
, data
);
731 die_find_child(sp_die
, __die_walk_funclines_cb
, &lw
, &die_mem
);
736 static int __die_walk_culines_cb(Dwarf_Die
*sp_die
, void *data
)
738 struct __line_walk_param
*lw
= data
;
740 lw
->retval
= __die_walk_funclines(sp_die
, true, lw
->callback
, lw
->data
);
742 return DWARF_CB_ABORT
;
748 * die_walk_lines - Walk on lines inside given DIE
749 * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
750 * @callback: callback routine
753 * Walk on all lines inside given @rt_die and call @callback on each line.
754 * If the @rt_die is a function, walk only on the lines inside the function,
755 * otherwise @rt_die must be a CU DIE.
756 * Note that this walks not only dwarf line list, but also function entries
757 * and inline call-site.
759 int die_walk_lines(Dwarf_Die
*rt_die
, line_walk_callback_t callback
, void *data
)
764 const char *fname
, *decf
= NULL
;
767 Dwarf_Die die_mem
, *cu_die
;
771 if (dwarf_tag(rt_die
) != DW_TAG_compile_unit
) {
772 cu_die
= dwarf_diecu(rt_die
, &die_mem
, NULL
, NULL
);
773 dwarf_decl_line(rt_die
, &decl
);
774 decf
= dwarf_decl_file(rt_die
);
778 pr_debug2("Failed to get CU from given DIE.\n");
782 /* Get lines list in the CU */
783 if (dwarf_getsrclines(cu_die
, &lines
, &nlines
) != 0) {
784 pr_debug2("Failed to get source lines on this CU.\n");
787 pr_debug2("Get %zd lines from this CU\n", nlines
);
789 /* Walk on the lines on lines list */
790 for (i
= 0; i
< nlines
; i
++) {
791 line
= dwarf_onesrcline(lines
, i
);
793 dwarf_lineno(line
, &lineno
) != 0 ||
794 dwarf_lineaddr(line
, &addr
) != 0) {
795 pr_debug2("Failed to get line info. "
796 "Possible error in debuginfo.\n");
799 /* Filter lines based on address */
800 if (rt_die
!= cu_die
) {
803 * The line is included in given function, and
804 * no inline block includes it.
806 if (!dwarf_haspc(rt_die
, addr
))
808 if (die_find_inlinefunc(rt_die
, addr
, &die_mem
)) {
809 dwarf_decl_line(&die_mem
, &inl
);
811 decf
!= dwarf_decl_file(&die_mem
))
815 /* Get source line */
816 fname
= dwarf_linesrc(line
, NULL
, NULL
);
818 ret
= callback(fname
, lineno
, addr
, data
);
824 * Dwarf lines doesn't include function declarations and inlined
825 * subroutines. We have to check functions list or given function.
827 if (rt_die
!= cu_die
)
829 * Don't need walk functions recursively, because nested
830 * inlined functions don't have lines of the specified DIE.
832 ret
= __die_walk_funclines(rt_die
, false, callback
, data
);
834 struct __line_walk_param param
= {
835 .callback
= callback
,
839 dwarf_getfuncs(cu_die
, __die_walk_culines_cb
, ¶m
, 0);
846 struct __find_variable_param
{
851 static int __die_find_variable_cb(Dwarf_Die
*die_mem
, void *data
)
853 struct __find_variable_param
*fvp
= data
;
854 Dwarf_Attribute attr
;
857 tag
= dwarf_tag(die_mem
);
858 if ((tag
== DW_TAG_formal_parameter
||
859 tag
== DW_TAG_variable
) &&
860 die_compare_name(die_mem
, fvp
->name
) &&
861 /* Does the DIE have location information or external instance? */
862 (dwarf_attr(die_mem
, DW_AT_external
, &attr
) ||
863 dwarf_attr(die_mem
, DW_AT_location
, &attr
)))
864 return DIE_FIND_CB_END
;
865 if (dwarf_haspc(die_mem
, fvp
->addr
))
866 return DIE_FIND_CB_CONTINUE
;
868 return DIE_FIND_CB_SIBLING
;
872 * die_find_variable_at - Find a given name variable at given address
873 * @sp_die: a function DIE
874 * @name: variable name
876 * @die_mem: a buffer for result DIE
878 * Find a variable DIE called @name at @addr in @sp_die.
880 Dwarf_Die
*die_find_variable_at(Dwarf_Die
*sp_die
, const char *name
,
881 Dwarf_Addr addr
, Dwarf_Die
*die_mem
)
883 struct __find_variable_param fvp
= { .name
= name
, .addr
= addr
};
885 return die_find_child(sp_die
, __die_find_variable_cb
, (void *)&fvp
,
889 static int __die_find_member_cb(Dwarf_Die
*die_mem
, void *data
)
891 const char *name
= data
;
893 if (dwarf_tag(die_mem
) == DW_TAG_member
) {
894 if (die_compare_name(die_mem
, name
))
895 return DIE_FIND_CB_END
;
896 else if (!dwarf_diename(die_mem
)) { /* Unnamed structure */
897 Dwarf_Die type_die
, tmp_die
;
898 if (die_get_type(die_mem
, &type_die
) &&
899 die_find_member(&type_die
, name
, &tmp_die
))
900 return DIE_FIND_CB_END
;
903 return DIE_FIND_CB_SIBLING
;
907 * die_find_member - Find a given name member in a data structure
908 * @st_die: a data structure type DIE
910 * @die_mem: a buffer for result DIE
912 * Find a member DIE called @name in @st_die.
914 Dwarf_Die
*die_find_member(Dwarf_Die
*st_die
, const char *name
,
917 return die_find_child(st_die
, __die_find_member_cb
, (void *)name
,
922 * die_get_typename - Get the name of given variable DIE
923 * @vr_die: a variable DIE
924 * @buf: a strbuf for result type name
926 * Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.
927 * and Return -ENOENT if failed to find type name.
928 * Note that the result will stores typedef name if possible, and stores
929 * "*(function_type)" if the type is a function pointer.
931 int die_get_typename(Dwarf_Die
*vr_die
, struct strbuf
*buf
)
935 const char *tmp
= "";
937 if (__die_get_real_type(vr_die
, &type
) == NULL
)
940 tag
= dwarf_tag(&type
);
941 if (tag
== DW_TAG_array_type
|| tag
== DW_TAG_pointer_type
)
943 else if (tag
== DW_TAG_subroutine_type
) {
944 /* Function pointer */
945 return strbuf_add(buf
, "(function_type)", 15);
947 if (!dwarf_diename(&type
))
949 if (tag
== DW_TAG_union_type
)
951 else if (tag
== DW_TAG_structure_type
)
953 else if (tag
== DW_TAG_enumeration_type
)
955 /* Write a base name */
956 return strbuf_addf(buf
, "%s%s", tmp
, dwarf_diename(&type
));
958 ret
= die_get_typename(&type
, buf
);
959 return ret
? ret
: strbuf_addstr(buf
, tmp
);
963 * die_get_varname - Get the name and type of given variable DIE
964 * @vr_die: a variable DIE
965 * @buf: a strbuf for type and variable name
967 * Get the name and type of @vr_die and stores it in @buf as "type\tname".
969 int die_get_varname(Dwarf_Die
*vr_die
, struct strbuf
*buf
)
973 ret
= die_get_typename(vr_die
, buf
);
975 pr_debug("Failed to get type, make it unknown.\n");
976 ret
= strbuf_add(buf
, " (unknown_type)", 14);
979 return ret
< 0 ? ret
: strbuf_addf(buf
, "\t%s", dwarf_diename(vr_die
));
982 #ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
984 * die_get_var_innermost_scope - Get innermost scope range of given variable DIE
985 * @sp_die: a subprogram DIE
986 * @vr_die: a variable DIE
987 * @buf: a strbuf for variable byte offset range
989 * Get the innermost scope range of @vr_die and stores it in @buf as
990 * "@<function_name+[NN-NN,NN-NN]>".
992 static int die_get_var_innermost_scope(Dwarf_Die
*sp_die
, Dwarf_Die
*vr_die
,
999 Dwarf_Addr start
, end
;
1005 ret
= dwarf_entrypc(sp_die
, &entry
);
1009 name
= dwarf_diename(sp_die
);
1013 count
= dwarf_getscopes_die(vr_die
, &scopes
);
1015 /* (*SCOPES)[1] is the DIE for the scope containing that scope */
1021 while ((offset
= dwarf_ranges(&scopes
[1], offset
, &base
,
1022 &start
, &end
)) > 0) {
1027 ret
= strbuf_addf(buf
, "@<%s+[%" PRIu64
"-%" PRIu64
,
1031 ret
= strbuf_addf(buf
, ",%" PRIu64
"-%" PRIu64
,
1039 ret
= strbuf_add(buf
, "]>", 2);
1047 * die_get_var_range - Get byte offset range of given variable DIE
1048 * @sp_die: a subprogram DIE
1049 * @vr_die: a variable DIE
1050 * @buf: a strbuf for type and variable name and byte offset range
1052 * Get the byte offset range of @vr_die and stores it in @buf as
1053 * "@<function_name+[NN-NN,NN-NN]>".
1055 int die_get_var_range(Dwarf_Die
*sp_die
, Dwarf_Die
*vr_die
, struct strbuf
*buf
)
1059 Dwarf_Addr start
, end
;
1064 Dwarf_Attribute attr
;
1068 ret
= dwarf_entrypc(sp_die
, &entry
);
1072 name
= dwarf_diename(sp_die
);
1076 if (dwarf_attr(vr_die
, DW_AT_location
, &attr
) == NULL
)
1079 while ((offset
= dwarf_getlocations(&attr
, offset
, &base
,
1080 &start
, &end
, &op
, &nops
)) > 0) {
1082 /* Single Location Descriptions */
1083 ret
= die_get_var_innermost_scope(sp_die
, vr_die
, buf
);
1087 /* Location Lists */
1091 ret
= strbuf_addf(buf
, "@<%s+[%" PRIu64
"-%" PRIu64
,
1095 ret
= strbuf_addf(buf
, ",%" PRIu64
"-%" PRIu64
,
1103 ret
= strbuf_add(buf
, "]>", 2);
1108 int die_get_var_range(Dwarf_Die
*sp_die __maybe_unused
,
1109 Dwarf_Die
*vr_die __maybe_unused
,
1110 struct strbuf
*buf __maybe_unused
)
1117 * die_has_loclist - Check if DW_AT_location of @vr_die is a location list
1118 * @vr_die: a variable DIE
1120 static bool die_has_loclist(Dwarf_Die
*vr_die
)
1122 Dwarf_Attribute loc
;
1123 int tag
= dwarf_tag(vr_die
);
1125 if (tag
!= DW_TAG_formal_parameter
&&
1126 tag
!= DW_TAG_variable
)
1129 return (dwarf_attr_integrate(vr_die
, DW_AT_location
, &loc
) &&
1130 dwarf_whatform(&loc
) == DW_FORM_sec_offset
);
1134 * die_is_optimized_target - Check if target program is compiled with
1138 * For any object in given CU whose DW_AT_location is a location list,
1139 * target program is compiled with optimization. This is applicable to
1142 bool die_is_optimized_target(Dwarf_Die
*cu_die
)
1146 if (die_has_loclist(cu_die
))
1149 if (!dwarf_child(cu_die
, &tmp_die
) &&
1150 die_is_optimized_target(&tmp_die
))
1153 if (!dwarf_siblingof(cu_die
, &tmp_die
) &&
1154 die_is_optimized_target(&tmp_die
))
1161 * die_search_idx - Search index of given line address
1162 * @lines: Line records of single CU
1163 * @nr_lines: Number of @lines
1164 * @addr: address we are looking for
1165 * @idx: index to be set by this function (return value)
1167 * Search for @addr by looping over every lines of CU. If address
1168 * matches, set index of that line in @idx. Note that single source
1169 * line can have multiple line records. i.e. single source line can
1170 * have multiple index.
1172 static bool die_search_idx(Dwarf_Lines
*lines
, unsigned long nr_lines
,
1173 Dwarf_Addr addr
, unsigned long *idx
)
1178 for (i
= 0; i
< nr_lines
; i
++) {
1179 if (dwarf_lineaddr(dwarf_onesrcline(lines
, i
), &tmp
))
1191 * die_get_postprologue_addr - Search next address after function prologue
1192 * @entrypc_idx: entrypc index
1193 * @lines: Line records of single CU
1194 * @nr_lines: Number of @lines
1195 * @hignpc: high PC address of function
1196 * @postprologue_addr: Next address after function prologue (return value)
1198 * Look for prologue-end marker. If there is no explicit marker, return
1199 * address of next line record or next source line.
1201 static bool die_get_postprologue_addr(unsigned long entrypc_idx
,
1203 unsigned long nr_lines
,
1205 Dwarf_Addr
*postprologue_addr
)
1208 int entrypc_lno
, lno
;
1213 /* entrypc_lno is actual source line number */
1214 line
= dwarf_onesrcline(lines
, entrypc_idx
);
1215 if (dwarf_lineno(line
, &entrypc_lno
))
1218 for (i
= entrypc_idx
; i
< nr_lines
; i
++) {
1219 line
= dwarf_onesrcline(lines
, i
);
1221 if (dwarf_lineaddr(line
, &addr
) ||
1222 dwarf_lineno(line
, &lno
) ||
1223 dwarf_lineprologueend(line
, &p_end
))
1226 /* highpc is exclusive. [entrypc,highpc) */
1230 /* clang supports prologue-end marker */
1234 /* Actual next line in source */
1235 if (lno
!= entrypc_lno
)
1239 * Single source line can have multiple line records.
1241 * void foo() { printf("hello\n"); }
1242 * contains two line records. One points to declaration and
1243 * other points to printf() line. Variable 'lno' won't get
1244 * incremented in this case but 'i' will.
1246 if (i
!= entrypc_idx
)
1250 dwarf_lineaddr(line
, postprologue_addr
);
1251 if (*postprologue_addr
>= highpc
)
1252 dwarf_lineaddr(dwarf_onesrcline(lines
, i
- 1),
1259 * die_skip_prologue - Use next address after prologue as probe location
1260 * @sp_die: a subprogram DIE
1262 * @entrypc: entrypc of the function
1264 * Function prologue prepares stack and registers before executing function
1265 * logic. When target program is compiled without optimization, function
1266 * parameter information is only valid after prologue. When we probe entrypc
1267 * of the function, and try to record function parameter, it contains
1270 void die_skip_prologue(Dwarf_Die
*sp_die
, Dwarf_Die
*cu_die
,
1271 Dwarf_Addr
*entrypc
)
1273 size_t nr_lines
= 0;
1274 unsigned long entrypc_idx
= 0;
1275 Dwarf_Lines
*lines
= NULL
;
1276 Dwarf_Addr postprologue_addr
;
1279 if (dwarf_highpc(sp_die
, &highpc
))
1282 if (dwarf_getsrclines(cu_die
, &lines
, &nr_lines
))
1285 if (!die_search_idx(lines
, nr_lines
, *entrypc
, &entrypc_idx
))
1288 if (!die_get_postprologue_addr(entrypc_idx
, lines
, nr_lines
,
1289 highpc
, &postprologue_addr
))
1292 *entrypc
= postprologue_addr
;