1
2
3
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 "strbuf.h"
13#include "string2.h"
14
15
16
17
18
19
20
21
22const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
23{
24 Dwarf_Files *files;
25 size_t nfiles, i;
26 const char *src = NULL;
27 int ret;
28
29 if (!fname)
30 return NULL;
31
32 ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
33 if (ret != 0)
34 return NULL;
35
36 for (i = 0; i < nfiles; i++) {
37 src = dwarf_filesrc(files, i, NULL, NULL);
38 if (strtailcmp(src, fname) == 0)
39 break;
40 }
41 if (i == nfiles)
42 return NULL;
43 return src;
44}
45
46
47
48
49
50
51
52
53
54const char *cu_get_comp_dir(Dwarf_Die *cu_die)
55{
56 Dwarf_Attribute attr;
57 if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
58 return NULL;
59 return dwarf_formstring(&attr);
60}
61
62
63static Dwarf_Line *cu_getsrc_die(Dwarf_Die *cu_die, Dwarf_Addr addr)
64{
65 Dwarf_Addr laddr;
66 Dwarf_Lines *lines;
67 Dwarf_Line *line;
68 size_t nlines, l, u, n;
69 bool flag;
70
71 if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0 ||
72 nlines == 0)
73 return NULL;
74
75
76 l = 0; u = nlines - 1;
77 while (l < u) {
78 n = u - (u - l) / 2;
79 line = dwarf_onesrcline(lines, n);
80 if (!line || dwarf_lineaddr(line, &laddr) != 0)
81 return NULL;
82 if (addr < laddr)
83 u = n - 1;
84 else
85 l = n;
86 }
87
88 do {
89 line = dwarf_onesrcline(lines, --l);
90 if (!line || dwarf_lineaddr(line, &laddr) != 0)
91 return NULL;
92 } while (laddr == addr);
93 l++;
94
95 do {
96 line = dwarf_onesrcline(lines, l++);
97 if (!line || dwarf_lineaddr(line, &laddr) != 0 ||
98 dwarf_linebeginstatement(line, &flag) != 0)
99 return NULL;
100 if (laddr > addr)
101 return NULL;
102 } while (!flag);
103
104 return line;
105}
106
107
108
109
110
111
112
113
114
115
116int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
117 const char **fname, int *lineno)
118{
119 Dwarf_Line *line;
120 Dwarf_Die die_mem;
121 Dwarf_Addr faddr;
122
123 if (die_find_realfunc(cu_die, (Dwarf_Addr)addr, &die_mem)
124 && die_entrypc(&die_mem, &faddr) == 0 &&
125 faddr == addr) {
126 *fname = dwarf_decl_file(&die_mem);
127 dwarf_decl_line(&die_mem, lineno);
128 goto out;
129 }
130
131 line = cu_getsrc_die(cu_die, (Dwarf_Addr)addr);
132 if (line && dwarf_lineno(line, lineno) == 0) {
133 *fname = dwarf_linesrc(line, NULL, NULL);
134 if (!*fname)
135
136 *lineno = 0;
137 }
138
139out:
140 return *lineno ?: -ENOENT;
141}
142
143static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
144
145
146
147
148
149
150
151
152
153
154
155int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
156 int (*callback)(Dwarf_Die *, void *), void *data)
157{
158 Dwarf_Die die_mem;
159 Dwarf_Die *sc_die;
160 int ret = -ENOENT;
161
162
163 for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
164 sc_die != NULL;
165 sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
166 &die_mem)) {
167 ret = callback(sc_die, data);
168 if (ret)
169 break;
170 }
171
172 return ret;
173
174}
175
176
177
178
179
180
181
182
183const char *die_get_linkage_name(Dwarf_Die *dw_die)
184{
185 Dwarf_Attribute attr;
186
187 if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL)
188 return NULL;
189 return dwarf_formstring(&attr);
190}
191
192
193
194
195
196
197
198
199bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
200{
201 const char *name;
202
203 name = dwarf_diename(dw_die);
204 return name ? (strcmp(tname, name) == 0) : false;
205}
206
207
208
209
210
211
212
213
214
215bool die_match_name(Dwarf_Die *dw_die, const char *glob)
216{
217 const char *name;
218
219 name = dwarf_diename(dw_die);
220 if (name && strglobmatch(name, glob))
221 return true;
222
223 name = die_get_linkage_name(dw_die);
224 if (name && strglobmatch(name, glob))
225 return true;
226
227 return false;
228}
229
230
231
232
233
234
235
236
237int die_get_call_lineno(Dwarf_Die *in_die)
238{
239 Dwarf_Attribute attr;
240 Dwarf_Word ret;
241
242 if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
243 return -ENOENT;
244
245 dwarf_formudata(&attr, &ret);
246 return (int)ret;
247}
248
249
250
251
252
253
254
255
256
257Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
258{
259 Dwarf_Attribute attr;
260
261 if (dwarf_attr_integrate(vr_die, DW_AT_type, &attr) &&
262 dwarf_formref_die(&attr, die_mem))
263 return die_mem;
264 else
265 return NULL;
266}
267
268
269static Dwarf_Die *__die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
270{
271 int tag;
272
273 do {
274 vr_die = die_get_type(vr_die, die_mem);
275 if (!vr_die)
276 break;
277 tag = dwarf_tag(vr_die);
278 } while (tag == DW_TAG_const_type ||
279 tag == DW_TAG_restrict_type ||
280 tag == DW_TAG_volatile_type ||
281 tag == DW_TAG_shared_type);
282
283 return vr_die;
284}
285
286
287
288
289
290
291
292
293
294
295
296Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
297{
298 do {
299 vr_die = __die_get_real_type(vr_die, die_mem);
300 } while (vr_die && dwarf_tag(vr_die) == DW_TAG_typedef);
301
302 return vr_die;
303}
304
305
306static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
307 Dwarf_Word *result)
308{
309 Dwarf_Attribute attr;
310
311 if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
312 dwarf_formudata(&attr, result) != 0)
313 return -ENOENT;
314
315 return 0;
316}
317
318
319static int die_get_attr_sdata(Dwarf_Die *tp_die, unsigned int attr_name,
320 Dwarf_Sword *result)
321{
322 Dwarf_Attribute attr;
323
324 if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
325 dwarf_formsdata(&attr, result) != 0)
326 return -ENOENT;
327
328 return 0;
329}
330
331
332
333
334
335
336
337
338bool die_is_signed_type(Dwarf_Die *tp_die)
339{
340 Dwarf_Word ret;
341
342 if (die_get_attr_udata(tp_die, DW_AT_encoding, &ret))
343 return false;
344
345 return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
346 ret == DW_ATE_signed_fixed);
347}
348
349
350
351
352
353
354
355
356bool die_is_func_def(Dwarf_Die *dw_die)
357{
358 Dwarf_Attribute attr;
359
360 return (dwarf_tag(dw_die) == DW_TAG_subprogram &&
361 dwarf_attr(dw_die, DW_AT_declaration, &attr) == NULL);
362}
363
364
365
366
367
368
369
370
371
372
373int die_entrypc(Dwarf_Die *dw_die, Dwarf_Addr *addr)
374{
375 Dwarf_Addr base, end;
376
377 if (!addr)
378 return -EINVAL;
379
380 if (dwarf_entrypc(dw_die, addr) == 0)
381 return 0;
382
383 return dwarf_ranges(dw_die, 0, &base, addr, &end) < 0 ? -ENOENT : 0;
384}
385
386
387
388
389
390
391
392
393
394
395bool die_is_func_instance(Dwarf_Die *dw_die)
396{
397 Dwarf_Addr tmp;
398 Dwarf_Attribute attr_mem;
399 int tag = dwarf_tag(dw_die);
400
401 if (tag != DW_TAG_subprogram &&
402 tag != DW_TAG_inlined_subroutine)
403 return false;
404
405 return dwarf_entrypc(dw_die, &tmp) == 0 ||
406 dwarf_attr(dw_die, DW_AT_ranges, &attr_mem) != NULL;
407}
408
409
410
411
412
413
414
415
416
417int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
418{
419 Dwarf_Attribute attr;
420 Dwarf_Op *expr;
421 size_t nexpr;
422 int ret;
423
424 if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
425 return -ENOENT;
426
427 if (dwarf_formudata(&attr, offs) != 0) {
428
429 ret = dwarf_getlocation(&attr, &expr, &nexpr);
430 if (ret < 0 || nexpr == 0)
431 return -ENOENT;
432
433 if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
434 pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
435 expr[0].atom, nexpr);
436 return -ENOTSUP;
437 }
438 *offs = (Dwarf_Word)expr[0].number;
439 }
440 return 0;
441}
442
443
444static int die_get_call_fileno(Dwarf_Die *in_die)
445{
446 Dwarf_Sword idx;
447
448 if (die_get_attr_sdata(in_die, DW_AT_call_file, &idx) == 0)
449 return (int)idx;
450 else
451 return -ENOENT;
452}
453
454
455static int die_get_decl_fileno(Dwarf_Die *pdie)
456{
457 Dwarf_Sword idx;
458
459 if (die_get_attr_sdata(pdie, DW_AT_decl_file, &idx) == 0)
460 return (int)idx;
461 else
462 return -ENOENT;
463}
464
465
466
467
468
469
470
471
472const char *die_get_call_file(Dwarf_Die *in_die)
473{
474 Dwarf_Die cu_die;
475 Dwarf_Files *files;
476 int idx;
477
478 idx = die_get_call_fileno(in_die);
479 if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) ||
480 dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
481 return NULL;
482
483 return dwarf_filesrc(files, idx, NULL, NULL);
484}
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
503 int (*callback)(Dwarf_Die *, void *),
504 void *data, Dwarf_Die *die_mem)
505{
506 Dwarf_Die child_die;
507 int ret;
508
509 ret = dwarf_child(rt_die, die_mem);
510 if (ret != 0)
511 return NULL;
512
513 do {
514 ret = callback(die_mem, data);
515 if (ret == DIE_FIND_CB_END)
516 return die_mem;
517
518 if ((ret & DIE_FIND_CB_CHILD) &&
519 die_find_child(die_mem, callback, data, &child_die)) {
520 memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
521 return die_mem;
522 }
523 } while ((ret & DIE_FIND_CB_SIBLING) &&
524 dwarf_siblingof(die_mem, die_mem) == 0);
525
526 return NULL;
527}
528
529struct __addr_die_search_param {
530 Dwarf_Addr addr;
531 Dwarf_Die *die_mem;
532};
533
534static int __die_search_func_tail_cb(Dwarf_Die *fn_die, void *data)
535{
536 struct __addr_die_search_param *ad = data;
537 Dwarf_Addr addr = 0;
538
539 if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
540 !dwarf_highpc(fn_die, &addr) &&
541 addr == ad->addr) {
542 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
543 return DWARF_CB_ABORT;
544 }
545 return DWARF_CB_OK;
546}
547
548
549
550
551
552
553
554
555
556
557
558Dwarf_Die *die_find_tailfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
559 Dwarf_Die *die_mem)
560{
561 struct __addr_die_search_param ad;
562 ad.addr = addr;
563 ad.die_mem = die_mem;
564
565 if (!dwarf_getfuncs(cu_die, __die_search_func_tail_cb, &ad, 0))
566 return NULL;
567 else
568 return die_mem;
569}
570
571
572static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
573{
574 struct __addr_die_search_param *ad = data;
575
576
577
578
579
580 if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
581 dwarf_haspc(fn_die, ad->addr)) {
582 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
583 return DWARF_CB_ABORT;
584 }
585 return DWARF_CB_OK;
586}
587
588
589
590
591
592
593
594
595
596
597Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
598 Dwarf_Die *die_mem)
599{
600 struct __addr_die_search_param ad;
601 ad.addr = addr;
602 ad.die_mem = die_mem;
603
604 if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
605 return NULL;
606 else
607 return die_mem;
608}
609
610
611static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
612{
613 Dwarf_Addr *addr = data;
614
615 if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
616 dwarf_haspc(die_mem, *addr))
617 return DIE_FIND_CB_END;
618
619 return DIE_FIND_CB_CONTINUE;
620}
621
622
623
624
625
626
627
628
629
630
631
632
633Dwarf_Die *die_find_top_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
634 Dwarf_Die *die_mem)
635{
636 return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
637}
638
639
640
641
642
643
644
645
646
647
648
649
650Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
651 Dwarf_Die *die_mem)
652{
653 Dwarf_Die tmp_die;
654
655 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr, &tmp_die);
656 if (!sp_die)
657 return NULL;
658
659
660 while (sp_die) {
661 memcpy(die_mem, sp_die, sizeof(Dwarf_Die));
662 sp_die = die_find_child(sp_die, __die_find_inline_cb, &addr,
663 &tmp_die);
664 }
665
666 return die_mem;
667}
668
669struct __instance_walk_param {
670 void *addr;
671 int (*callback)(Dwarf_Die *, void *);
672 void *data;
673 int retval;
674};
675
676static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
677{
678 struct __instance_walk_param *iwp = data;
679 Dwarf_Attribute attr_mem;
680 Dwarf_Die origin_mem;
681 Dwarf_Attribute *attr;
682 Dwarf_Die *origin;
683 int tmp;
684
685 if (!die_is_func_instance(inst))
686 return DIE_FIND_CB_CONTINUE;
687
688 attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
689 if (attr == NULL)
690 return DIE_FIND_CB_CONTINUE;
691
692 origin = dwarf_formref_die(attr, &origin_mem);
693 if (origin == NULL || origin->addr != iwp->addr)
694 return DIE_FIND_CB_CONTINUE;
695
696
697 if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
698 dwarf_decl_line(origin, &tmp);
699 if (die_get_call_lineno(inst) == tmp) {
700 tmp = die_get_decl_fileno(origin);
701 if (die_get_call_fileno(inst) == tmp)
702 return DIE_FIND_CB_CONTINUE;
703 }
704 }
705
706 iwp->retval = iwp->callback(inst, iwp->data);
707
708 return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
709}
710
711
712
713
714
715
716
717
718
719
720
721int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
722 void *data)
723{
724 Dwarf_Die cu_die;
725 Dwarf_Die die_mem;
726 struct __instance_walk_param iwp = {
727 .addr = or_die->addr,
728 .callback = callback,
729 .data = data,
730 .retval = -ENOENT,
731 };
732
733 if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
734 return -ENOENT;
735
736 die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
737
738 return iwp.retval;
739}
740
741
742struct __line_walk_param {
743 bool recursive;
744 line_walk_callback_t callback;
745 void *data;
746 int retval;
747};
748
749static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
750{
751 struct __line_walk_param *lw = data;
752 Dwarf_Addr addr = 0;
753 const char *fname;
754 int lineno;
755
756 if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
757 fname = die_get_call_file(in_die);
758 lineno = die_get_call_lineno(in_die);
759 if (fname && lineno > 0 && die_entrypc(in_die, &addr) == 0) {
760 lw->retval = lw->callback(fname, lineno, addr, lw->data);
761 if (lw->retval != 0)
762 return DIE_FIND_CB_END;
763 }
764 if (!lw->recursive)
765 return DIE_FIND_CB_SIBLING;
766 }
767
768 if (addr) {
769 fname = dwarf_decl_file(in_die);
770 if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
771 lw->retval = lw->callback(fname, lineno, addr, lw->data);
772 if (lw->retval != 0)
773 return DIE_FIND_CB_END;
774 }
775 }
776
777
778 return DIE_FIND_CB_CONTINUE;
779}
780
781
782static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
783 line_walk_callback_t callback, void *data)
784{
785 struct __line_walk_param lw = {
786 .recursive = recursive,
787 .callback = callback,
788 .data = data,
789 .retval = 0,
790 };
791 Dwarf_Die die_mem;
792 Dwarf_Addr addr;
793 const char *fname;
794 int lineno;
795
796
797 fname = dwarf_decl_file(sp_die);
798 if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
799 die_entrypc(sp_die, &addr) == 0) {
800 lw.retval = callback(fname, lineno, addr, data);
801 if (lw.retval != 0)
802 goto done;
803 }
804 die_find_child(sp_die, __die_walk_funclines_cb, &lw, &die_mem);
805done:
806 return lw.retval;
807}
808
809static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
810{
811 struct __line_walk_param *lw = data;
812
813
814
815
816
817 lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
818 if (lw->retval != 0)
819 return DWARF_CB_ABORT;
820
821 return DWARF_CB_OK;
822}
823
824
825
826
827
828
829
830
831
832
833
834
835
836int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
837{
838 Dwarf_Lines *lines;
839 Dwarf_Line *line;
840 Dwarf_Addr addr;
841 const char *fname, *decf = NULL, *inf = NULL;
842 int lineno, ret = 0;
843 int decl = 0, inl;
844 Dwarf_Die die_mem, *cu_die;
845 size_t nlines, i;
846 bool flag;
847
848
849 if (dwarf_tag(rt_die) != DW_TAG_compile_unit) {
850 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
851 dwarf_decl_line(rt_die, &decl);
852 decf = dwarf_decl_file(rt_die);
853 } else
854 cu_die = rt_die;
855 if (!cu_die) {
856 pr_debug2("Failed to get CU from given DIE.\n");
857 return -EINVAL;
858 }
859
860
861 if (dwarf_getsrclines(cu_die, &lines, &nlines) != 0) {
862 pr_debug2("Failed to get source lines on this CU.\n");
863 return -ENOENT;
864 }
865 pr_debug2("Get %zd lines from this CU\n", nlines);
866
867
868 for (i = 0; i < nlines; i++) {
869 line = dwarf_onesrcline(lines, i);
870 if (line == NULL ||
871 dwarf_lineno(line, &lineno) != 0 ||
872 dwarf_lineaddr(line, &addr) != 0) {
873 pr_debug2("Failed to get line info. "
874 "Possible error in debuginfo.\n");
875 continue;
876 }
877
878 if (dwarf_lineendsequence(line, &flag) != 0 || flag)
879 continue;
880
881 if (dwarf_linebeginstatement(line, &flag) != 0 || !flag)
882 continue;
883
884 if (rt_die != cu_die) {
885
886
887
888
889
890 if (!dwarf_haspc(rt_die, addr))
891 continue;
892
893 if (die_find_inlinefunc(rt_die, addr, &die_mem)) {
894
895 inf = die_get_call_file(&die_mem);
896 if ((inf && !strcmp(inf, decf)) &&
897 die_get_call_lineno(&die_mem) == lineno)
898 goto found;
899
900 dwarf_decl_line(&die_mem, &inl);
901 if (inl != decl ||
902 decf != dwarf_decl_file(&die_mem))
903 continue;
904 }
905 }
906found:
907
908 fname = dwarf_linesrc(line, NULL, NULL);
909
910 ret = callback(fname, lineno, addr, data);
911 if (ret != 0)
912 return ret;
913 }
914
915
916
917
918
919 if (rt_die != cu_die)
920
921
922
923
924
925 ret = __die_walk_funclines(rt_die, false, callback, data);
926 else {
927 struct __line_walk_param param = {
928 .callback = callback,
929 .data = data,
930 .retval = 0,
931 };
932 dwarf_getfuncs(cu_die, __die_walk_culines_cb, ¶m, 0);
933 ret = param.retval;
934 }
935
936 return ret;
937}
938
939struct __find_variable_param {
940 const char *name;
941 Dwarf_Addr addr;
942};
943
944static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
945{
946 struct __find_variable_param *fvp = data;
947 Dwarf_Attribute attr;
948 int tag;
949
950 tag = dwarf_tag(die_mem);
951 if ((tag == DW_TAG_formal_parameter ||
952 tag == DW_TAG_variable) &&
953 die_compare_name(die_mem, fvp->name) &&
954
955 (dwarf_attr(die_mem, DW_AT_external, &attr) ||
956 dwarf_attr(die_mem, DW_AT_location, &attr)))
957 return DIE_FIND_CB_END;
958 if (dwarf_haspc(die_mem, fvp->addr))
959 return DIE_FIND_CB_CONTINUE;
960 else
961 return DIE_FIND_CB_SIBLING;
962}
963
964
965
966
967
968
969
970
971
972
973Dwarf_Die *die_find_variable_at(Dwarf_Die *sp_die, const char *name,
974 Dwarf_Addr addr, Dwarf_Die *die_mem)
975{
976 struct __find_variable_param fvp = { .name = name, .addr = addr};
977
978 return die_find_child(sp_die, __die_find_variable_cb, (void *)&fvp,
979 die_mem);
980}
981
982static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
983{
984 const char *name = data;
985
986 if (dwarf_tag(die_mem) == DW_TAG_member) {
987 if (die_compare_name(die_mem, name))
988 return DIE_FIND_CB_END;
989 else if (!dwarf_diename(die_mem)) {
990 Dwarf_Die type_die, tmp_die;
991 if (die_get_type(die_mem, &type_die) &&
992 die_find_member(&type_die, name, &tmp_die))
993 return DIE_FIND_CB_END;
994 }
995 }
996 return DIE_FIND_CB_SIBLING;
997}
998
999
1000
1001
1002
1003
1004
1005
1006
1007Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
1008 Dwarf_Die *die_mem)
1009{
1010 return die_find_child(st_die, __die_find_member_cb, (void *)name,
1011 die_mem);
1012}
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf)
1025{
1026 Dwarf_Die type;
1027 int tag, ret;
1028 const char *tmp = "";
1029
1030 if (__die_get_real_type(vr_die, &type) == NULL)
1031 return -ENOENT;
1032
1033 tag = dwarf_tag(&type);
1034 if (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)
1035 tmp = "*";
1036 else if (tag == DW_TAG_subroutine_type) {
1037
1038 return strbuf_add(buf, "(function_type)", 15);
1039 } else {
1040 if (!dwarf_diename(&type))
1041 return -ENOENT;
1042 if (tag == DW_TAG_union_type)
1043 tmp = "union ";
1044 else if (tag == DW_TAG_structure_type)
1045 tmp = "struct ";
1046 else if (tag == DW_TAG_enumeration_type)
1047 tmp = "enum ";
1048
1049 return strbuf_addf(buf, "%s%s", tmp, dwarf_diename(&type));
1050 }
1051 ret = die_get_typename(&type, buf);
1052 return ret ? ret : strbuf_addstr(buf, tmp);
1053}
1054
1055
1056
1057
1058
1059
1060
1061
1062int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf)
1063{
1064 int ret;
1065
1066 ret = die_get_typename(vr_die, buf);
1067 if (ret < 0) {
1068 pr_debug("Failed to get type, make it unknown.\n");
1069 ret = strbuf_add(buf, " (unknown_type)", 14);
1070 }
1071
1072 return ret < 0 ? ret : strbuf_addf(buf, "\t%s", dwarf_diename(vr_die));
1073}
1074
1075#ifdef HAVE_DWARF_GETLOCATIONS_SUPPORT
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085static int die_get_var_innermost_scope(Dwarf_Die *sp_die, Dwarf_Die *vr_die,
1086 struct strbuf *buf)
1087{
1088 Dwarf_Die *scopes;
1089 int count;
1090 size_t offset = 0;
1091 Dwarf_Addr base;
1092 Dwarf_Addr start, end;
1093 Dwarf_Addr entry;
1094 int ret;
1095 bool first = true;
1096 const char *name;
1097
1098 ret = die_entrypc(sp_die, &entry);
1099 if (ret)
1100 return ret;
1101
1102 name = dwarf_diename(sp_die);
1103 if (!name)
1104 return -ENOENT;
1105
1106 count = dwarf_getscopes_die(vr_die, &scopes);
1107
1108
1109 if (count <= 1) {
1110 ret = -EINVAL;
1111 goto out;
1112 }
1113
1114 while ((offset = dwarf_ranges(&scopes[1], offset, &base,
1115 &start, &end)) > 0) {
1116 start -= entry;
1117 end -= entry;
1118
1119 if (first) {
1120 ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1121 name, start, end);
1122 first = false;
1123 } else {
1124 ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1125 start, end);
1126 }
1127 if (ret < 0)
1128 goto out;
1129 }
1130
1131 if (!first)
1132 ret = strbuf_add(buf, "]>", 2);
1133
1134out:
1135 free(scopes);
1136 return ret;
1137}
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf)
1149{
1150 int ret = 0;
1151 Dwarf_Addr base;
1152 Dwarf_Addr start, end;
1153 Dwarf_Addr entry;
1154 Dwarf_Op *op;
1155 size_t nops;
1156 size_t offset = 0;
1157 Dwarf_Attribute attr;
1158 bool first = true;
1159 const char *name;
1160
1161 ret = die_entrypc(sp_die, &entry);
1162 if (ret)
1163 return ret;
1164
1165 name = dwarf_diename(sp_die);
1166 if (!name)
1167 return -ENOENT;
1168
1169 if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
1170 return -EINVAL;
1171
1172 while ((offset = dwarf_getlocations(&attr, offset, &base,
1173 &start, &end, &op, &nops)) > 0) {
1174 if (start == 0) {
1175
1176 ret = die_get_var_innermost_scope(sp_die, vr_die, buf);
1177 goto out;
1178 }
1179
1180
1181 start -= entry;
1182 end -= entry;
1183 if (first) {
1184 ret = strbuf_addf(buf, "@<%s+[%" PRIu64 "-%" PRIu64,
1185 name, start, end);
1186 first = false;
1187 } else {
1188 ret = strbuf_addf(buf, ",%" PRIu64 "-%" PRIu64,
1189 start, end);
1190 }
1191 if (ret < 0)
1192 goto out;
1193 }
1194
1195 if (!first)
1196 ret = strbuf_add(buf, "]>", 2);
1197out:
1198 return ret;
1199}
1200#else
1201int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,
1202 Dwarf_Die *vr_die __maybe_unused,
1203 struct strbuf *buf __maybe_unused)
1204{
1205 return -ENOTSUP;
1206}
1207#endif
1208
1209
1210
1211
1212
1213static bool die_has_loclist(Dwarf_Die *vr_die)
1214{
1215 Dwarf_Attribute loc;
1216 int tag = dwarf_tag(vr_die);
1217
1218 if (tag != DW_TAG_formal_parameter &&
1219 tag != DW_TAG_variable)
1220 return false;
1221
1222 return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) &&
1223 dwarf_whatform(&loc) == DW_FORM_sec_offset);
1224}
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235bool die_is_optimized_target(Dwarf_Die *cu_die)
1236{
1237 Dwarf_Die tmp_die;
1238
1239 if (die_has_loclist(cu_die))
1240 return true;
1241
1242 if (!dwarf_child(cu_die, &tmp_die) &&
1243 die_is_optimized_target(&tmp_die))
1244 return true;
1245
1246 if (!dwarf_siblingof(cu_die, &tmp_die) &&
1247 die_is_optimized_target(&tmp_die))
1248 return true;
1249
1250 return false;
1251}
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines,
1266 Dwarf_Addr addr, unsigned long *idx)
1267{
1268 unsigned long i;
1269 Dwarf_Addr tmp;
1270
1271 for (i = 0; i < nr_lines; i++) {
1272 if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp))
1273 return false;
1274
1275 if (tmp == addr) {
1276 *idx = i;
1277 return true;
1278 }
1279 }
1280 return false;
1281}
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294static bool die_get_postprologue_addr(unsigned long entrypc_idx,
1295 Dwarf_Lines *lines,
1296 unsigned long nr_lines,
1297 Dwarf_Addr highpc,
1298 Dwarf_Addr *postprologue_addr)
1299{
1300 unsigned long i;
1301 int entrypc_lno, lno;
1302 Dwarf_Line *line;
1303 Dwarf_Addr addr;
1304 bool p_end;
1305
1306
1307 line = dwarf_onesrcline(lines, entrypc_idx);
1308 if (dwarf_lineno(line, &entrypc_lno))
1309 return false;
1310
1311 for (i = entrypc_idx; i < nr_lines; i++) {
1312 line = dwarf_onesrcline(lines, i);
1313
1314 if (dwarf_lineaddr(line, &addr) ||
1315 dwarf_lineno(line, &lno) ||
1316 dwarf_lineprologueend(line, &p_end))
1317 return false;
1318
1319
1320 if (addr >= highpc)
1321 break;
1322
1323
1324 if (p_end)
1325 break;
1326
1327
1328 if (lno != entrypc_lno)
1329 break;
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339 if (i != entrypc_idx)
1340 break;
1341 }
1342
1343 dwarf_lineaddr(line, postprologue_addr);
1344 if (*postprologue_addr >= highpc)
1345 dwarf_lineaddr(dwarf_onesrcline(lines, i - 1),
1346 postprologue_addr);
1347
1348 return true;
1349}
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
1364 Dwarf_Addr *entrypc)
1365{
1366 size_t nr_lines = 0;
1367 unsigned long entrypc_idx = 0;
1368 Dwarf_Lines *lines = NULL;
1369 Dwarf_Addr postprologue_addr;
1370 Dwarf_Addr highpc;
1371
1372 if (dwarf_highpc(sp_die, &highpc))
1373 return;
1374
1375 if (dwarf_getsrclines(cu_die, &lines, &nr_lines))
1376 return;
1377
1378 if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx))
1379 return;
1380
1381 if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines,
1382 highpc, &postprologue_addr))
1383 return;
1384
1385 *entrypc = postprologue_addr;
1386}
1387