~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/dwarf-aux.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * dwarf-aux.c : libdw auxiliary interfaces
  4  */
  5 
  6 #include <errno.h>
  7 #include <inttypes.h>
  8 #include <stdbool.h>
  9 #include <stdlib.h>
 10 #include "debug.h"
 11 #include "dwarf-aux.h"
 12 #include "string2.h"
 13 
 14 /**
 15  * cu_find_realpath - Find the realpath of the target file
 16  * @cu_die: A DIE(dwarf information entry) of CU(compilation Unit)
 17  * @fname:  The tail filename of the target file
 18  *
 19  * Find the real(long) path of @fname in @cu_die.
 20  */
 21 const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
 22 {
 23         Dwarf_Files *files;
 24         size_t nfiles, i;
 25         const char *src = NULL;
 26         int ret;
 27 
 28         if (!fname)
 29                 return NULL;
 30 
 31         ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
 32         if (ret != 0)
 33                 return NULL;
 34 
 35         for (i = 0; i < nfiles; i++) {
 36                 src = dwarf_filesrc(files, i, NULL, NULL);
 37                 if (strtailcmp(src, fname) == 0)
 38                         break;
 39         }
 40         if (i == nfiles)
 41                 return NULL;
 42         return src;
 43 }
 44 
 45 /**
 46  * cu_get_comp_dir - Get the path of compilation directory
 47  * @cu_die: a CU DIE
 48  *
 49  * Get the path of compilation directory of given @cu_die.
 50  * Since this depends on DW_AT_comp_dir, older gcc will not
 51  * embedded it. In that case, this returns NULL.
 52  */
 53 const char *cu_get_comp_dir(Dwarf_Die *cu_die)
 54 {
 55         Dwarf_Attribute attr;
 56         if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
 57                 return NULL;
 58         return dwarf_formstring(&attr);
 59 }
 60 
 61 /**
 62  * cu_find_lineinfo - Get a line number and file name for given address
 63  * @cu_die: a CU DIE
 64  * @addr: An address
 65  * @fname: a pointer which returns the file name string
 66  * @lineno: a pointer which returns the line number
 67  *
 68  * Find a line number and file name for @addr in @cu_die.
 69  */
 70 int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
 71                     const char **fname, int *lineno)
 72 {
 73         Dwarf_Line *line;
 74         Dwarf_Addr laddr;
 75 
 76         line = dwarf_getsrc_die(cu_die, (Dwarf_Addr)addr);
 77         if (line && dwarf_lineaddr(line, &laddr) == 0 &&
 78             addr == (unsigned long)laddr && dwarf_lineno(line, lineno) == 0) {
 79                 *fname = dwarf_linesrc(line, NULL, NULL);
 80                 if (!*fname)
 81                         /* line number is useless without filename */
 82                         *lineno = 0;
 83         }
 84 
 85         return *lineno ?: -ENOENT;
 86 }
 87 
 88 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
 89 
 90 /**
 91  * cu_walk_functions_at - Walk on function DIEs at given address
 92  * @cu_die: A CU DIE
 93  * @addr: An address
 94  * @callback: A callback which called with found DIEs
 95  * @data: A user data
 96  *
 97  * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
 98  * should be subprogram or inlined-subroutines.
 99  */
