libbacktrace/elf.c

   1 /* elf.c -- Get debug data from an ELF file for backtraces.
   2    Copyright (C) 2012 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Google.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are
   7 met:
   8
   9     (1) Redistributions of source code must retain the above copyright
  10     notice, this list of conditions and the following disclaimer.
  11
  12     (2) Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in
  14     the documentation and/or other materials provided with the
  15     distribution.
  16
  17     (3) The name of the author may not be used to
  18     endorse or promote products derived from this software without
  19     specific prior written permission.
  20
  21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31 POSSIBILITY OF SUCH DAMAGE.  */
  32
  33 #include "config.h"
  34
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <sys/types.h>
  38
  39 #ifdef HAVE_DL_ITERATE_PHDR
  40 #include <link.h>
  41 #endif
  42
  43 #include "backtrace.h"
  44 #include "internal.h"
  45
  46 #ifndef HAVE_DL_ITERATE_PHDR
  47
  48 /* Dummy version of dl_iterate_phdr for systems that don't have it.  */
  49
  50 #define dl_phdr_info x_dl_phdr_info
  51 #define dl_iterate_phdr x_dl_iterate_phdr
  52
  53 struct dl_phdr_info
  54 {
  55   uintptr_t dlpi_addr;
  56   const char *dlpi_name;
  57 };
  58
  59 static int
  60 dl_iterate_phdr (int (*callback) (struct dl_phdr_info *,
  61                                   size_t, void *) ATTRIBUTE_UNUSED,
  62                  void *data ATTRIBUTE_UNUSED)
  63 {
  64   return 0;
  65 }
  66
  67 #endif /* ! defined (HAVE_DL_ITERATE_PHDR) */
  68
  69 /* The configure script must tell us whether we are 32-bit or 64-bit
  70    ELF.  We could make this code test and support either possibility,
  71    but there is no point.  This code only works for the currently
  72    running executable, which means that we know the ELF mode at
  73    configure mode.  */
  74
  75 #if BACKTRACE_ELF_SIZE != 32 && BACKTRACE_ELF_SIZE != 64
  76 #error "Unknown BACKTRACE_ELF_SIZE"
  77 #endif
  78
  79 /* <link.h> might #include <elf.h> which might define our constants
  80    with slightly different values.  Undefine them to be safe.  */
  81
  82 #undef EI_NIDENT
  83 #undef EI_MAG0
  84 #undef EI_MAG1
  85 #undef EI_MAG2
  86 #undef EI_MAG3
  87 #undef EI_CLASS
  88 #undef EI_DATA
  89 #undef EI_VERSION
  90 #undef ELF_MAG0
  91 #undef ELF_MAG1
  92 #undef ELF_MAG2
  93 #undef ELF_MAG3
  94 #undef ELFCLASS32
  95 #undef ELFCLASS64
  96 #undef ELFDATA2LSB
  97 #undef ELFDATA2MSB
  98 #undef EV_CURRENT
  99 #undef SHN_LORESERVE
 100 #undef SHN_XINDEX
 101 #undef SHT_SYMTAB
 102 #undef SHT_STRTAB
 103 #undef SHT_DYNSYM
 104 #undef STT_FUNC
 105
 106 /* Basic types.  */
 107
 108 typedef uint16_t b_elf_half;    /* Elf_Half.  */
 109 typedef uint32_t b_elf_word;    /* Elf_Word.  */
 110 typedef int32_t  b_elf_sword;   /* Elf_Sword.  */
 111
 112 #if BACKTRACE_ELF_SIZE == 32
 113
 114 typedef uint32_t b_elf_addr;    /* Elf_Addr.  */
 115 typedef uint32_t b_elf_off;     /* Elf_Off.  */
 116
 117 typedef uint32_t b_elf_wxword;  /* 32-bit Elf_Word, 64-bit ELF_Xword.  */
 118
 119 #else
 120
 121 typedef uint64_t b_elf_addr;    /* Elf_Addr.  */
 122 typedef uint64_t b_elf_off;     /* Elf_Off.  */
 123 typedef uint64_t b_elf_xword;   /* Elf_Xword.  */
 124 typedef int64_t  b_elf_sxword;  /* Elf_Sxword.  */
 125
 126 typedef uint64_t b_elf_wxword;  /* 32-bit Elf_Word, 64-bit ELF_Xword.  */
 127
 128 #endif
 129
 130 /* Data structures and associated constants.  */
 131
 132 #define EI_NIDENT 16
 133
 134 typedef struct {
 135   unsigned char e_ident[EI_NIDENT];     /* ELF "magic number" */
 136   b_elf_half    e_type;                 /* Identifies object file type */
 137   b_elf_half    e_machine;              /* Specifies required architecture */
 138   b_elf_word    e_version;              /* Identifies object file version */
 139   b_elf_addr    e_entry;                /* Entry point virtual address */
 140   b_elf_off     e_phoff;                /* Program header table file offset */
 141   b_elf_off     e_shoff;                /* Section header table file offset */
 142   b_elf_word    e_flags;                /* Processor-specific flags */
 143   b_elf_half    e_ehsize;               /* ELF header size in bytes */
 144   b_elf_half    e_phentsize;            /* Program header table entry size */
 145   b_elf_half    e_phnum;                /* Program header table entry count */
 146   b_elf_half    e_shentsize;            /* Section header table entry size */
 147   b_elf_half    e_shnum;                /* Section header table entry count */
 148   b_elf_half    e_shstrndx;             /* Section header string table index */
 149 } b_elf_ehdr;  /* Elf_Ehdr.  */
 150
 151 #define EI_MAG0 0
 152 #define EI_MAG1 1
 153 #define EI_MAG2 2
 154 #define EI_MAG3 3
 155 #define EI_CLASS 4
 156 #define EI_DATA 5
 157 #define EI_VERSION 6
 158
 159 #define ELFMAG0 0x7f
 160 #define ELFMAG1 'E'
 161 #define ELFMAG2 'L'
 162 #define ELFMAG3 'F'
 163
 164 #define ELFCLASS32 1
 165 #define ELFCLASS64 2
 166
 167 #define ELFDATA2LSB 1
 168 #define ELFDATA2MSB 2
 169
 170 #define EV_CURRENT 1
 171
 172 typedef struct {
 173   b_elf_word    sh_name;                /* Section name, index in string tbl */
 174   b_elf_word    sh_type;                /* Type of section */
 175   b_elf_wxword  sh_flags;               /* Miscellaneous section attributes */
 176   b_elf_addr    sh_addr;                /* Section virtual addr at execution */
 177   b_elf_off     sh_offset;              /* Section file offset */
 178   b_elf_wxword  sh_size;                /* Size of section in bytes */
 179   b_elf_word    sh_link;                /* Index of another section */
 180   b_elf_word    sh_info;                /* Additional section information */
 181   b_elf_wxword  sh_addralign;           /* Section alignment */
 182   b_elf_wxword  sh_entsize;             /* Entry size if section holds table */
 183 } b_elf_shdr;  /* Elf_Shdr.  */
 184
 185 #define SHN_LORESERVE   0xFF00          /* Begin range of reserved indices */
 186 #define SHN_XINDEX      0xFFFF          /* Section index is held elsewhere */
 187
 188 #define SHT_SYMTAB 2
 189 #define SHT_STRTAB 3
 190 #define SHT_DYNSYM 11
 191
 192 #if BACKTRACE_ELF_SIZE == 32
 193
 194 typedef struct
 195 {
 196   b_elf_word    st_name;                /* Symbol name, index in string tbl */
 197   b_elf_addr    st_value;               /* Symbol value */
 198   b_elf_word    st_size;                /* Symbol size */
 199   unsigned char st_info;                /* Symbol binding and type */
 200   unsigned char st_other;               /* Visibility and other data */
 201   b_elf_half    st_shndx;               /* Symbol section index */
 202 } b_elf_sym;  /* Elf_Sym.  */
 203
 204 #else /* BACKTRACE_ELF_SIZE != 32 */
 205
 206 typedef struct
 207 {
 208   b_elf_word    st_name;                /* Symbol name, index in string tbl */
 209   unsigned char st_info;                /* Symbol binding and type */
 210   unsigned char st_other;               /* Visibility and other data */
 211   b_elf_half    st_shndx;               /* Symbol section index */
 212   b_elf_addr    st_value;               /* Symbol value */
 213   b_elf_xword   st_size;                /* Symbol size */
 214 } b_elf_sym;  /* Elf_Sym.  */
 215
 216 #endif /* BACKTRACE_ELF_SIZE != 32 */
 217
 218 #define STT_FUNC 2
 219
 220 /* An index of ELF sections we care about.  */
 221
 222 enum debug_section
 223 {
 224   DEBUG_INFO,
 225   DEBUG_LINE,
 226   DEBUG_ABBREV,
 227   DEBUG_RANGES,
 228   DEBUG_STR,
 229   DEBUG_MAX
 230 };
 231
 232 /* Names of sections, indexed by enum elf_section.  */
 233
 234 static const char * const debug_section_names[DEBUG_MAX] =
 235 {
 236   ".debug_info",
 237   ".debug_line",
 238   ".debug_abbrev",
 239   ".debug_ranges",
 240   ".debug_str"
 241 };
 242
 243 /* Information we gather for the sections we care about.  */
 244
 245 struct debug_section_info
 246 {
 247   /* Section file offset.  */
 248   off_t offset;
 249   /* Section size.  */
 250   size_t size;
 251   /* Section contents, after read from file.  */
 252   const unsigned char *data;
 253 };
 254
 255 /* Information we keep for an ELF symbol.  */
 256
 257 struct elf_symbol
 258 {
 259   /* The name of the symbol.  */
 260   const char *name;
 261   /* The address of the symbol.  */
 262   uintptr_t address;
 263   /* The size of the symbol.  */
 264   size_t size;
 265 };
 266
 267 /* Information to pass to elf_syminfo.  */
 268
 269 struct elf_syminfo_data
 270 {
 271   /* Symbols for the next module.  */
 272   struct elf_syminfo_data *next;
 273   /* The ELF symbols, sorted by address.  */
 274   struct elf_symbol *symbols;
 275   /* The number of symbols.  */
 276   size_t count;
 277 };
 278
 279 /* A dummy callback function used when we can't find any debug info.  */
 280
 281 static int
 282 elf_nodebug (struct backtrace_state *state ATTRIBUTE_UNUSED,
 283              uintptr_t pc ATTRIBUTE_UNUSED,
 284              backtrace_full_callback callback ATTRIBUTE_UNUSED,
 285              backtrace_error_callback error_callback, void *data)
 286 {
 287   error_callback (data, "no debug info in ELF executable", -1);
 288   return 0;
 289 }
 290
 291 /* A dummy callback function used when we can't find a symbol
 292    table.  */
 293
 294 static void
 295 elf_nosyms (struct backtrace_state *state ATTRIBUTE_UNUSED,
 296             uintptr_t pc ATTRIBUTE_UNUSED,
 297             backtrace_syminfo_callback callback ATTRIBUTE_UNUSED,
 298             backtrace_error_callback error_callback, void *data)
 299 {
 300   error_callback (data, "no symbol table in ELF executable", -1);
 301 }
 302
 303 /* Compare struct elf_symbol for qsort.  */
 304
 305 static int
 306 elf_symbol_compare (const void *v1, const void *v2)
 307 {
 308   const struct elf_symbol *e1 = (const struct elf_symbol *) v1;
 309   const struct elf_symbol *e2 = (const struct elf_symbol *) v2;
 310
 311   if (e1->address < e2->address)
 312     return -1;
 313   else if (e1->address > e2->address)
 314     return 1;
 315   else
 316     return 0;
 317 }
 318
 319 /* Compare a PC against an elf_symbol for bsearch.  We allocate one
 320    extra entry in the array so that this can look safely at the next
 321    entry.  */
 322
 323 static int
 324 elf_symbol_search (const void *vkey, const void *ventry)
 325 {
 326   const uintptr_t *key = (const uintptr_t *) vkey;
 327   const struct elf_symbol *entry = (const struct elf_symbol *) ventry;
 328   uintptr_t pc;
 329
 330   pc = *key;
 331   if (pc < entry->address)
 332     return -1;
 333   else if (pc >= entry->address + entry->size)
 334     return 1;
 335   else
 336     return 0;
 337 }
 338
 339 /* Initialize the symbol table info for elf_syminfo.  */
 340
 341 static int
 342 elf_initialize_syminfo (struct backtrace_state *state,
 343                         const unsigned char *symtab_data, size_t symtab_size,
 344                         const unsigned char *strtab, size_t strtab_size,
 345                         backtrace_error_callback error_callback,
 346                         void *data, struct elf_syminfo_data *sdata)
 347 {
 348   size_t sym_count;
 349   const b_elf_sym *sym;
 350   size_t elf_symbol_count;
 351   size_t elf_symbol_size;
 352   struct elf_symbol *elf_symbols;
 353   size_t i;
 354   unsigned int j;
 355
 356   sym_count = symtab_size / sizeof (b_elf_sym);
 357
 358   /* We only care about function symbols.  Count them.  */
 359   sym = (const b_elf_sym *) symtab_data;
 360   elf_symbol_count = 0;
 361   for (i = 0; i < sym_count; ++i, ++sym)
 362     {
 363       if ((sym->st_info & 0xf) == STT_FUNC)
 364         ++elf_symbol_count;
 365     }
 366
 367   elf_symbol_size = elf_symbol_count * sizeof (struct elf_symbol);
 368   elf_symbols = ((struct elf_symbol *)
 369                  backtrace_alloc (state, elf_symbol_size, error_callback,
 370                                   data));
 371   if (elf_symbols == NULL)
 372     return 0;
 373
 374   sym = (const b_elf_sym *) symtab_data;
 375   j = 0;
 376   for (i = 0; i < sym_count; ++i, ++sym)
 377     {
 378       if ((sym->st_info & 0xf) != STT_FUNC)
 379         continue;
 380       if (sym->st_name >= strtab_size)
 381         {
 382           error_callback (data, "symbol string index out of range", 0);
 383           backtrace_free (state, elf_symbols, elf_symbol_size, error_callback,
 384                           data);
 385           return 0;
 386         }
 387       elf_symbols[j].name = (const char *) strtab + sym->st_name;
 388       elf_symbols[j].address = sym->st_value;
 389       elf_symbols[j].size = sym->st_size;
 390       ++j;
 391     }
 392
 393   qsort (elf_symbols, elf_symbol_count, sizeof (struct elf_symbol),
 394          elf_symbol_compare);
 395
 396   sdata->next = NULL;
 397   sdata->symbols = elf_symbols;
 398   sdata->count = elf_symbol_count;
 399
 400   return 1;
 401 }
 402
 403 /* Add EDATA to the list in STATE.  */
 404
 405 static void
 406 elf_add_syminfo_data (struct backtrace_state *state,
 407                       struct elf_syminfo_data *edata)
 408 {
 409   if (!state->threaded)
 410     {
 411       struct elf_syminfo_data **pp;
 412
 413       for (pp = (struct elf_syminfo_data **) (void *) &state->syminfo_data;
 414            *pp != NULL;
 415            pp = &(*pp)->next)
 416         ;
 417       *pp = edata;
 418     }
 419   else
 420     {
 421       while (1)
 422         {
 423           struct elf_syminfo_data **pp;
 424
 425           pp = (struct elf_syminfo_data **) (void *) &state->syminfo_data;
 426
 427           while (1)
 428             {
 429               struct elf_syminfo_data *p;
 430
 431               /* Atomic load.  */
 432               p = *pp;
 433               while (!__sync_bool_compare_and_swap (pp, p, p))
 434                 p = *pp;
 435
 436               if (p == NULL)
 437                 break;
 438
 439               pp = &p->next;
 440             }
 441
 442           if (__sync_bool_compare_and_swap (pp, NULL, edata))
 443             break;
 444         }
 445     }
 446 }
 447
 448 /* Return the symbol name and value for a PC.  */
 449
 450 static void
 451 elf_syminfo (struct backtrace_state *state, uintptr_t pc,
 452              backtrace_syminfo_callback callback,
 453              backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
 454              void *data)
 455 {
 456   struct elf_syminfo_data *edata;
 457   struct elf_symbol *sym;
 458
 459   edata = (struct elf_syminfo_data *) state->syminfo_data;
 460   sym = ((struct elf_symbol *)
 461          bsearch (&pc, edata->symbols, edata->count,
 462                   sizeof (struct elf_symbol), elf_symbol_search));
 463   if (sym == NULL)
 464     callback (data, pc, NULL, 0);
 465   else
 466     callback (data, pc, sym->name, sym->address);
 467 }
 468
 469 /* Add the backtrace data for one ELF file.  */
 470
 471 static int
 472 elf_add (struct backtrace_state *state, int descriptor, uintptr_t base_address,
 473          backtrace_error_callback error_callback, void *data,
 474          fileline *fileline_fn, int *found_sym, int *found_dwarf)
 475 {
 476   struct backtrace_view ehdr_view;
 477   b_elf_ehdr ehdr;
 478   off_t shoff;
 479   unsigned int shnum;
 480   unsigned int shstrndx;
 481   struct backtrace_view shdrs_view;
 482   int shdrs_view_valid;
 483   const b_elf_shdr *shdrs;
 484   const b_elf_shdr *shstrhdr;
 485   size_t shstr_size;
 486   off_t shstr_off;
 487   struct backtrace_view names_view;
 488   int names_view_valid;
 489   const char *names;
 490   unsigned int symtab_shndx;
 491   unsigned int dynsym_shndx;
 492   unsigned int i;
 493   struct debug_section_info sections[DEBUG_MAX];
 494   struct backtrace_view symtab_view;
 495   int symtab_view_valid;
 496   struct backtrace_view strtab_view;
 497   int strtab_view_valid;
 498   off_t min_offset;
 499   off_t max_offset;
 500   struct backtrace_view debug_view;
 501   int debug_view_valid;
 502
 503   *found_sym = 0;
 504   *found_dwarf = 0;
 505
 506   shdrs_view_valid = 0;
 507   names_view_valid = 0;
 508   symtab_view_valid = 0;
 509   strtab_view_valid = 0;
 510   debug_view_valid = 0;
 511
 512   if (!backtrace_get_view (state, descriptor, 0, sizeof ehdr, error_callback,
 513                            data, &ehdr_view))
 514     goto fail;
 515
 516   memcpy (&ehdr, ehdr_view.data, sizeof ehdr);
 517
 518   backtrace_release_view (state, &ehdr_view, error_callback, data);
 519
 520   if (ehdr.e_ident[EI_MAG0] != ELFMAG0
 521       || ehdr.e_ident[EI_MAG1] != ELFMAG1
 522       || ehdr.e_ident[EI_MAG2] != ELFMAG2
 523       || ehdr.e_ident[EI_MAG3] != ELFMAG3)
 524     {
 525       error_callback (data, "executable file is not ELF", 0);
 526       goto fail;
 527     }
 528   if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
 529     {
 530       error_callback (data, "executable file is unrecognized ELF version", 0);
 531       goto fail;
 532     }
 533
 534 #if BACKTRACE_ELF_SIZE == 32
 535 #define BACKTRACE_ELFCLASS ELFCLASS32
 536 #else
 537 #define BACKTRACE_ELFCLASS ELFCLASS64
 538 #endif
 539
 540   if (ehdr.e_ident[EI_CLASS] != BACKTRACE_ELFCLASS)
 541     {
 542       error_callback (data, "executable file is unexpected ELF class", 0);
 543       goto fail;
 544     }
 545
 546   if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB
 547       && ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
 548     {
 549       error_callback (data, "executable file has unknown endianness", 0);
 550       goto fail;
 551     }
 552
 553   shoff = ehdr.e_shoff;
 554   shnum = ehdr.e_shnum;
 555   shstrndx = ehdr.e_shstrndx;
 556
 557   if ((shnum == 0 || shstrndx == SHN_XINDEX)
 558       && shoff != 0)
 559     {
 560       struct backtrace_view shdr_view;
 561       const b_elf_shdr *shdr;
 562
 563       if (!backtrace_get_view (state, descriptor, shoff, sizeof shdr,
 564                                error_callback, data, &shdr_view))
 565         goto fail;
 566
 567       shdr = (const b_elf_shdr *) shdr_view.data;
 568
 569       if (shnum == 0)
 570         shnum = shdr->sh_size;
 571
 572       if (shstrndx == SHN_XINDEX)
 573         {
 574           shstrndx = shdr->sh_link;
 575
 576           /* Versions of the GNU binutils between 2.12 and 2.18 did
 577              not handle objects with more than SHN_LORESERVE sections
 578              correctly.  All large section indexes were offset by
 579              0x100.  There is more information at
 580              http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
 581              Fortunately these object files are easy to detect, as the
 582              GNU binutils always put the section header string table
 583              near the end of the list of sections.  Thus if the
 584              section header string table index is larger than the
 585              number of sections, then we know we have to subtract
 586              0x100 to get the real section index.  */
 587           if (shstrndx >= shnum && shstrndx >= SHN_LORESERVE + 0x100)
 588             shstrndx -= 0x100;
 589         }
 590
 591       backtrace_release_view (state, &shdr_view, error_callback, data);
 592     }
 593
 594   /* To translate PC to file/line when using DWARF, we need to find
 595      the .debug_info and .debug_line sections.  */
 596
 597   /* Read the section headers, skipping the first one.  */
 598
 599   if (!backtrace_get_view (state, descriptor, shoff + sizeof (b_elf_shdr),
 600                            (shnum - 1) * sizeof (b_elf_shdr),
 601                            error_callback, data, &shdrs_view))
 602     goto fail;
 603   shdrs_view_valid = 1;
 604   shdrs = (const b_elf_shdr *) shdrs_view.data;
 605
 606   /* Read the section names.  */
 607
 608   shstrhdr = &shdrs[shstrndx - 1];
 609   shstr_size = shstrhdr->sh_size;
 610   shstr_off = shstrhdr->sh_offset;
 611
 612   if (!backtrace_get_view (state, descriptor, shstr_off, shstr_size,
 613                            error_callback, data, &names_view))
 614     goto fail;
 615   names_view_valid = 1;
 616   names = (const char *) names_view.data;
 617
 618   symtab_shndx = 0;
 619   dynsym_shndx = 0;
 620
 621   memset (sections, 0, sizeof sections);
 622
 623   /* Look for the symbol table.  */
 624   for (i = 1; i < shnum; ++i)
 625     {
 626       const b_elf_shdr *shdr;
 627       unsigned int sh_name;
 628       const char *name;
 629       int j;
 630
 631       shdr = &shdrs[i - 1];
 632
 633       if (shdr->sh_type == SHT_SYMTAB)
 634         symtab_shndx = i;
 635       else if (shdr->sh_type == SHT_DYNSYM)
 636         dynsym_shndx = i;
 637
 638       sh_name = shdr->sh_name;
 639       if (sh_name >= shstr_size)
 640         {
 641           error_callback (data, "ELF section name out of range", 0);
 642           goto fail;
 643         }
 644
 645       name = names + sh_name;
 646
 647       for (j = 0; j < (int) DEBUG_MAX; ++j)
 648         {
 649           if (strcmp (name, debug_section_names[j]) == 0)
 650             {
 651               sections[j].offset = shdr->sh_offset;
 652               sections[j].size = shdr->sh_size;
 653               break;
 654             }
 655         }
 656     }
 657
 658   if (symtab_shndx == 0)
 659     symtab_shndx = dynsym_shndx;
 660   if (symtab_shndx != 0)
 661     {
 662       const b_elf_shdr *symtab_shdr;
 663       unsigned int strtab_shndx;
 664       const b_elf_shdr *strtab_shdr;
 665       struct elf_syminfo_data *sdata;
 666
 667       symtab_shdr = &shdrs[symtab_shndx - 1];
 668       strtab_shndx = symtab_shdr->sh_link;
 669       if (strtab_shndx >= shnum)
 670         {
 671           error_callback (data,
 672                           "ELF symbol table strtab link out of range", 0);
 673           goto fail;
 674         }
 675       strtab_shdr = &shdrs[strtab_shndx - 1];
 676
 677       if (!backtrace_get_view (state, descriptor, symtab_shdr->sh_offset,
 678                                symtab_shdr->sh_size, error_callback, data,
 679                                &symtab_view))
 680         goto fail;
 681       symtab_view_valid = 1;
 682
 683       if (!backtrace_get_view (state, descriptor, strtab_shdr->sh_offset,
 684                                strtab_shdr->sh_size, error_callback, data,
 685                                &strtab_view))
 686         goto fail;
 687       strtab_view_valid = 1;
 688
 689       sdata = ((struct elf_syminfo_data *)
 690                backtrace_alloc (state, sizeof *sdata, error_callback, data));
 691       if (sdata == NULL)
 692         goto fail;
 693
 694       if (!elf_initialize_syminfo (state,
 695                                    symtab_view.data, symtab_shdr->sh_size,
 696                                    strtab_view.data, strtab_shdr->sh_size,
 697                                    error_callback, data, sdata))
 698         {
 699           backtrace_free (state, sdata, sizeof *sdata, error_callback, data);
 700           goto fail;
 701         }
 702
 703       /* We no longer need the symbol table, but we hold on to the
 704          string table permanently.  */
 705       backtrace_release_view (state, &symtab_view, error_callback, data);
 706
 707       *found_sym = 1;
 708
 709       elf_add_syminfo_data (state, sdata);
 710     }
 711
 712   /* FIXME: Need to handle compressed debug sections.  */
 713
 714   backtrace_release_view (state, &shdrs_view, error_callback, data);
 715   shdrs_view_valid = 0;
 716   backtrace_release_view (state, &names_view, error_callback, data);
 717   names_view_valid = 0;
 718
 719   /* Read all the debug sections in a single view, since they are
 720      probably adjacent in the file.  We never release this view.  */
 721
 722   min_offset = 0;
 723   max_offset = 0;
 724   for (i = 0; i < (int) DEBUG_MAX; ++i)
 725     {
 726       off_t end;
 727
 728       if (min_offset == 0 || sections[i].offset < min_offset)
 729         min_offset = sections[i].offset;
 730       end = sections[i].offset + sections[i].size;
 731       if (end > max_offset)
 732         max_offset = end;
 733     }
 734   if (min_offset == 0 || max_offset == 0)
 735     {
 736       if (!backtrace_close (descriptor, error_callback, data))
 737         goto fail;
 738       *fileline_fn = elf_nodebug;
 739       return 1;
 740     }
 741
 742   if (!backtrace_get_view (state, descriptor, min_offset,
 743                            max_offset - min_offset,
 744                            error_callback, data, &debug_view))
 745     goto fail;
 746   debug_view_valid = 1;
 747
 748   /* We've read all we need from the executable.  */
 749   if (!backtrace_close (descriptor, error_callback, data))
 750     goto fail;
 751   descriptor = -1;
 752
 753   for (i = 0; i < (int) DEBUG_MAX; ++i)
 754     sections[i].data = ((const unsigned char *) debug_view.data
 755                         + (sections[i].offset - min_offset));
 756
 757   if (!backtrace_dwarf_add (state, base_address,
 758                             sections[DEBUG_INFO].data,
 759                             sections[DEBUG_INFO].size,
 760                             sections[DEBUG_LINE].data,
 761                             sections[DEBUG_LINE].size,
 762                             sections[DEBUG_ABBREV].data,
 763                             sections[DEBUG_ABBREV].size,
 764                             sections[DEBUG_RANGES].data,
 765                             sections[DEBUG_RANGES].size,
 766                             sections[DEBUG_STR].data,
 767                             sections[DEBUG_STR].size,
 768                             ehdr.e_ident[EI_DATA] == ELFDATA2MSB,
 769                             error_callback, data, fileline_fn))
 770     goto fail;
 771
 772   *found_dwarf = 1;
 773
 774   return 1;
 775
 776  fail:
 777   if (shdrs_view_valid)
 778     backtrace_release_view (state, &shdrs_view, error_callback, data);
 779   if (names_view_valid)
 780     backtrace_release_view (state, &names_view, error_callback, data);
 781   if (symtab_view_valid)
 782     backtrace_release_view (state, &symtab_view, error_callback, data);
 783   if (strtab_view_valid)
 784     backtrace_release_view (state, &strtab_view, error_callback, data);
 785   if (debug_view_valid)
 786     backtrace_release_view (state, &debug_view, error_callback, data);
 787   if (descriptor != -1)
 788     backtrace_close (descriptor, error_callback, data);
 789   return 0;
 790 }
 791
 792 /* Data passed to phdr_callback.  */
 793
 794 struct phdr_data
 795 {
 796   struct backtrace_state *state;
 797   backtrace_error_callback error_callback;
 798   void *data;
 799   fileline *fileline_fn;
 800   int *found_sym;
 801   int *found_dwarf;
 802 };
 803
 804 /* Callback passed to dl_iterate_phdr.  Load debug info from shared
 805    libraries.  */
 806
 807 static int
 808 phdr_callback (struct dl_phdr_info *info, size_t size ATTRIBUTE_UNUSED,
 809                void *pdata)
 810 {
 811   struct phdr_data *pd = (struct phdr_data *) pdata;
 812   int descriptor;
 813   int does_not_exist;
 814   fileline elf_fileline_fn;
 815   int found_dwarf;
 816
 817   /* There is not much we can do if we don't have the module name.  If
 818      the base address is 0, this is probably the executable, which we
 819      already loaded.  */
 820   if (info->dlpi_name == NULL
 821       || info->dlpi_name[0] == '\0'
 822       || info->dlpi_addr == 0)
 823     return 0;
 824
 825   descriptor = backtrace_open (info->dlpi_name, pd->error_callback, pd->data,
 826                                &does_not_exist);
 827   if (descriptor < 0)
 828     return 0;
 829
 830   if (elf_add (pd->state, descriptor, info->dlpi_addr, pd->error_callback,
 831                pd->data, &elf_fileline_fn, pd->found_sym, &found_dwarf))
 832     {
 833       if (found_dwarf)
 834         {
 835           *pd->found_dwarf = 1;
 836           *pd->fileline_fn = elf_fileline_fn;
 837         }
 838     }
 839
 840   return 0;
 841 }
 842
 843 /* Initialize the backtrace data we need from an ELF executable.  At
 844    the ELF level, all we need to do is find the debug info
 845    sections.  */
 846
 847 int
 848 backtrace_initialize (struct backtrace_state *state, int descriptor,
 849                       backtrace_error_callback error_callback,
 850                       void *data, fileline *fileline_fn)
 851 {
 852   int found_sym;
 853   int found_dwarf;
 854   syminfo elf_syminfo_fn;
 855   fileline elf_fileline_fn;
 856   struct phdr_data pd;
 857
 858   if (!elf_add (state, descriptor, 0, error_callback, data, &elf_fileline_fn,
 859                 &found_sym, &found_dwarf))
 860     return 0;
 861
 862   pd.state = state;
 863   pd.error_callback = error_callback;
 864   pd.data = data;
 865   pd.fileline_fn = fileline_fn;
 866   pd.found_sym = &found_sym;
 867   pd.found_dwarf = &found_dwarf;
 868
 869   dl_iterate_phdr (phdr_callback, (void *) &pd);
 870
 871   elf_syminfo_fn = found_sym ? elf_syminfo : elf_nosyms;
 872   if (!state->threaded)
 873     {
 874       if (state->syminfo_fn == NULL || found_sym)
 875         state->syminfo_fn = elf_syminfo_fn;
 876     }
 877   else
 878     {
 879       __sync_bool_compare_and_swap (&state->syminfo_fn, NULL, elf_syminfo_fn);
 880       if (found_sym)
 881         __sync_bool_compare_and_swap (&state->syminfo_fn, elf_nosyms,
 882                                       elf_syminfo_fn);
 883     }
 884
 885   if (!state->threaded)
 886     {
 887       if (state->fileline_fn == NULL || state->fileline_fn == elf_nodebug)
 888         *fileline_fn = elf_fileline_fn;
 889     }
 890   else
 891     {
 892       fileline current_fn;
 893
 894       /* Atomic load.  */
 895       current_fn = state->fileline_fn;
 896       while (!__sync_bool_compare_and_swap (&state->fileline_fn, current_fn,
 897                                             current_fn))
 898         current_fn = state->fileline_fn;
 899       if (current_fn == NULL || current_fn == elf_nodebug)
 900         *fileline_fn = elf_fileline_fn;
 901     }
 902
 903   return 1;
 904 }