Fix: Free die_name in bin_info_lookup_cu_function_name
[babeltrace.git] / lib / bin-info.c
1 /*
2 * bin-info.c
3 *
4 * Babeltrace - Executable and Shared Object Debug Info Reader
5 *
6 * Copyright 2015 Antoine Busque <abusque@efficios.com>
7 *
8 * Author: Antoine Busque <abusque@efficios.com>
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * SOFTWARE.
27 */
28
29 #include <fcntl.h>
30 #include <math.h>
31 #include <libgen.h>
32 #include <stdio.h>
33 #include <inttypes.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37 #include <dwarf.h>
38 #include <glib.h>
39 #include <babeltrace/dwarf.h>
40 #include <babeltrace/bin-info.h>
41 #include <babeltrace/crc32.h>
42 #include <babeltrace/babeltrace-internal.h>
43 #include <babeltrace/utils.h>
44 #include <errno.h>
45
46 /*
47 * An address printed in hex is at most 20 bytes (16 for 64-bits +
48 * leading 0x + optional leading '+' if addr is an offset + null
49 * character).
50 */
51 #define ADDR_STR_LEN 20
52
53 BT_HIDDEN
54 int bin_info_init(void)
55 {
56 int ret = 0;
57
58 if (elf_version(EV_CURRENT) == EV_NONE) {
59 printf_debug("ELF library initialization failed: %s\n",
60 elf_errmsg(-1));
61 ret = -1;
62 }
63
64 return ret;
65 }
66
67 BT_HIDDEN
68 struct bin_info *bin_info_create(const char *path, uint64_t low_addr,
69 uint64_t memsz, bool is_pic)
70 {
71 struct bin_info *bin = NULL;
72
73 if (!path) {
74 goto error;
75 }
76
77 bin = g_new0(struct bin_info, 1);
78 if (!bin) {
79 goto error;
80 }
81
82 if (opt_debug_info_target_prefix) {
83 bin->elf_path = g_build_path("/", opt_debug_info_target_prefix,
84 path, NULL);
85 } else {
86 bin->elf_path = strdup(path);
87 }
88
89 if (!bin->elf_path) {
90 goto error;
91 }
92
93 bin->is_pic = is_pic;
94 bin->memsz = memsz;
95 bin->low_addr = low_addr;
96 bin->high_addr = bin->low_addr + bin->memsz;
97
98 return bin;
99
100 error:
101 bin_info_destroy(bin);
102 return NULL;
103 }
104
105 BT_HIDDEN
106 void bin_info_destroy(struct bin_info *bin)
107 {
108 if (!bin) {
109 return;
110 }
111
112 dwarf_end(bin->dwarf_info);
113
114 free(bin->elf_path);
115 free(bin->dwarf_path);
116 free(bin->build_id);
117 free(bin->dbg_link_filename);
118
119 elf_end(bin->elf_file);
120
121 close(bin->elf_fd);
122 close(bin->dwarf_fd);
123
124 g_free(bin);
125 }
126
127
128 BT_HIDDEN
129 int bin_info_set_build_id(struct bin_info *bin, uint8_t *build_id,
130 size_t build_id_len)
131 {
132 if (!bin || !build_id) {
133 goto error;
134 }
135
136 bin->build_id = malloc(build_id_len);
137 if (!bin->build_id) {
138 goto error;
139 }
140
141 memcpy(bin->build_id, build_id, build_id_len);
142 bin->build_id_len = build_id_len;
143
144 /*
145 * Reset the is_elf_only flag in case it had been set
146 * previously, because we might find separate debug info using
147 * the new build id information.
148 */
149 bin->is_elf_only = false;
150
151 return 0;
152
153 error:
154
155 return -1;
156 }
157
158 BT_HIDDEN
159 int bin_info_set_debug_link(struct bin_info *bin, char *filename, uint32_t crc)
160 {
161 if (!bin || !filename) {
162 goto error;
163 }
164
165 bin->dbg_link_filename = strdup(filename);
166 if (!bin->dbg_link_filename) {
167 goto error;
168 }
169
170 bin->dbg_link_crc = crc;
171
172 /*
173 * Reset the is_elf_only flag in case it had been set
174 * previously, because we might find separate debug info using
175 * the new build id information.
176 */
177 bin->is_elf_only = false;
178
179 return 0;
180
181 error:
182
183 return -1;
184 }
185
186 /**
187 * Tries to read DWARF info from the location given by path, and
188 * attach it to the given bin_info instance if it exists.
189 *
190 * @param bin bin_info instance for which to set DWARF info
191 * @param path Presumed location of the DWARF info
192 * @returns 0 on success, negative value on failure
193 */
194 static
195 int bin_info_set_dwarf_info_from_path(struct bin_info *bin, char *path)
196 {
197 int fd = -1, ret = 0;
198 struct bt_dwarf_cu *cu = NULL;
199 Dwarf *dwarf_info = NULL;
200
201 if (!bin || !path) {
202 goto error;
203 }
204
205 fd = open(path, O_RDONLY);
206 if (fd < 0) {
207 fd = -errno;
208 goto error;
209 }
210
211 dwarf_info = dwarf_begin(fd, DWARF_C_READ);
212 if (!dwarf_info) {
213 goto error;
214 }
215
216 /*
217 * Check if the dwarf info has any CU. If not, the
218 * executable's object file contains no DWARF info.
219 */
220 cu = bt_dwarf_cu_create(dwarf_info);
221 if (!cu) {
222 goto error;
223 }
224
225 ret = bt_dwarf_cu_next(cu);
226 if (ret) {
227 goto error;
228 }
229
230 bin->dwarf_fd = fd;
231 bin->dwarf_path = strdup(path);
232 if (!bin->dwarf_path) {
233 goto error;
234 }
235 bin->dwarf_info = dwarf_info;
236 free(cu);
237
238 return 0;
239
240 error:
241 if (fd >= 0) {
242 close(fd);
243 fd = -1;
244 }
245 dwarf_end(dwarf_info);
246 g_free(dwarf_info);
247 free(cu);
248
249 return fd;
250 }
251
252 /**
253 * Try to set the dwarf_info for a given bin_info instance via the
254 * build ID method.
255 *
256 * @param bin bin_info instance for which to retrieve the
257 * DWARF info via build ID
258 * @returns 0 on success (i.e. dwarf_info set), -1 on failure
259 */
260 static
261 int bin_info_set_dwarf_info_build_id(struct bin_info *bin)
262 {
263 int i = 0, ret = 0;
264 char *path = NULL, *build_id_file = NULL;
265 const char *dbg_dir = NULL;
266 size_t build_id_file_len;
267
268 if (!bin || !bin->build_id) {
269 goto error;
270 }
271
272 dbg_dir = opt_debug_info_dir ? : DEFAULT_DEBUG_DIR;
273
274 /* 2 characters per byte printed in hex, +1 for '/' and +1 for '\0' */
275 build_id_file_len = (2 * bin->build_id_len) + 1 +
276 strlen(BUILD_ID_SUFFIX) + 1;
277 build_id_file = malloc(build_id_file_len);
278 if (!build_id_file) {
279 goto error;
280 }
281
282 snprintf(build_id_file, 4, "%02x/", bin->build_id[0]);
283 for (i = 1; i < bin->build_id_len; ++i) {
284 int path_idx = 3 + 2 * (i - 1);
285
286 snprintf(&build_id_file[path_idx], 3, "%02x", bin->build_id[i]);
287 }
288 strcat(build_id_file, BUILD_ID_SUFFIX);
289
290 path = g_build_path("/", dbg_dir, BUILD_ID_SUBDIR, build_id_file, NULL);
291 if (!path) {
292 goto error;
293 }
294
295 ret = bin_info_set_dwarf_info_from_path(bin, path);
296 if (ret) {
297 goto error;
298 }
299
300 goto end;
301
302 error:
303 ret = -1;
304 end:
305 free(build_id_file);
306 free(path);
307
308 return ret;
309 }
310
311 /**
312 * Tests whether the file located at path exists and has the expected
313 * checksum.
314 *
315 * This predicate is used when looking up separate debug info via the
316 * GNU debuglink method. The expected crc can be found .gnu_debuglink
317 * section in the original ELF file, along with the filename for the
318 * file containing the debug info.
319 *
320 * @param path Full path at which to look for the debug file
321 * @param crc Expected checksum for the debug file
322 * @returns 1 if the file exists and has the correct checksum,
323 * 0 otherwise
324 */
325 static
326 int is_valid_debug_file(char *path, uint32_t crc)
327 {
328 int ret = 0, fd = -1;
329 uint32_t _crc = 0;
330
331 if (!path) {
332 goto end;
333 }
334
335 fd = open(path, O_RDONLY);
336 if (fd < 0) {
337 goto end;
338 }
339
340 ret = crc32(fd, &_crc);
341 if (ret) {
342 ret = 0;
343 goto end;
344 }
345
346 ret = (crc == _crc);
347
348 end:
349 close(fd);
350 return ret;
351 }
352
353 /**
354 * Try to set the dwarf_info for a given bin_info instance via the
355 * build ID method.
356 *
357 * @param bin bin_info instance for which to retrieve the
358 * DWARF info via debug link
359 * @returns 0 on success (i.e. dwarf_info set), -1 on failure
360 */
361 static
362 int bin_info_set_dwarf_info_debug_link(struct bin_info *bin)
363 {
364 int ret = 0;
365 const char *dbg_dir = NULL;
366 char *dir_name = NULL, *bin_dir = NULL, *path = NULL;
367 size_t max_path_len = 0;
368
369 if (!bin || !bin->dbg_link_filename) {
370 goto error;
371 }
372
373 dbg_dir = opt_debug_info_dir ? : DEFAULT_DEBUG_DIR;
374
375 dir_name = dirname(bin->elf_path);
376 if (!dir_name) {
377 goto error;
378 }
379
380 /* bin_dir is just dir_name with a trailing slash */
381 bin_dir = malloc(strlen(dir_name) + 2);
382 if (!bin_dir) {
383 goto error;
384 }
385
386 strcpy(bin_dir, dir_name);
387 strcat(bin_dir, "/");
388
389 max_path_len = strlen(dbg_dir) + strlen(bin_dir) +
390 strlen(DEBUG_SUBDIR) + strlen(bin->dbg_link_filename)
391 + 1;
392 path = malloc(max_path_len);
393 if (!path) {
394 goto error;
395 }
396
397 /* First look in the executable's dir */
398 strcpy(path, bin_dir);
399 strcat(path, bin->dbg_link_filename);
400
401 if (is_valid_debug_file(path, bin->dbg_link_crc)) {
402 goto found;
403 }
404
405 /* If not found, look in .debug subdir */
406 strcpy(path, bin_dir);
407 strcat(path, DEBUG_SUBDIR);
408 strcat(path, bin->dbg_link_filename);
409
410 if (is_valid_debug_file(path, bin->dbg_link_crc)) {
411 goto found;
412 }
413
414 /* Lastly, look under the global debug directory */
415 strcpy(path, dbg_dir);
416 strcat(path, bin_dir);
417 strcat(path, bin->dbg_link_filename);
418
419 if (is_valid_debug_file(path, bin->dbg_link_crc)) {
420 goto found;
421 }
422
423 error:
424 ret = -1;
425 end:
426 free(path);
427 free(bin_dir);
428
429 return ret;
430
431 found:
432 ret = bin_info_set_dwarf_info_from_path(bin, path);
433 if (ret) {
434 goto error;
435 }
436
437 goto end;
438 }
439
440 /**
441 * Initialize the DWARF info for a given executable.
442 *
443 * @param bin bin_info instance
444 * @returns 0 on success, negative value on failure
445 */
446 static
447 int bin_info_set_dwarf_info(struct bin_info *bin)
448 {
449 int ret = 0;
450
451 if (!bin) {
452 ret = -1;
453 goto end;
454 }
455
456 /* First try to set the DWARF info from the ELF file */
457 ret = bin_info_set_dwarf_info_from_path(bin, bin->elf_path);
458 if (!ret) {
459 goto end;
460 }
461
462 /*
463 * If that fails, try to find separate debug info via build ID
464 * and debug link.
465 */
466 ret = bin_info_set_dwarf_info_build_id(bin);
467 if (!ret) {
468 goto end;
469 }
470
471 ret = bin_info_set_dwarf_info_debug_link(bin);
472 if (!ret) {
473 goto end;
474 }
475
476 end:
477 return ret;
478 }
479
480 /**
481 * Initialize the ELF file for a given executable.
482 *
483 * @param bin bin_info instance
484 * @returns 0 on success, negative value on error.
485 */
486 static
487 int bin_info_set_elf_file(struct bin_info *bin)
488 {
489 int elf_fd = -1;
490 Elf *elf_file = NULL;
491
492 if (!bin) {
493 goto error;
494 }
495
496 elf_fd = open(bin->elf_path, O_RDONLY);
497 if (elf_fd < 0) {
498 elf_fd = -errno;
499 printf_verbose("Failed to open %s\n", bin->elf_path);
500 goto error;
501 }
502
503 elf_file = elf_begin(elf_fd, ELF_C_READ, NULL);
504 if (!elf_file) {
505 printf_debug("elf_begin failed: %s\n", elf_errmsg(-1));
506 goto error;
507 }
508
509 if (elf_kind(elf_file) != ELF_K_ELF) {
510 printf_verbose("Error: %s is not an ELF object\n",
511 bin->elf_path);
512 goto error;
513 }
514
515 bin->elf_fd = elf_fd;
516 bin->elf_file = elf_file;
517 return 0;
518
519 error:
520 if (elf_fd >= 0) {
521 close(elf_fd);
522 elf_fd = -1;
523 }
524 elf_end(elf_file);
525 return elf_fd;
526 }
527
528 BT_HIDDEN
529 void source_location_destroy(struct source_location *src_loc)
530 {
531 if (!src_loc) {
532 return;
533 }
534
535 free(src_loc->filename);
536 g_free(src_loc);
537 }
538
539 /**
540 * Append a string representation of an address offset to an existing
541 * string.
542 *
543 * On success, the out parameter `result` will contain the base string
544 * followed by the offset string of the form "+0x1234". On failure,
545 * `result` remains unchanged.
546 *
547 * @param base_str The string to which to append an offset string
548 * @param low_addr The lower virtual memory address, the base from
549 * which the offset is computed
550 * @param high_addr The higher virtual memory address
551 * @param result Out parameter, the base string followed by the
552 * offset string
553 * @returns 0 on success, -1 on failure
554 */
555 static
556 int bin_info_append_offset_str(const char *base_str, uint64_t low_addr,
557 uint64_t high_addr, char **result)
558 {
559 int ret;
560 uint64_t offset;
561 char *_result = NULL;
562 char offset_str[ADDR_STR_LEN];
563
564 if (!base_str || !result) {
565 goto error;
566 }
567
568 offset = high_addr - low_addr;
569
570 _result = malloc(strlen(base_str) + ADDR_STR_LEN);
571 if (!_result) {
572 goto error;
573 }
574
575 ret = snprintf(offset_str, ADDR_STR_LEN, "+%#0" PRIx64, offset);
576 if (ret < 0) {
577 goto error;
578 }
579 strcpy(_result, base_str);
580 strcat(_result, offset_str);
581 *result = _result;
582
583 return 0;
584
585 error:
586 free(_result);
587 return -1;
588 }
589
590 /**
591 * Try to find the symbol closest to an address within a given ELF
592 * section.
593 *
594 * Only function symbols are taken into account. The symbol's address
595 * must precede `addr`. A symbol with a closer address might exist
596 * after `addr` but is irrelevant because it cannot encompass `addr`.
597 *
598 * On success, if found, the out parameters `sym` and `shdr` are
599 * set. On failure or if none are found, they remain unchanged.
600 *
601 * @param scn ELF section in which to look for the address
602 * @param addr Virtual memory address for which to find the
603 * nearest function symbol
604 * @param sym Out parameter, the nearest function symbol
605 * @param shdr Out parameter, the section header for scn
606 * @returns 0 on success, -1 on failure
607 */
608 static
609 int bin_info_get_nearest_symbol_from_section(Elf_Scn *scn, uint64_t addr,
610 GElf_Sym **sym, GElf_Shdr **shdr)
611 {
612 int i;
613 size_t symbol_count;
614 Elf_Data *data = NULL;
615 GElf_Shdr *_shdr = NULL;
616 GElf_Sym *nearest_sym = NULL;
617
618 if (!scn || !sym || !shdr) {
619 goto error;
620 }
621
622 _shdr = g_new0(GElf_Shdr, 1);
623 if (!_shdr) {
624 goto error;
625 }
626
627 _shdr = gelf_getshdr(scn, _shdr);
628 if (!_shdr) {
629 goto error;
630 }
631
632 if (_shdr->sh_type != SHT_SYMTAB) {
633 /*
634 * We are only interested in symbol table (symtab)
635 * sections, skip this one.
636 */
637 goto end;
638 }
639
640 data = elf_getdata(scn, NULL);
641 if (!data) {
642 goto error;
643 }
644
645 symbol_count = _shdr->sh_size / _shdr->sh_entsize;
646
647 for (i = 0; i < symbol_count; ++i) {
648 GElf_Sym *cur_sym = NULL;
649
650 cur_sym = g_new0(GElf_Sym, 1);
651 if (!cur_sym) {
652 goto error;
653 }
654 cur_sym = gelf_getsym(data, i, cur_sym);
655 if (!cur_sym) {
656 goto error;
657 }
658 if (GELF_ST_TYPE(cur_sym->st_info) != STT_FUNC) {
659 /* We're only interested in the functions. */
660 g_free(cur_sym);
661 continue;
662 }
663
664 if (cur_sym->st_value <= addr &&
665 (!nearest_sym ||
666 cur_sym->st_value > nearest_sym->st_value)) {
667 g_free(nearest_sym);
668 nearest_sym = cur_sym;
669 } else {
670 g_free(cur_sym);
671 }
672 }
673
674 end:
675 if (nearest_sym) {
676 *sym = nearest_sym;
677 *shdr = _shdr;
678 } else {
679 g_free(_shdr);
680 }
681
682 return 0;
683
684 error:
685 g_free(nearest_sym);
686 g_free(_shdr);
687 return -1;
688 }
689
690 /**
691 * Get the name of the function containing a given address within an
692 * executable using ELF symbols.
693 *
694 * The function name is in fact the name of the nearest ELF symbol,
695 * followed by the offset in bytes between the address and the symbol
696 * (in hex), separated by a '+' character.
697 *
698 * If found, the out parameter `func_name` is set on success. On failure,
699 * it remains unchanged.
700 *
701 * @param bin bin_info instance for the executable containing
702 * the address
703 * @param addr Virtual memory address for which to find the
704 * function name
705 * @param func_name Out parameter, the function name
706 * @returns 0 on success, -1 on failure
707 */
708 static
709 int bin_info_lookup_elf_function_name(struct bin_info *bin, uint64_t addr,
710 char **func_name)
711 {
712 /*
713 * TODO (possible optimisation): if an ELF has no symtab
714 * section, it has been stripped. Therefore, it would be wise
715 * to store a flag indicating the stripped status after the
716 * first iteration to prevent subsequent ones.
717 */
718 int ret = 0;
719 Elf_Scn *scn = NULL;
720 GElf_Sym *sym = NULL;
721 GElf_Shdr *shdr = NULL;
722 char *sym_name = NULL;
723
724 /* Set ELF file if it hasn't been accessed yet. */
725 if (!bin->elf_file) {
726 ret = bin_info_set_elf_file(bin);
727 if (ret) {
728 /* Failed to set ELF file. */
729 goto error;
730 }
731 }
732
733 scn = elf_nextscn(bin->elf_file, scn);
734 if (!scn) {
735 goto error;
736 }
737
738 while (scn && !sym) {
739 ret = bin_info_get_nearest_symbol_from_section(
740 scn, addr, &sym, &shdr);
741 if (ret) {
742 goto error;
743 }
744
745 scn = elf_nextscn(bin->elf_file, scn);
746 }
747
748 if (sym) {
749 sym_name = elf_strptr(bin->elf_file, shdr->sh_link,
750 sym->st_name);
751 if (!sym_name) {
752 goto error;
753 }
754
755 ret = bin_info_append_offset_str(sym_name, sym->st_value, addr,
756 func_name);
757 if (ret) {
758 goto error;
759 }
760 }
761
762 g_free(shdr);
763 g_free(sym);
764 return 0;
765
766 error:
767 g_free(shdr);
768 g_free(sym);
769 return ret;
770 }
771
772 /**
773 * Get the name of the function containing a given address within a
774 * given compile unit (CU).
775 *
776 * If found, the out parameter `func_name` is set on success. On
777 * failure, it remains unchanged.
778 *
779 * @param cu bt_dwarf_cu instance which may contain the address
780 * @param addr Virtual memory address for which to find the
781 * function name
782 * @param func_name Out parameter, the function name
783 * @returns 0 on success, -1 on failure
784 */
785 static
786 int bin_info_lookup_cu_function_name(struct bt_dwarf_cu *cu, uint64_t addr,
787 char **func_name)
788 {
789 int ret = 0;
790 bool found = false;
791 struct bt_dwarf_die *die = NULL;
792
793 if (!cu || !func_name) {
794 goto error;
795 }
796
797 die = bt_dwarf_die_create(cu);
798 if (!die) {
799 goto error;
800 }
801
802 while (bt_dwarf_die_next(die) == 0) {
803 int tag;
804
805 ret = bt_dwarf_die_get_tag(die, &tag);
806 if (ret) {
807 goto error;
808 }
809
810 if (tag == DW_TAG_subprogram) {
811 ret = bt_dwarf_die_contains_addr(die, addr, &found);
812 if (ret) {
813 goto error;
814 }
815
816 if (found) {
817 break;
818 }
819 }
820 }
821
822 if (found) {
823 uint64_t low_addr = 0;
824 char *die_name = NULL;
825
826 ret = bt_dwarf_die_get_name(die, &die_name);
827 if (ret) {
828 goto error;
829 }
830
831 ret = dwarf_lowpc(die->dwarf_die, &low_addr);
832 if (ret) {
833 free(die_name);
834 goto error;
835 }
836
837 ret = bin_info_append_offset_str(die_name, low_addr, addr,
838 func_name);
839 free(die_name);
840 if (ret) {
841 goto error;
842 }
843 }
844
845 bt_dwarf_die_destroy(die);
846 return 0;
847
848 error:
849 bt_dwarf_die_destroy(die);
850 return -1;
851 }
852
853 /**
854 * Get the name of the function containing a given address within an
855 * executable using DWARF debug info.
856 *
857 * If found, the out parameter `func_name` is set on success. On
858 * failure, it remains unchanged.
859 *
860 * @param bin bin_info instance for the executable containing
861 * the address
862 * @param addr Virtual memory address for which to find the
863 * function name
864 * @param func_name Out parameter, the function name
865 * @returns 0 on success, -1 on failure
866 */
867 static
868 int bin_info_lookup_dwarf_function_name(struct bin_info *bin, uint64_t addr,
869 char **func_name)
870 {
871 int ret = 0;
872 char *_func_name = NULL;
873 struct bt_dwarf_cu *cu = NULL;
874
875 if (!bin || !func_name) {
876 goto error;
877 }
878
879 cu = bt_dwarf_cu_create(bin->dwarf_info);
880 if (!cu) {
881 goto error;
882 }
883
884 while (bt_dwarf_cu_next(cu) == 0) {
885 ret = bin_info_lookup_cu_function_name(cu, addr, &_func_name);
886 if (ret) {
887 goto error;
888 }
889
890 if (_func_name) {
891 break;
892 }
893 }
894
895 if (_func_name) {
896 *func_name = _func_name;
897 } else {
898 goto error;
899 }
900
901 bt_dwarf_cu_destroy(cu);
902 return 0;
903
904 error:
905 bt_dwarf_cu_destroy(cu);
906 return -1;
907 }
908
909 BT_HIDDEN
910 int bin_info_lookup_function_name(struct bin_info *bin, uint64_t addr,
911 char **func_name)
912 {
913 int ret = 0;
914 char *_func_name = NULL;
915
916 if (!bin || !func_name) {
917 goto error;
918 }
919
920 /* Set DWARF info if it hasn't been accessed yet. */
921 if (!bin->dwarf_info && !bin->is_elf_only) {
922 ret = bin_info_set_dwarf_info(bin);
923 if (ret) {
924 printf_verbose("Failed to set bin dwarf info, falling back to ELF lookup.\n");
925 /* Failed to set DWARF info, fallback to ELF. */
926 bin->is_elf_only = true;
927 }
928 }
929
930 if (!bin_info_has_address(bin, addr)) {
931 goto error;
932 }
933
934 /*
935 * Addresses in ELF and DWARF are relative to base address for
936 * PIC, so make the address argument relative too if needed.
937 */
938 if (bin->is_pic) {
939 addr -= bin->low_addr;
940 }
941
942 if (bin->is_elf_only) {
943 ret = bin_info_lookup_elf_function_name(bin, addr, &_func_name);
944 printf_verbose("Failed to lookup function name (elf), error %i\n", ret);
945 } else {
946 ret = bin_info_lookup_dwarf_function_name(bin, addr, &_func_name);
947 printf_verbose("Failed to lookup function name (dwarf), error %i\n", ret);
948 }
949
950 *func_name = _func_name;
951 return 0;
952
953 error:
954 return -1;
955 }
956
957 BT_HIDDEN
958 int bin_info_get_bin_loc(struct bin_info *bin, uint64_t addr, char **bin_loc)
959 {
960 int ret = 0;
961 char *_bin_loc = NULL;
962
963 if (!bin || !bin_loc) {
964 goto error;
965 }
966
967 if (bin->is_pic) {
968 addr -= bin->low_addr;
969 ret = asprintf(&_bin_loc, "+%#0" PRIx64, addr);
970 } else {
971 ret = asprintf(&_bin_loc, "@%#0" PRIx64, addr);
972 }
973
974 if (ret == -1 || !_bin_loc) {
975 goto error;
976 }
977
978 *bin_loc = _bin_loc;
979 return 0;
980
981 error:
982 return -1;
983 }
984
985 /**
986 * Predicate used to determine whether the children of a given DIE
987 * contain a specific address.
988 *
989 * More specifically, the parameter `die` is expected to be a
990 * subprogram (function) DIE, and this predicate tells whether any
991 * subroutines are inlined within this function and would contain
992 * `addr`.
993 *
994 * On success, the out parameter `contains` is set with the boolean
995 * value indicating whether the DIE's range covers `addr`. On failure,
996 * it remains unchanged.
997 *
998 * Do note that this function advances the position of `die`. If the
999 * address is found within one of its children, `die` will be pointing
1000 * to that child upon returning from the function, allowing to extract
1001 * the information deemed necessary.
1002 *
1003 * @param die The parent DIE in whose children the address will be
1004 * looked for
1005 * @param addr The address for which to look for in the DIEs
1006 * @param contains Out parameter, true if addr is contained,
1007 * false if not
1008 * @returns Returns 0 on success, -1 on failure
1009 */
1010 static
1011 int bin_info_child_die_has_address(struct bt_dwarf_die *die, uint64_t addr, bool *contains)
1012 {
1013 int ret = 0;
1014 bool _contains = false;
1015
1016 if (!die) {
1017 goto error;
1018 }
1019
1020 ret = bt_dwarf_die_child(die);
1021 if (ret) {
1022 goto error;
1023 }
1024
1025 do {
1026 int tag;
1027
1028 ret = bt_dwarf_die_get_tag(die, &tag);
1029 if (ret) {
1030 goto error;
1031 }
1032
1033 if (tag == DW_TAG_inlined_subroutine) {
1034 ret = bt_dwarf_die_contains_addr(die, addr, &_contains);
1035 if (ret) {
1036 goto error;
1037 }
1038
1039 if (contains) {
1040 goto end;
1041 }
1042 }
1043 } while (bt_dwarf_die_next(die) == 0);
1044
1045 end:
1046 *contains = _contains;
1047 return 0;
1048
1049 error:
1050 return -1;
1051 }
1052
1053 /**
1054 * Lookup the source location for a given address within a CU, making
1055 * the assumption that it is contained within an inline routine in a
1056 * function.
1057 *
1058 * @param cu bt_dwarf_cu instance in which to look for the address
1059 * @param addr The address for which to look for
1060 * @param src_loc Out parameter, the source location (filename and
1061 * line number) for the address
1062 * @returns 0 on success, -1 on failure
1063 */
1064 static
1065 int bin_info_lookup_cu_src_loc_inl(struct bt_dwarf_cu *cu, uint64_t addr,
1066 struct source_location **src_loc)
1067 {
1068 int ret = 0;
1069 bool found = false;
1070 struct bt_dwarf_die *die = NULL;
1071 struct source_location *_src_loc = NULL;
1072
1073 if (!cu || !src_loc) {
1074 goto error;
1075 }
1076
1077 die = bt_dwarf_die_create(cu);
1078 if (!die) {
1079 goto error;
1080 }
1081
1082 while (bt_dwarf_die_next(die) == 0) {
1083 int tag;
1084
1085 ret = bt_dwarf_die_get_tag(die, &tag);
1086 if (ret) {
1087 goto error;
1088 }
1089
1090 if (tag == DW_TAG_subprogram) {
1091 bool contains = false;
1092
1093 ret = bt_dwarf_die_contains_addr(die, addr, &contains);
1094 if (ret) {
1095 goto error;
1096 }
1097
1098 if (contains) {
1099 /*
1100 * Try to find an inlined subroutine
1101 * child of this DIE containing addr.
1102 */
1103 ret = bin_info_child_die_has_address(die, addr,
1104 &found);
1105 if(ret) {
1106 goto error;
1107 }
1108
1109 goto end;
1110 }
1111 }
1112 }
1113
1114 end:
1115 if (found) {
1116 char *filename = NULL;
1117 uint64_t line_no;
1118
1119 _src_loc = g_new0(struct source_location, 1);
1120 if (!_src_loc) {
1121 goto error;
1122 }
1123
1124 ret = bt_dwarf_die_get_call_file(die, &filename);
1125 if (ret) {
1126 goto error;
1127 }
1128 ret = bt_dwarf_die_get_call_line(die, &line_no);
1129 if (ret) {
1130 free(filename);
1131 goto error;
1132 }
1133
1134 _src_loc->filename = filename;
1135 _src_loc->line_no = line_no;
1136 *src_loc = _src_loc;
1137 }
1138
1139 bt_dwarf_die_destroy(die);
1140 return 0;
1141
1142 error:
1143 source_location_destroy(_src_loc);
1144 bt_dwarf_die_destroy(die);
1145 return -1;
1146 }
1147
1148 /**
1149 * Lookup the source location for a given address within a CU,
1150 * assuming that it is contained within an inlined function.
1151 *
1152 * A source location can be found regardless of inlining status for
1153 * this method, but in the case of an inlined function, the returned
1154 * source location will point not to the callsite but rather to the
1155 * definition site of the inline function.
1156 *
1157 * @param cu bt_dwarf_cu instance in which to look for the address
1158 * @param addr The address for which to look for
1159 * @param src_loc Out parameter, the source location (filename and
1160 * line number) for the address
1161 * @returns 0 on success, -1 on failure
1162 */
1163 static
1164 int bin_info_lookup_cu_src_loc_no_inl(struct bt_dwarf_cu *cu, uint64_t addr,
1165 struct source_location **src_loc)
1166 {
1167 struct source_location *_src_loc = NULL;
1168 struct bt_dwarf_die *die = NULL;
1169 const char *filename = NULL;
1170 Dwarf_Line *line = NULL;
1171 Dwarf_Addr line_addr;
1172 int ret, line_no;
1173
1174 if (!cu || !src_loc) {
1175 goto error;
1176 }
1177
1178 die = bt_dwarf_die_create(cu);
1179 if (!die) {
1180 goto error;
1181 }
1182
1183 line = dwarf_getsrc_die(die->dwarf_die, addr);
1184 if (!line) {
1185 goto error;
1186 }
1187
1188 ret = dwarf_lineaddr(line, &line_addr);
1189 if (ret) {
1190 goto error;
1191 }
1192
1193 filename = dwarf_linesrc(line, NULL, NULL);
1194 if (!filename) {
1195 goto error;
1196 }
1197
1198 if (addr == line_addr) {
1199 _src_loc = g_new0(struct source_location, 1);
1200 if (!_src_loc) {
1201 goto error;
1202 }
1203
1204 ret = dwarf_lineno(line, &line_no);
1205 if (ret) {
1206 goto error;
1207 }
1208
1209 _src_loc->line_no = line_no;
1210 _src_loc->filename = strdup(filename);
1211 }
1212
1213 bt_dwarf_die_destroy(die);
1214
1215 if (_src_loc) {
1216 *src_loc = _src_loc;
1217 }
1218
1219 return 0;
1220
1221 error:
1222 source_location_destroy(_src_loc);
1223 bt_dwarf_die_destroy(die);
1224 return -1;
1225 }
1226
1227 /**
1228 * Get the source location (file name and line number) for a given
1229 * address within a compile unit (CU).
1230 *
1231 * On success, the out parameter `src_loc` is set if found. On
1232 * failure, it remains unchanged.
1233 *
1234 * @param cu bt_dwarf_cu instance for the compile unit which
1235 * may contain the address
1236 * @param addr Virtual memory address for which to find the
1237 * source location
1238 * @param src_loc Out parameter, the source location
1239 * @returns 0 on success, -1 on failure
1240 */
1241 static
1242 int bin_info_lookup_cu_src_loc(struct bt_dwarf_cu *cu, uint64_t addr,
1243 struct source_location **src_loc)
1244 {
1245 int ret = 0;
1246 struct source_location *_src_loc = NULL;
1247
1248 if (!cu || !src_loc) {
1249 goto error;
1250 }
1251
1252 ret = bin_info_lookup_cu_src_loc_inl(cu, addr, &_src_loc);
1253 if (ret) {
1254 goto error;
1255 }
1256
1257 if (_src_loc) {
1258 goto end;
1259 }
1260
1261 ret = bin_info_lookup_cu_src_loc_no_inl(cu, addr, &_src_loc);
1262 if (ret) {
1263 goto error;
1264 }
1265
1266 if (_src_loc) {
1267 goto end;
1268 }
1269
1270 end:
1271 if (_src_loc) {
1272 *src_loc = _src_loc;
1273 }
1274
1275 return 0;
1276
1277 error:
1278 source_location_destroy(_src_loc);
1279 return -1;
1280 }
1281
1282 BT_HIDDEN
1283 int bin_info_lookup_source_location(struct bin_info *bin, uint64_t addr,
1284 struct source_location **src_loc)
1285 {
1286 struct bt_dwarf_cu *cu = NULL;
1287 struct source_location *_src_loc = NULL;
1288
1289 if (!bin || !src_loc) {
1290 goto error;
1291 }
1292
1293 /* Set DWARF info if it hasn't been accessed yet. */
1294 if (!bin->dwarf_info && !bin->is_elf_only) {
1295 if (bin_info_set_dwarf_info(bin)) {
1296 /* Failed to set DWARF info. */
1297 bin->is_elf_only = true;
1298 }
1299 }
1300
1301 if (bin->is_elf_only) {
1302 /* We cannot lookup source location without DWARF info. */
1303 goto error;
1304 }
1305
1306 if (!bin_info_has_address(bin, addr)) {
1307 goto error;
1308 }
1309
1310 /*
1311 * Addresses in ELF and DWARF are relative to base address for
1312 * PIC, so make the address argument relative too if needed.
1313 */
1314 if (bin->is_pic) {
1315 addr -= bin->low_addr;
1316 }
1317
1318 cu = bt_dwarf_cu_create(bin->dwarf_info);
1319 if (!cu) {
1320 goto error;
1321 }
1322
1323 while (bt_dwarf_cu_next(cu) == 0) {
1324 int ret;
1325
1326 ret = bin_info_lookup_cu_src_loc(cu, addr, &_src_loc);
1327 if (ret) {
1328 goto error;
1329 }
1330
1331 if (_src_loc) {
1332 break;
1333 }
1334 }
1335
1336 bt_dwarf_cu_destroy(cu);
1337 if (_src_loc) {
1338 *src_loc = _src_loc;
1339 }
1340
1341 return 0;
1342
1343 error:
1344 source_location_destroy(_src_loc);
1345 bt_dwarf_cu_destroy(cu);
1346 return -1;
1347 }
This page took 0.095837 seconds and 4 git commands to generate.