100 int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
101                     int (*callback)(Dwarf_Die *, void *), void *data)
102 {
103         Dwarf_Die die_mem;
104         Dwarf_Die *sc_die;
105         int ret = -ENOENT;
106 
107         /* Inlined function could be recursive. Trace it until fail */
108         for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
109              sc_die != NULL;
110              sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
111                                      &die_mem)) {
112                 ret = callback(sc_die, data);
113                 if (ret)
114                         break;
115         }
116 
117         return ret;
118 
119 }
120 
121 /**
122  * die_get_linkage_name - Get the linkage name of the object
123  * @dw_die: A DIE of the object
124  *
125  * Get the linkage name attiribute of given @dw_die.
126  * For C++ binary, the linkage name will be the mangled symbol.
127  */
128 const char *die_get_linkage_name(Dwarf_Die *dw_die)
129 {
130         Dwarf_Attribute attr;
131 
132         if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL)
133                 return NULL;
134         return dwarf_formstring(&attr);
135 }
136 
137 /**
138  * die_compare_name - Compare diename and tname
139  * @dw_die: a DIE
140  * @tname: a string of target name
141  *
142  * Compare the name of @dw_die and @tname. Return false if @dw_die has no name.
143  */
144 bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
145 {
146         const char *name;
147 
148         name = dwarf_diename(dw_die);
149         return name ? (strcmp(tname, name) == 0) : false;
150 }
151 
152 /**
153  * die_match_name - Match diename/linkage name and glob
154  * @dw_die: a DIE
155  * @glob: a string of target glob pattern
156  *
157  * Glob matching the name of @dw_die and @glob. Return false if matching fail.
158  * This also match linkage name.
159  */
160 bool die_match_name(Dwarf_Die *dw_die, const char *glob)
161 {
162         const char *name;
163 
164         name = dwarf_diename(dw_die);
165         if (name && strglobmatch(name, glob))
166                 return true;
167         /* fall back to check linkage name */
168         name = die_get_linkage_name(dw_die);
169         if (name && strglobmatch(name, glob))
170                 return true;
171 
172         return false;
173 }
174 
175 /**
176  * die_get_call_lineno - Get callsite line number of inline-function instance
177  * @in_die: a DIE of an inlined function instance
178  *
179  * Get call-site line number of @in_die. This means from where the inline
180  * function is called.
181  */
182 int die_get_call_lineno(Dwarf_Die *in_die)
183 {
184         Dwarf_Attribute attr;
185         Dwarf_Word ret;
186 
187         if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
188                 return -ENOENT;
189 
190         dwarf_formudata(&attr, &ret);
191         return (int)ret;
192 }
193 
194 /**
195  * die_get_type - Get type DIE
196  * @vr_die: a DIE of a variable
197  * @die_mem: where to store a type DIE
198  *
199  * Get a DIE of the type of given variable (@vr_die), and store
200  * it to die_mem. Return NULL if fails to get a type DIE.
201  */
202 Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
203 {
204         Dwarf_Attribute attr;
205 
206         if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
207             dwarf_formref_die(&attr, die_mem))
208                 return die_mem;
209         else
210                 return NULL;
211 }
212 
213 /* Get a type die, but skip qualifiers */
214 static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
215 {
216         int tag;
217 
218         do {
219                 vr_die = die_get_type(vr_die, die_mem);
220                 if (!vr_die)
221                         break;
222                 tag = dwarf_tag(vr_die);
223         } while (tag == DW_TAG_const_type ||
224                  tag == DW_TAG_restrict_type ||
225                  tag == DW_TAG_volatile_type ||
226                  tag == DW_TAG_shared_type);
227 
228         return vr_die;
229 }
230 
231 /**
232  * die_get_real_type - Get a type die, but skip qualifiers and typedef
233  * @vr_die: a DIE of a variable
234  * @die_mem: where to store a type DIE
235  *
236  * Get a DIE of the type of given variable (@vr_die), and store
237  * it to die_mem. Return NULL if fails to get a type DIE.
238  * If the type is qualifiers (e.g. const) or typedef, this skips it
239  * and tries to find real type (structure or basic types, e.g. int).
240  */
241 Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
242 {
243         do {
244                 vr_die = __die_get_real_type(vr_die, die_mem);
245         } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
246 
247         return vr_die;
248 }
249 
250 /* Get attribute and translate it as a udata */
251 static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
252                               Dwarf_Word *result)
253 {
254         Dwarf_Attribute attr;
255 
256         if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
257             dwarf_formudata(&attr, result) != 0)
258                 return -ENOENT;
259 
260         return 0;
261 }
262 
263 /* Get attribute and translate it as a sdata */
264 static int die_get_attr_sdata(Dwarf_Die *tp_die, unsigned int attr_name,
265                               Dwarf_Sword *result)
266 {
267         Dwarf_Attribute attr;
268 
269         if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
270             dwarf_formsdata(&attr, result) != 0)
271                 return -ENOENT;
272 
273         return 0;
274 }
275 
276 /**
277  * die_is_signed_type - Check whether a type DIE is signed or not
278  * @tp_die: a DIE of a type
279  *
280  * Get the encoding of @tp_die and return true if the encoding
281  * is signed.
282  */
283 bool die_is_signed_type(Dwarf_Die *tp_die)
284 {
285         Dwarf_Word ret;
286 
287         if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret))
288                 return false;
289 
290         return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
291                 ret == DW_ATE_signed_fixed);
292 }
293 
294 /**
295  * die_is_func_def - Ensure that this DIE is a subprogram and definition
296  * @dw_die: a DIE
297  *
298  * Ensure that this DIE is a subprogram and NOT a declaration. This
299  * returns true if @dw_die is a function definition.
300  **/
301 bool die_is_func_def(Dwarf_Die *dw_die)
302 {
303         Dwarf_Attribute attr;
304 
305         return (dwarf_tag(dw_die) == DW_TAG_subprogram &&
306                 dwarf_attr(dw_die, DW_AT_declaration, &attr) == NULL);
307 }
308 
309 /**
310  * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
311  * @dw_die: a DIE
312  *
313  * Ensure that this DIE is an instance (which has an entry address).
314  * This returns true if @dw_die is a function instance. If not, you need to
315  * call die_walk_instances() to find actual instances.
316  **/
317 bool die_is_func_instance(Dwarf_Die *dw_die)
318 {
319         Dwarf_Addr tmp;
320 
321         /* Actually gcc optimizes non-inline as like as inlined */
322         return !dwarf_func_inline(dw_die) && dwarf_entrypc(dw_die, &tmp) == 0;
323 }
324 /**
325  * die_get_data_member_location - Get the data-member offset
326  * @mb_die: a DIE of a member of a data structure
327  * @offs: The offset of the member in the data structure
328  *
329  * Get the offset of @mb_die in the data structure including @mb_die, and
330  * stores result offset to @offs. If any error occurs this returns errno.
331  */
332 int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
333 {
334         Dwarf_Attribute attr;
335         Dwarf_Op *expr;
336         size_t nexpr;
337         int ret;
338 
339         if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
340                 return -ENOENT;
341 
342         if (dwarf_formudata(&attr, offs) != 0) {
343                 /* DW_AT_data_member_location should be DW_OP_plus_uconst */
344                 ret = dwarf_getlocation(&attr, &expr, &nexpr);
345                 if (ret < 0 || nexpr == 0)
346                         return -ENOENT;
347 
348                 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
349                         pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
350                                  expr[0].atom, nexpr);
351                         return -ENOTSUP;
352                 }
353                 *offs = (Dwarf_Word)expr[0].number;
354         }
355         return 0;
356 }
357 
358 /* Get the call file index number in CU DIE */
359 static int die_get_call_fileno(Dwarf_Die *in_die)
360 {
361         Dwarf_Sword idx;
362 
363         if (die_get_attr_sdata(in_die, DW_AT_call_file, &idx) == 0)
364                 return (int)idx;
365         else
366                 return -ENOENT;
367 }
368 
369 /* Get the declared file index number in CU DIE */
370 static int die_get_decl_fileno(Dwarf_Die *pdie)
371 {
372         Dwarf_Sword idx;
373 
374         if (die_get_attr_sdata(pdie, DW_AT_decl_file, &idx) == 0)
375                 return (int)idx;
376         else
377                 return -ENOENT;
378 }
379 
380 /**
381  * die_get_call_file - Get callsite file name of inlined function instance
382  * @in_die: a DIE of an inlined function instance
383  *
384  * Get call-site file name of @in_die. This means from which file the inline
385  * function is called.
386  */
387 const char *die_get_call_file(Dwarf_Die *in_die)
388 {
389         Dwarf_Die cu_die;
390         Dwarf_Files *files;
391         int idx;
392 
393         idx = die_get_call_fileno(in_die);
394         if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) ||
395             dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
396                 return NULL;
397 
398         return dwarf_filesrc(files, idx, NULL, NULL);
399 }
400 
401 
402 /**
403  * die_find_child - Generic DIE search function in DIE tree
404  * @rt_die: a root DIE
405  * @callback: a callback function
406  * @data: a user data passed to the callback function
407  * @die_mem: a buffer for result DIE
408  *
409  * Trace DIE tree from @rt_die and call @callback for each child DIE.
410  * If @callback returns DIE_FIND_CB_END, this stores the DIE into
411  * @die_mem and returns it. If @callback returns DIE_FIND_CB_CONTINUE,
412  * this continues to trace the tree. Optionally, @callback can return
413  * DIE_FIND_CB_CHILD and DIE_FIND_CB_SIBLING, those means trace only
414  * the children and trace only the siblings respectively.
415  * Returns NULL if @callback can't find any appropriate DIE.
416  */
417 Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
418                           int (*callback)(Dwarf_Die *, void *),
419                           void *data, Dwarf_Die *die_mem)
420 {
421         Dwarf_Die child_die;
422         int ret;
423 
424         ret = dwarf_child(rt_die, die_mem);
425         if (ret != 0)
426                 return NULL;
427 
428         do {
429                 ret = callback(die_mem, data);
430                 if (ret == DIE_FIND_CB_END)
431                         return die_mem;
432 
433                 if ((ret & DIE_FIND_CB_CHILD) &&
434                     die_find_child(die_mem, callback, data, &child_die)) {
435                         memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
436                         return die_mem;
437                 }
438         } while ((ret & DIE_FIND_CB_SIBLING) &&
439                  dwarf_siblingof(die_mem, die_mem) == 0);
440 
441         return NULL;
442 }
443 
444 struct __addr_die_search_param {
445         Dwarf_Addr      addr;
446         Dwarf_Die       *die_mem;
447 };
448 
449 static int __die_search_func_tail_cb(Dwarf_Die *fn_die, void *data)
450 {
451         struct __addr_die_search_param *ad = data;
452         Dwarf_Addr addr = 0;
453 
454         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
455             !dwarf_highpc(fn_die, &addr) &&
456             addr == ad->addr) {
457                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
458                 return DWARF_CB_ABORT;
459         }
460         return DWARF_CB_OK;
461 }
462 
463 /**
464  * die_find_tailfunc - Search for a non-inlined function with tail call at
465  * given address
466  * @cu_die: a CU DIE which including @addr
467  * @addr: target address
468  * @die_mem: a buffer for result DIE
469  *
470  * Search for a non-inlined function DIE with tail call at @addr. Stores the
471  * DIE to @die_mem and returns it if found. Returns NULL if failed.
472  */
473 Dwarf_Die *die_find_tailfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
474                                     Dwarf_Die *die_mem)
475 {
476         struct __addr_die_search_param ad;
477         ad.addr = addr;
478         ad.die_mem = die_mem;
479         /* dwarf_getscopes can't find subprogram. */
480         if (!dwarf_getfuncs(cu_die, __die_search_func_tail_cb, &ad, 0))
481                 return NULL;
482         else
483                 return die_mem;
484 }
485 
486 /* die_find callback for non-inlined function search */
487 static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
488 {
489         struct __addr_die_search_param *ad = data;
490 
491         /*
492          * Since a declaration entry doesn't has given pc, this always returns
493          * function definition entry.
494          */
495         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
496             dwarf_haspc(fn_die, ad->addr)) {
497                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
498                 return DWARF_CB_ABORT;
499         }
500         return DWARF_CB_OK;
501 }
502 
503 /**
504  * die_find_realfunc - Search a non-inlined function at given address
505  * @cu_die: a CU DIE which including @addr
506  * @addr: target address
507  * @die_mem: a buffer for result DIE
508  *
509  * Search a non-inlined function DIE which includes @addr. Stores the
510  * DIE to @die_mem and returns it if found. Returns NULL if failed.
511  */
512 Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
513                                     Dwarf_Die *die_mem)
514 {
515         struct __addr_die_search_param ad;
516         ad.addr = addr;
517         ad.die_mem = die_mem;
518         /* dwarf_getscopes can't find subprogram. */
519         if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
520                 return NULL;
521         else
522                 return die_mem;
523 }
524 
525 /* die_find callback for inline function search */
526 static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
527 {
528         Dwarf_Addr *addr = data;
529 
530         if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
531             dwarf_haspc(die_mem, *addr))
532                 return DIE_FIND_CB_END;
533 
534         return DIE_FIND_CB_CONTINUE;
535 }
536 
537 /**
538  * die_find_top_inlinefunc - Search the top inlined function at given address
539  * @sp_die: a subprogram DIE which including @addr
540  * @addr: target address
541  * @die_mem: a buffer for result DIE
542  *
543  * Search an inlined function DIE which includes @addr. Stores the
544  * DIE to @die_mem and returns it if found. Returns NULL if failed.
545  * Even if several inlined functions are expanded recursively, this
546  * doesn't trace it down, and returns the topmost one.
547  */
548 Dwarf_Die *die_find_top_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
549                                    Dwarf_Die *die_mem)
550 {
551         return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
552 }
553 
554 /**
555  * die_find_inlinefunc - Search an inlined function at given address
556  * @sp_die: a subprogram DIE which including @addr
557  * @addr: target address
558  * @die_mem: a buffer for result DIE
559  *
560  * Search an inlined function DIE which includes @addr. Stores the
561  * DIE to @die_mem and returns it if found. Returns NULL if failed.
562  * If several inlined functions are expanded recursively, this trace
563  * it down and returns deepest one.
564  */
565 Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
566                                Dwarf_Die *die_mem)
567 {
568         Dwarf_Die tmp_die;
569 
570         sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, &tmp_die);
571         if (!sp_die)
572                 return NULL;
573 
574         /* Inlined function could be recursive. Trace it until fail */
575         while (sp_die) {
576                 memcpy(die_mem, sp_die, sizeof(Dwarf_Die));
577                 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr,
578                                         &tmp_die);
579         }
580 
581         return die_mem;
582 }
583 
584 struct __instance_walk_param {
585         void    *addr;
586         int     (*callback)(Dwarf_Die *, void *);
587         void    *data;
588         int     retval;
589 };
590 
591 static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
592 {
593         struct __instance_walk_param *iwp = data;
594         Dwarf_Attribute attr_mem;
595         Dwarf_Die origin_mem;
596         Dwarf_Attribute *attr;
597         Dwarf_Die *origin;
598         int tmp;
599 
600         attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
601         if (attr == NULL)
602                 return DIE_FIND_CB_CONTINUE;
603 
604         origin = dwarf_formref_die(attr, &origin_mem);
605         if (origin == NULL || origin->addr != iwp->addr)
606                 return DIE_FIND_CB_CONTINUE;
607 
608         /* Ignore redundant instances */
609         if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
610                 dwarf_decl_line(origin, &tmp);
611                 if (die_get_call_lineno(inst) == tmp) {
612                         tmp = die_get_decl_fileno(origin);
613                         if (die_get_call_fileno(inst) == tmp)
614                                 return DIE_FIND_CB_CONTINUE;
615                 }
616         }
617 
618         iwp->retval = iwp->callback(inst, iwp->data);
619 
620         return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
621 }
622 
623 /**
624  * die_walk_instances - Walk on instances of given DIE
625  * @or_die: an abstract original DIE
626  * @callback: a callback function which is called with instance DIE
627  * @data: user data
628  *
629  * Walk on the instances of give @in_die. @in_die must be an inlined function
630  * declartion. This returns the return value of @callback if it returns
631  * non-zero value, or -ENOENT if there is no instance.
632  */
633 int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
634                        void *data)
635 {
636         Dwarf_Die cu_die;
637         Dwarf_Die die_mem;
638         struct __instance_walk_param iwp = {
639                 .addr = or_die->addr,
640                 .callback = callback,
641                 .data = data,
642                 .retval = -ENOENT,
643         };
644 
645         if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
646                 return -ENOENT;
647 
648         die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
649 
650         return iwp.retval;
651 }
652 
653 /* Line walker internal parameters */
654 struct __line_walk_param {
655         bool recursive;
656         line_walk_callback_t callback;
657         void *data;
658         int retval;
659 };
660 
661 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
662 {
663         struct __line_walk_param *lw = data;
664         Dwarf_Addr addr = 0;
665         const char *fname;
666         int lineno;
667 
668         if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
669                 fname = die_get_call_file(in_die);
670                 lineno = die_get_call_lineno(in_die);
671                 if (fname && lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
672                         lw->retval = lw->callback(fname, lineno, addr, lw->data);
673                         if (lw->retval != 0)
674                                 return DIE_FIND_CB_END;
675                 }
676         }
677         if (!lw->recursive)
678                 /* Don't need to search recursively */
679                 return DIE_FIND_CB_SIBLING;
680 
681         if (addr) {
682                 fname = dwarf_decl_file(in_die);
683                 if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
684                         lw->retval = lw->callback(fname, lineno, addr, lw->data);
685                         if (lw->retval != 0)
686                                 return DIE_FIND_CB_END;
687                 }
688         }
689 
690         /* Continue to search nested inlined function call-sites */
691         return DIE_FIND_CB_CONTINUE;
692 }
693 
694 /* Walk on lines of blocks included in given DIE */
695 static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
696                                 line_walk_callback_t callback, void *data)
697 {
698         struct __line_walk_param lw = {
699                 .recursive = recursive,
700                 .callback = callback,
701                 .data = data,
702                 .retval = 0,
703         };
704         Dwarf_Die die_mem;
705         Dwarf_Addr addr;
706         const char *fname;
707         int lineno;
708 
709         /* Handle function declaration line */
710         fname = dwarf_decl_file(sp_die);
711         if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
712             dwarf_entrypc(sp_die, &addr) == 0) {
713                 lw.retval = callback(fname, lineno, addr, data);
714                 if (lw.retval != 0)
715                         goto done;
716         }
717         die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
718 done:
719         return lw.retval;
720 }
721 
722 static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
723 {
724         struct __line_walk_param *lw = data;
725 
726         lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
727         if (lw->retval != 0)
728                 return DWARF_CB_ABORT;
729 
730         return DWARF_CB_OK;
731 }
732 
733 /**
734  * die_walk_lines - Walk on lines inside given DIE
735  * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
736  * @callback: callback routine
737  * @data: user data
738  *
739  * Walk on all lines inside given @rt_die and call @callback on each line.
740  * If the @rt_die is a function, walk only on the lines inside the function,
741  * otherwise @rt_die must be a CU DIE.
742  * Note that this walks not only dwarf line list, but also function entries
743  * and inline call-site.
744  */
745 int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
746 {
747         Dwarf_Lines *lines;
748         Dwarf_Line *line;
749         Dwarf_Addr addr;
750         const char *fname, *decf = NULL;
751         int lineno, ret = 0;
752         int decl = 0, inl;
753         Dwarf_Die die_mem, *cu_die;
754         size_t nlines, i;
755 
756         /* Get the CU die */
757         if (dwarf_tag(rt_die) != DW_TAG_compile_unit) {
758                 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
759                 dwarf_decl_line(rt_die, &decl);
760                 decf = dwarf_decl_file(rt_die);
761         } else
762                 cu_die = rt_die;
763         if (!cu_die) {
764                 pr_debug2("Failed to get CU from given DIE.\n");
765                 return -EINVAL;
766         }
767 
768         /* Get lines list in the CU */
769         if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
770                 pr_debug2("Failed to get source lines on this CU.\n");
771                 return -ENOENT;
772         }
773         pr_debug2("Get %zd lines from this CU\n", nlines);
774 
775         /* Walk on the lines on lines list */
776         for (i = 0; i < nlines; i++) {
777                 line = dwarf_onesrcline(lines, i);
778                 if (line == NULL ||
779                     dwarf_lineno(line, &lineno) != 0 ||
780                     dwarf_lineaddr(line, &addr) != 0) {
781                         pr_debug2("Failed to get line info. "
782                                   "Possible error in debuginfo.\n");
783                         continue;
784                 }
785                 /* Filter lines based on address */
786                 if (rt_die != cu_die) {
787                         /*
788                          * Address filtering
789                          * The line is included in given function, and
790                          * no inline block includes it.
791                          */
792                         if (!dwarf_haspc(rt_die, addr))
793                                 continue;
794                         if (die_find_inlinefunc(rt_die, addr, &die_mem)) {
795                                 dwarf_decl_line(&die_mem, &inl);
796                                 if (inl != decl ||
797                                     decf != dwarf_decl_file(&die_mem))
798                                         continue;
799                         }
800                 }
801                 /* Get source line */
802                 fname = dwarf_linesrc(line, NULL, NULL);
803 
804                 ret = callback(fname, lineno, addr, data);
805                 if (ret != 0)
806                         return ret;
807         }
808 
809         /*
810          * Dwarf lines doesn't include function declarations and inlined
811          * subroutines. We have to check functions list or given function.
812          */
813         if (rt_die != cu_die)
814                 /*
815                  * Don't need walk functions recursively, because nested
816                  * inlined functions don't have lines of the specified DIE.
817                  */
818                 ret = __die_walk_funclines(rt_die, false, callback, data);
819         else {
820                 struct __line_walk_param param = {
821                         .callback = callback,
822                         .data = data,
823                         .retval = 0,
824                 };
825                 dwarf_getfuncs(cu_die, __die_walk_culines_cb, &param, 0);
826                 ret = param.retval;
827         }
828 
829         return ret;
830 }
831 
832 struct __find_variable_param {
833         const char *name;
834         Dwarf_Addr addr;
835 };
836 
837 static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
838 {
839         struct __find_variable_param *fvp = data;
840         Dwarf_Attribute attr;
841         int tag;
842 
843         tag = dwarf_tag(die_mem);
844         if ((tag == DW_TAG_formal_parameter ||
845              tag == DW_TAG_variable) &&
846             die_compare_name(die_mem, fvp->name) &&
847         /* Does the DIE have location information or external instance? */
848             (dwarf_attr(die_mem, DW_AT_external, &attr) ||
849              dwarf_attr(die_mem, DW_AT_location, &attr)))
850                 return DIE_FIND_CB_END;
851         if (dwarf_haspc(die_mem, fvp->addr))
852                 return DIE_FIND_CB_CONTINUE;
853         else
854                 return DIE_FIND_CB_SIBLING;
855 }
856 
857 /**
858  * die_find_variable_at - Find a given name variable at given address
859  * @sp_die: a function DIE
860  * @name: variable name
861  * @addr: address
862  * @die_mem: a buffer for result DIE
863  *
864  * Find a variable DIE called @name at @addr in @sp_die.
865  */
866 Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
867                                 Dwarf_Addr addr, Dwarf_Die *die_mem)
868 {
869         struct __find_variable_param fvp = { .name = name, .addr = addr};
870 
871         return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
872                               die_mem);
873 }
874 
875 static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
876 {
877         const char *name = data;
878 
879         if (dwarf_tag(die_mem) == DW_TAG_member) {
880                 if (die_compare_name(die_mem, name))
881                         return DIE_FIND_CB_END;
882                 else if (!dwarf_diename(die_mem)) {     /* Unnamed structure */
883                         Dwarf_Die type_die, tmp_die;
884                         if (die_get_type(die_mem, &type_die) &&
885                             die_find_member(&type_die, name, &tmp_die))
886                                 return DIE_FIND_CB_END;
887                 }
888         }
889         return DIE_FIND_CB_SIBLING;
890 }
891 
892 /**
893  * die_find_member - Find a given name member in a data structure
894  * @st_die: a data structure type DIE
895  * @name: member name
896  * @die_mem: a buffer for result DIE
897  *
898  * Find a member DIE called @name in @st_die.
899  */
900 Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
901                            Dwarf_Die *die_mem)
902 {
903         return die_find_child(st_die, __die_find_member_cb, (void *)name,
904                               die_mem);
905 }
906 
907 /**
908  * die_get_typename - Get the name of given variable DIE
909  * @vr_die: a variable DIE
910  * @buf: a strbuf for result type name
911  *
912  * Get the name of @vr_die and stores it to @buf. Return 0 if succeeded.
913  * and Return -ENOENT if failed to find type name.
914  * Note that the result will stores typedef name if possible, and stores
915  * "*(function_type)" if the type is a function pointer.
916  */
917 int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf)
918 {
919         Dwarf_Die type;
920         int tag, ret;
921         const char *tmp = "";
922 
923         if (__die_get_real_type(vr_die, &type) == NULL)
924                 return -ENOENT;
925 
926         tag = dwarf_tag(&type);
927         if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
928                 tmp = "*";
929         else if (tag == DW_TAG_subroutine_type) {
930                 /* Function pointer */
931                 return strbuf_add(buf, "(function_type)", 15);
932         } else {
933                 if (!dwarf_diename(&type))
934                         return -ENOENT;
935                 if (tag == DW_TAG_union_type)
936                         tmp = "union ";
937                 else if (tag == DW_TAG_structure_type)
938                         tmp = "struct ";
939                 else if (tag == DW_TAG_enumeration_type)
940                         tmp = "enum ";
941                 /* Write a base name */
942                 return strbuf_addf(buf, "%s%s", tmp, dwarf_diename(&type));
943         }
944         ret = die_get_typename(&type, buf);
945         return ret ? ret : strbuf_addstr(buf, tmp);
946 }
947 
948 /**
949  * die_get_varname - Get the name and type of given variable DIE
950  * @vr_die: a variable DIE
951  * @buf: a strbuf for type and variable name
952  *
953  * Get the name and type of @vr_die and stores it in @buf as "type\tname".
954  */
955 int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf)
956 {
957         int ret;
958 
959         ret = die_get_typename(vr_die, buf);
960         if (ret < 0) {
961                 pr_debug("Failed to get type, make it unknown.\n");
962                 ret = strbuf_add(buf, " (unknown_type)", 14);
963         }
964 
965         return ret < 0 ? ret : strbuf_addf(buf, "\t%s", dwarf_diename(vr_die));
966 }
967 
968 #ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
969 /**
970  * die_get_var_innermost_scope - Get innermost scope range of given variable DIE
971  * @sp_die: a subprogram DIE
972  * @vr_die: a variable DIE
973  * @buf: a strbuf for variable byte offset range
974  *
975  * Get the innermost scope range of @vr_die and stores it in @buf as
976  * "@<function_name+[NN-NN,NN-NN]>".
977  */
978 static int die_get_var_innermost_scope(Dwarf_Die *sp_die, Dwarf_Die *vr_die,
979                                 struct strbuf *buf)
980 {
981         Dwarf_Die *scopes;
982         int count;
983         size_t offset = 0;
984         Dwarf_Addr base;
985         Dwarf_Addr start, end;
986         Dwarf_Addr entry;
987         int ret;
988         bool first = true;
989         const char *name;
990 
991         ret = dwarf_entrypc(sp_die, &entry);
992         if (ret)
993                 return ret;
994 
995         name = dwarf_diename(sp_die);
996         if (!name)
997                 return -ENOENT;
998 
999         count = dwarf_getscopes_die(vr_die, &scopes);
1000 
1001         /* (*SCOPES)[1] is the DIE for the scope containing that scope */
1002         if (count <= 1) {
1003                 ret = -EINVAL;
1004                 goto out;
1005         }
1006 
1007         while ((offset = dwarf_ranges(&scopes[1], offset, &base,
1008                                         &start, &end)) > 0) {
1009                 start -= entry;
1010                 end -= entry;
1011 
1012                 if (first) {
1013                         ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1014                                           name, start, end);
1015                         first = false;
1016                 } else {
1017                         ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1018                                           start, end);
1019                 }
1020                 if (ret < 0)
1021                         goto out;
1022         }
1023 
1024         if (!first)
1025                 ret = strbuf_add(buf, "]>", 2);
1026 
1027 out:
1028         free(scopes);
1029         return ret;
1030 }
1031 
1032 /**
1033  * die_get_var_range - Get byte offset range of given variable DIE
1034  * @sp_die: a subprogram DIE
1035  * @vr_die: a variable DIE
1036  * @buf: a strbuf for type and variable name and byte offset range
1037  *
1038  * Get the byte offset range of @vr_die and stores it in @buf as
1039  * "@<function_name+[NN-NN,NN-NN]>".
1040  */
1041 int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf)
1042 {
1043         int ret = 0;
1044         Dwarf_Addr base;
1045         Dwarf_Addr start, end;
1046         Dwarf_Addr entry;
1047         Dwarf_Op *op;
1048         size_t nops;
1049         size_t offset = 0;
1050         Dwarf_Attribute attr;
1051         bool first = true;
1052         const char *name;
1053 
1054         ret = dwarf_entrypc(sp_die, &entry);
1055         if (ret)
1056                 return ret;
1057 
1058         name = dwarf_diename(sp_die);
1059         if (!name)
1060                 return -ENOENT;
1061 
1062         if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
1063                 return -EINVAL;
1064 
1065         while ((offset = dwarf_getlocations(&attr, offset, &base,
1066                                         &start, &end, &op, &nops)) > 0) {
1067                 if (start == 0) {
1068                         /* Single Location Descriptions */
1069                         ret = die_get_var_innermost_scope(sp_die, vr_die, buf);
1070                         goto out;
1071                 }
1072 
1073                 /* Location Lists */
1074                 start -= entry;
1075                 end -= entry;
1076                 if (first) {
1077                         ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1078                                           name, start, end);
1079                         first = false;
1080                 } else {
1081                         ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1082                                           start, end);
1083                 }
1084                 if (ret < 0)
1085                         goto out;
1086         }
1087 
1088         if (!first)
1089                 ret = strbuf_add(buf, "]>", 2);
1090 out:
1091         return ret;
1092 }
1093 #else
1094 int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,
1095                       Dwarf_Die *vr_die __maybe_unused,
1096                       struct strbuf *buf __maybe_unused)
1097 {
1098         return -ENOTSUP;
1099 }
1100 #endif
1101 
1102 /*
1103  * die_has_loclist - Check if DW_AT_location of @vr_die is a location list
1104  * @vr_die: a variable DIE
1105  */
1106 static bool die_has_loclist(Dwarf_Die *vr_die)
1107 {
1108         Dwarf_Attribute loc;
1109         int tag = dwarf_tag(vr_die);
1110 
1111         if (tag != DW_TAG_formal_parameter &&
1112             tag != DW_TAG_variable)
1113                 return false;
1114 
1115         return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) &&
1116                 dwarf_whatform(&loc) == DW_FORM_sec_offset);
1117 }
1118 
1119 /*
1120  * die_is_optimized_target - Check if target program is compiled with
1121  * optimization
1122  * @cu_die: a CU DIE
1123  *
1124  * For any object in given CU whose DW_AT_location is a location list,
1125  * target program is compiled with optimization. This is applicable to
1126  * clang as well.
1127  */
1128 bool die_is_optimized_target(Dwarf_Die *cu_die)
1129 {
1130         Dwarf_Die tmp_die;
1131 
1132         if (die_has_loclist(cu_die))
1133                 return true;
1134 
1135         if (!dwarf_child(cu_die, &tmp_die) &&
1136             die_is_optimized_target(&tmp_die))
1137                 return true;
1138 
1139         if (!dwarf_siblingof(cu_die, &tmp_die) &&
1140             die_is_optimized_target(&tmp_die))
1141                 return true;
1142 
1143         return false;
1144 }
1145 
1146 /*
1147  * die_search_idx - Search index of given line address
1148  * @lines: Line records of single CU
1149  * @nr_lines: Number of @lines
1150  * @addr: address we are looking for
1151  * @idx: index to be set by this function (return value)
1152  *
1153  * Search for @addr by looping over every lines of CU. If address
1154  * matches, set index of that line in @idx. Note that single source
1155  * line can have multiple line records. i.e. single source line can
1156  * have multiple index.
1157  */
1158 static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines,
1159                            Dwarf_Addr addr, unsigned long *idx)
1160 {
1161         unsigned long i;
1162         Dwarf_Addr tmp;
1163 
1164         for (i = 0; i < nr_lines; i++) {
1165                 if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp))
1166                         return false;
1167 
1168                 if (tmp == addr) {
1169                         *idx = i;
1170                         return true;
1171                 }
1172         }
1173         return false;
1174 }
1175 
1176 /*
1177  * die_get_postprologue_addr - Search next address after function prologue
1178  * @entrypc_idx: entrypc index
1179  * @lines: Line records of single CU
1180  * @nr_lines: Number of @lines
1181  * @hignpc: high PC address of function
1182  * @postprologue_addr: Next address after function prologue (return value)
1183  *
1184  * Look for prologue-end marker. If there is no explicit marker, return
1185  * address of next line record or next source line.
1186  */
1187 static bool die_get_postprologue_addr(unsigned long entrypc_idx,
1188                                       Dwarf_Lines *lines,
1189                                       unsigned long nr_lines,
1190                                       Dwarf_Addr highpc,
1191                                       Dwarf_Addr *postprologue_addr)
1192 {
1193         unsigned long i;
1194         int entrypc_lno, lno;
1195         Dwarf_Line *line;
1196         Dwarf_Addr addr;
1197         bool p_end;
1198 
1199         /* entrypc_lno is actual source line number */
1200         line = dwarf_onesrcline(lines, entrypc_idx);
1201         if (dwarf_lineno(line, &entrypc_lno))
1202                 return false;
1203 
1204         for (i = entrypc_idx; i < nr_lines; i++) {
1205                 line = dwarf_onesrcline(lines, i);
1206 
1207                 if (dwarf_lineaddr(line, &addr) ||
1208                     dwarf_lineno(line, &lno)    ||
1209                     dwarf_lineprologueend(line, &p_end))
1210                         return false;
1211 
1212                 /* highpc is exclusive. [entrypc,highpc) */
1213                 if (addr >= highpc)
1214                         break;
1215 
1216                 /* clang supports prologue-end marker */
1217                 if (p_end)
1218                         break;
1219 
1220                 /* Actual next line in source */
1221                 if (lno != entrypc_lno)
1222                         break;
1223 
1224                 /*
1225                  * Single source line can have multiple line records.
1226                  * For Example,
1227                  *     void foo() { printf("hello\n"); }
1228                  * contains two line records. One points to declaration and
1229                  * other points to printf() line. Variable 'lno' won't get
1230                  * incremented in this case but 'i' will.
1231                  */
1232                 if (i != entrypc_idx)
1233                         break;
1234         }
1235 
1236         dwarf_lineaddr(line, postprologue_addr);
1237         if (*postprologue_addr >= highpc)
1238                 dwarf_lineaddr(dwarf_onesrcline(lines, i - 1),
1239                                postprologue_addr);
1240 
1241         return true;
1242 }
1243 
1244 /*
1245  * die_skip_prologue - Use next address after prologue as probe location
1246  * @sp_die: a subprogram DIE
1247  * @cu_die: a CU DIE
1248  * @entrypc: entrypc of the function
1249  *
1250  * Function prologue prepares stack and registers before executing function
1251  * logic. When target program is compiled without optimization, function
1252  * parameter information is only valid after prologue. When we probe entrypc
1253  * of the function, and try to record function parameter, it contains
1254  * garbage value.
1255  */
1256 void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
1257                        Dwarf_Addr *entrypc)
1258 {
1259         size_t nr_lines = 0;
1260         unsigned long entrypc_idx = 0;
1261         Dwarf_Lines *lines = NULL;
1262         Dwarf_Addr postprologue_addr;
1263         Dwarf_Addr highpc;
1264 
1265         if (dwarf_highpc(sp_die, &highpc))
1266                 return;
1267 
1268         if (dwarf_getsrclines(cu_die, &lines, &nr_lines))
1269                 return;
1270 
1271         if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx))
1272                 return;
1273 
1274         if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines,
1275                                        highpc, &postprologue_addr))
1276                 return;
1277 
1278         *entrypc = postprologue_addr;
1279 }
1280 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp