1
2
3
4
5
6#include <errno.h>
7#include <inttypes.h>
8#include <stdbool.h>
9#include "util.h"
10#include "debug.h"
11#include "dwarf-aux.h"
12#include "string2.h"
13
14
15
16
17
18
19
20
21const 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
47
48
49
50
51
52
53const 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
63
64
65
66
67
68
69
70int 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
82 *lineno = 0;
83 }
84
85 return *lineno ?: -ENOENT;
86}
87
88static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
89
90
91
92
93
94
95
96
97
98
99
100int 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
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
123
124
125
126
127
128const 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
139
140
141
142
143
144bool 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
154
155
156
157
158
159
160bool 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
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
177
178
179
180
181
182int 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
196
197
198
199
200
201
202Dwarf_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
214static 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
233
234
235
236
237
238
239
240
241Dwarf_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
251static 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
264static 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
278
279
280
281
282
283bool 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
296
297
298
299
300
301bool 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
311
312
313
314
315
316
317bool die_is_func_instance(Dwarf_Die *dw_die)
318{
319 Dwarf_Addr tmp;
320
321
322 return !dwarf_func_inline(dw_die) && dwarf_entrypc(dw_die, &tmp) == 0;
323}
324
325
326
327
328
329
330
331
332int 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
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
359static 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
370static 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
382
383
384
385
386
387const 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
404
405
406
407
408
409
410
411
412
413
414
415
416
417Dwarf_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
444struct __addr_die_search_param {
445 Dwarf_Addr addr;
446 Dwarf_Die *die_mem;
447};
448
449static 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
465
466
467
468
469
470
471
472
473Dwarf_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
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
487static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
488{
489 struct __addr_die_search_param *ad = data;
490
491
492
493
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
505
506
507
508
509
510
511
512Dwarf_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
519 if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
520 return NULL;
521 else
522 return die_mem;
523}
524
525
526static 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
539
540
541
542
543
544
545
546
547
548Dwarf_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
556
557
558
559
560
561
562
563
564
565Dwarf_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
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
584struct __instance_walk_param {
585 void *addr;
586 int (*callback)(Dwarf_Die *, void *);
587 void *data;
588 int retval;
589};
590
591static 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
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
625
626
627
628
629
630
631
632
633int 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
654struct __line_walk_param {
655 bool recursive;
656 line_walk_callback_t callback;
657 void *data;
658 int retval;
659};
660
661static 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
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
691 return DIE_FIND_CB_CONTINUE;
692}
693
694
695static 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
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);
718done:
719 return lw.retval;
720}
721
722static 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
735
736
737
738
739
740
741
742
743
744
745int 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
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
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
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
786 if (rt_die != cu_die) {
787
788
789
790
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
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
811
812
813 if (rt_die != cu_die)
814
815
816
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, ¶m, 0);
826 ret = param.retval;
827 }
828
829 return ret;
830}
831
832struct __find_variable_param {
833 const char *name;
834 Dwarf_Addr addr;
835};
836
837static 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
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
859
860
861
862
863
864
865
866Dwarf_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
875static 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)) {
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
894
895
896
897
898
899
900Dwarf_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
909
910
911
912
913
914
915
916
917int 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
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
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
950
951
952
953
954
955int 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
971
972
973
974
975
976
977
978static 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
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
1027out:
1028 free(scopes);
1029 return ret;
1030}
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041int 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
1069 ret = die_get_var_innermost_scope(sp_die, vr_die, buf);
1070 goto out;
1071 }
1072
1073
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);
1090out:
1091 return ret;
1092}
1093#else
1094int 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
1104
1105
1106static 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
1121
1122
1123
1124
1125
1126
1127
1128bool 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
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158static 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
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187static 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
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
1213 if (addr >= highpc)
1214 break;
1215
1216
1217 if (p_end)
1218 break;
1219
1220
1221 if (lno != entrypc_lno)
1222 break;
1223
1224
1225
1226
1227
1228
1229
1230
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
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256void 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