lib/so-info.c

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