gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2
   3    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   4    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   5    Free Software Foundation, Inc.
   6
   7    Written by Fred Fish at Cygnus Support.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "bfd.h"
  26 #include "gdb_string.h"
  27 #include "elf-bfd.h"
  28 #include "elf/common.h"
  29 #include "elf/internal.h"
  30 #include "elf/mips.h"
  31 #include "symtab.h"
  32 #include "symfile.h"
  33 #include "objfiles.h"
  34 #include "buildsym.h"
  35 #include "stabsread.h"
  36 #include "gdb-stabs.h"
  37 #include "complaints.h"
  38 #include "demangle.h"
  39
  40 extern void _initialize_elfread (void);
  41
  42 /* The struct elfinfo is available only during ELF symbol table and
  43    psymtab reading.  It is destroyed at the completion of psymtab-reading.
  44    It's local to elf_symfile_read.  */
  45
  46 struct elfinfo
  47   {
  48     asection *stabsect;         /* Section pointer for .stab section */
  49     asection *stabindexsect;    /* Section pointer for .stab.index section */
  50     asection *mdebugsect;       /* Section pointer for .mdebug section */
  51   };
  52
  53 static void free_elfinfo (void *);
  54
  55 /* Locate the segments in ABFD.  */
  56
  57 static struct symfile_segment_data *
  58 elf_symfile_segments (bfd *abfd)
  59 {
  60   Elf_Internal_Phdr *phdrs, **segments;
  61   long phdrs_size;
  62   int num_phdrs, num_segments, num_sections, i;
  63   asection *sect;
  64   struct symfile_segment_data *data;
  65
  66   phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
  67   if (phdrs_size == -1)
  68     return NULL;
  69
  70   phdrs = alloca (phdrs_size);
  71   num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
  72   if (num_phdrs == -1)
  73     return NULL;
  74
  75   num_segments = 0;
  76   segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
  77   for (i = 0; i < num_phdrs; i++)
  78     if (phdrs[i].p_type == PT_LOAD)
  79       segments[num_segments++] = &phdrs[i];
  80
  81   if (num_segments == 0)
  82     return NULL;
  83
  84   data = XZALLOC (struct symfile_segment_data);
  85   data->num_segments = num_segments;
  86   data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
  87   data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
  88
  89   for (i = 0; i < num_segments; i++)
  90     {
  91       data->segment_bases[i] = segments[i]->p_vaddr;
  92       data->segment_sizes[i] = segments[i]->p_memsz;
  93     }
  94
  95   num_sections = bfd_count_sections (abfd);
  96   data->segment_info = XCALLOC (num_sections, int);
  97
  98   for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
  99     {
 100       int j;
 101       CORE_ADDR vma;
 102
 103       if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
 104         continue;
 105
 106       vma = bfd_get_section_vma (abfd, sect);
 107
 108       for (j = 0; j < num_segments; j++)
 109         if (segments[j]->p_memsz > 0
 110             && vma >= segments[j]->p_vaddr
 111             && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
 112           {
 113             data->segment_info[i] = j + 1;
 114             break;
 115           }
 116
 117       /* We should have found a segment for every non-empty section.
 118          If we haven't, we will not relocate this section by any
 119          offsets we apply to the segments.  As an exception, do not
 120          warn about SHT_NOBITS sections; in normal ELF execution
 121          environments, SHT_NOBITS means zero-initialized and belongs
 122          in a segment, but in no-OS environments some tools (e.g. ARM
 123          RealView) use SHT_NOBITS for uninitialized data.  Since it is
 124          uninitialized, it doesn't need a program header.  Such
 125          binaries are not relocatable.  */
 126       if (bfd_get_section_size (sect) > 0 && j == num_segments
 127           && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
 128         warning (_("Loadable segment \"%s\" outside of ELF segments"),
 129                  bfd_section_name (abfd, sect));
 130     }
 131
 132   return data;
 133 }
 134
 135 /* We are called once per section from elf_symfile_read.  We
 136    need to examine each section we are passed, check to see
 137    if it is something we are interested in processing, and
 138    if so, stash away some access information for the section.
 139
 140    For now we recognize the dwarf debug information sections and
 141    line number sections from matching their section names.  The
 142    ELF definition is no real help here since it has no direct
 143    knowledge of DWARF (by design, so any debugging format can be
 144    used).
 145
 146    We also recognize the ".stab" sections used by the Sun compilers
 147    released with Solaris 2.
 148
 149    FIXME: The section names should not be hardwired strings (what
 150    should they be?  I don't think most object file formats have enough
 151    section flags to specify what kind of debug section it is
 152    -kingdon).  */
 153
 154 static void
 155 elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
 156 {
 157   struct elfinfo *ei;
 158
 159   ei = (struct elfinfo *) eip;
 160   if (strcmp (sectp->name, ".stab") == 0)
 161     {
 162       ei->stabsect = sectp;
 163     }
 164   else if (strcmp (sectp->name, ".stab.index") == 0)
 165     {
 166       ei->stabindexsect = sectp;
 167     }
 168   else if (strcmp (sectp->name, ".mdebug") == 0)
 169     {
 170       ei->mdebugsect = sectp;
 171     }
 172 }
 173
 174 static struct minimal_symbol *
 175 record_minimal_symbol (const char *name, int name_len, int copy_name,
 176                        CORE_ADDR address,
 177                        enum minimal_symbol_type ms_type,
 178                        asection *bfd_section, struct objfile *objfile)
 179 {
 180   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 181
 182   if (ms_type == mst_text || ms_type == mst_file_text)
 183     address = gdbarch_smash_text_address (gdbarch, address);
 184
 185   return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
 186                                           ms_type, bfd_section->index,
 187                                           bfd_section, objfile);
 188 }
 189
 190 /*
 191
 192    LOCAL FUNCTION
 193
 194    elf_symtab_read -- read the symbol table of an ELF file
 195
 196    SYNOPSIS
 197
 198    void elf_symtab_read (struct objfile *objfile, int type,
 199                          long number_of_symbols, asymbol **symbol_table)
 200
 201    DESCRIPTION
 202
 203    Given an objfile, a symbol table, and a flag indicating whether the
 204    symbol table contains regular, dynamic, or synthetic symbols, add all
 205    the global function and data symbols to the minimal symbol table.
 206
 207    In stabs-in-ELF, as implemented by Sun, there are some local symbols
 208    defined in the ELF symbol table, which can be used to locate
 209    the beginnings of sections from each ".o" file that was linked to
 210    form the executable objfile.  We gather any such info and record it
 211    in data structures hung off the objfile's private data.
 212
 213  */
 214
 215 #define ST_REGULAR 0
 216 #define ST_DYNAMIC 1
 217 #define ST_SYNTHETIC 2
 218
 219 static void
 220 elf_symtab_read (struct objfile *objfile, int type,
 221                  long number_of_symbols, asymbol **symbol_table,
 222                  int copy_names)
 223 {
 224   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 225   long storage_needed;
 226   asymbol *sym;
 227   long i;
 228   CORE_ADDR symaddr;
 229   CORE_ADDR offset;
 230   enum minimal_symbol_type ms_type;
 231   /* If sectinfo is nonNULL, it contains section info that should end up
 232      filed in the objfile.  */
 233   struct stab_section_info *sectinfo = NULL;
 234   /* If filesym is nonzero, it points to a file symbol, but we haven't
 235      seen any section info for it yet.  */
 236   asymbol *filesym = 0;
 237   /* Name of filesym.  This is either a constant string or is saved on
 238      the objfile's obstack.  */
 239   char *filesymname = "";
 240   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 241   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 242
 243   for (i = 0; i < number_of_symbols; i++)
 244     {
 245       sym = symbol_table[i];
 246       if (sym->name == NULL || *sym->name == '\0')
 247         {
 248           /* Skip names that don't exist (shouldn't happen), or names
 249              that are null strings (may happen). */
 250           continue;
 251         }
 252
 253       /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
 254          symbols which do not correspond to objects in the symbol table,
 255          but have some other target-specific meaning.  */
 256       if (bfd_is_target_special_symbol (objfile->obfd, sym))
 257         {
 258           if (gdbarch_record_special_symbol_p (gdbarch))
 259             gdbarch_record_special_symbol (gdbarch, objfile, sym);
 260           continue;
 261         }
 262
 263       offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 264       if (type == ST_DYNAMIC
 265           && sym->section == &bfd_und_section
 266           && (sym->flags & BSF_FUNCTION))
 267         {
 268           struct minimal_symbol *msym;
 269           bfd *abfd = objfile->obfd;
 270           asection *sect;
 271
 272           /* Symbol is a reference to a function defined in
 273              a shared library.
 274              If its value is non zero then it is usually the address
 275              of the corresponding entry in the procedure linkage table,
 276              plus the desired section offset.
 277              If its value is zero then the dynamic linker has to resolve
 278              the symbol. We are unable to find any meaningful address
 279              for this symbol in the executable file, so we skip it.  */
 280           symaddr = sym->value;
 281           if (symaddr == 0)
 282             continue;
 283
 284           /* sym->section is the undefined section.  However, we want to
 285              record the section where the PLT stub resides with the
 286              minimal symbol.  Search the section table for the one that
 287              covers the stub's address.  */
 288           for (sect = abfd->sections; sect != NULL; sect = sect->next)
 289             {
 290               if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
 291                 continue;
 292
 293               if (symaddr >= bfd_get_section_vma (abfd, sect)
 294                   && symaddr < bfd_get_section_vma (abfd, sect)
 295                                + bfd_get_section_size (sect))
 296                 break;
 297             }
 298           if (!sect)
 299             continue;
 300
 301           symaddr += ANOFFSET (objfile->section_offsets, sect->index);
 302
 303           msym = record_minimal_symbol
 304             (sym->name, strlen (sym->name), copy_names,
 305              symaddr, mst_solib_trampoline, sect, objfile);
 306           if (msym != NULL)
 307             msym->filename = filesymname;
 308           continue;
 309         }
 310
 311       /* If it is a nonstripped executable, do not enter dynamic
 312          symbols, as the dynamic symbol table is usually a subset
 313          of the main symbol table.  */
 314       if (type == ST_DYNAMIC && !stripped)
 315         continue;
 316       if (sym->flags & BSF_FILE)
 317         {
 318           /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 319              Chain any old one onto the objfile; remember new sym.  */
 320           if (sectinfo != NULL)
 321             {
 322               sectinfo->next = dbx->stab_section_info;
 323               dbx->stab_section_info = sectinfo;
 324               sectinfo = NULL;
 325             }
 326           filesym = sym;
 327           filesymname =
 328             obsavestring ((char *) filesym->name, strlen (filesym->name),
 329                           &objfile->objfile_obstack);
 330         }
 331       else if (sym->flags & BSF_SECTION_SYM)
 332         continue;
 333       else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 334         {
 335           struct minimal_symbol *msym;
 336
 337           /* Select global/local/weak symbols.  Note that bfd puts abs
 338              symbols in their own section, so all symbols we are
 339              interested in will have a section. */
 340           /* Bfd symbols are section relative. */
 341           symaddr = sym->value + sym->section->vma;
 342           /* Relocate all non-absolute and non-TLS symbols by the
 343              section offset.  */
 344           if (sym->section != &bfd_abs_section
 345               && !(sym->section->flags & SEC_THREAD_LOCAL))
 346             {
 347               symaddr += offset;
 348             }
 349           /* For non-absolute symbols, use the type of the section
 350              they are relative to, to intuit text/data.  Bfd provides
 351              no way of figuring this out for absolute symbols. */
 352           if (sym->section == &bfd_abs_section)
 353             {
 354               /* This is a hack to get the minimal symbol type
 355                  right for Irix 5, which has absolute addresses
 356                  with special section indices for dynamic symbols.
 357
 358                  NOTE: uweigand-20071112: Synthetic symbols do not
 359                  have an ELF-private part, so do not touch those.  */
 360               unsigned int shndx = type == ST_SYNTHETIC ? 0 :
 361                 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 362
 363               switch (shndx)
 364                 {
 365                 case SHN_MIPS_TEXT:
 366                   ms_type = mst_text;
 367                   break;
 368                 case SHN_MIPS_DATA:
 369                   ms_type = mst_data;
 370                   break;
 371                 case SHN_MIPS_ACOMMON:
 372                   ms_type = mst_bss;
 373                   break;
 374                 default:
 375                   ms_type = mst_abs;
 376                 }
 377
 378               /* If it is an Irix dynamic symbol, skip section name
 379                  symbols, relocate all others by section offset. */
 380               if (ms_type != mst_abs)
 381                 {
 382                   if (sym->name[0] == '.')
 383                     continue;
 384                   symaddr += offset;
 385                 }
 386             }
 387           else if (sym->section->flags & SEC_CODE)
 388             {
 389               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 390                 {
 391                   ms_type = mst_text;
 392                 }
 393               else if ((sym->name[0] == '.' && sym->name[1] == 'L')
 394                        || ((sym->flags & BSF_LOCAL)
 395                            && sym->name[0] == '$'
 396                            && sym->name[1] == 'L'))
 397                 /* Looks like a compiler-generated label.  Skip
 398                    it.  The assembler should be skipping these (to
 399                    keep executables small), but apparently with
 400                    gcc on the (deleted) delta m88k SVR4, it loses.
 401                    So to have us check too should be harmless (but
 402                    I encourage people to fix this in the assembler
 403                    instead of adding checks here).  */
 404                 continue;
 405               else
 406                 {
 407                   ms_type = mst_file_text;
 408                 }
 409             }
 410           else if (sym->section->flags & SEC_ALLOC)
 411             {
 412               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 413                 {
 414                   if (sym->section->flags & SEC_LOAD)
 415                     {
 416                       ms_type = mst_data;
 417                     }
 418                   else
 419                     {
 420                       ms_type = mst_bss;
 421                     }
 422                 }
 423               else if (sym->flags & BSF_LOCAL)
 424                 {
 425                   /* Named Local variable in a Data section.
 426                      Check its name for stabs-in-elf.  */
 427                   int special_local_sect;
 428                   if (strcmp ("Bbss.bss", sym->name) == 0)
 429                     special_local_sect = SECT_OFF_BSS (objfile);
 430                   else if (strcmp ("Ddata.data", sym->name) == 0)
 431                     special_local_sect = SECT_OFF_DATA (objfile);
 432                   else if (strcmp ("Drodata.rodata", sym->name) == 0)
 433                     special_local_sect = SECT_OFF_RODATA (objfile);
 434                   else
 435                     special_local_sect = -1;
 436                   if (special_local_sect >= 0)
 437                     {
 438                       /* Found a special local symbol.  Allocate a
 439                          sectinfo, if needed, and fill it in.  */
 440                       if (sectinfo == NULL)
 441                         {
 442                           int max_index;
 443                           size_t size;
 444
 445                           max_index = SECT_OFF_BSS (objfile);
 446                           if (objfile->sect_index_data > max_index)
 447                             max_index = objfile->sect_index_data;
 448                           if (objfile->sect_index_rodata > max_index)
 449                             max_index = objfile->sect_index_rodata;
 450
 451                           /* max_index is the largest index we'll
 452                              use into this array, so we must
 453                              allocate max_index+1 elements for it.
 454                              However, 'struct stab_section_info'
 455                              already includes one element, so we
 456                              need to allocate max_index aadditional
 457                              elements.  */
 458                           size = (sizeof (struct stab_section_info)
 459                                   + (sizeof (CORE_ADDR)
 460                                      * max_index));
 461                           sectinfo = (struct stab_section_info *)
 462                             xmalloc (size);
 463                           memset (sectinfo, 0, size);
 464                           sectinfo->num_sections = max_index;
 465                           if (filesym == NULL)
 466                             {
 467                               complaint (&symfile_complaints,
 468                                          _("elf/stab section information %s without a preceding file symbol"),
 469                                          sym->name);
 470                             }
 471                           else
 472                             {
 473                               sectinfo->filename =
 474                                 (char *) filesym->name;
 475                             }
 476                         }
 477                       if (sectinfo->sections[special_local_sect] != 0)
 478                         complaint (&symfile_complaints,
 479                                    _("duplicated elf/stab section information for %s"),
 480                                    sectinfo->filename);
 481                       /* BFD symbols are section relative.  */
 482                       symaddr = sym->value + sym->section->vma;
 483                       /* Relocate non-absolute symbols by the
 484                          section offset.  */
 485                       if (sym->section != &bfd_abs_section)
 486                         symaddr += offset;
 487                       sectinfo->sections[special_local_sect] = symaddr;
 488                       /* The special local symbols don't go in the
 489                          minimal symbol table, so ignore this one.  */
 490                       continue;
 491                     }
 492                   /* Not a special stabs-in-elf symbol, do regular
 493                      symbol processing.  */
 494                   if (sym->section->flags & SEC_LOAD)
 495                     {
 496                       ms_type = mst_file_data;
 497                     }
 498                   else
 499                     {
 500                       ms_type = mst_file_bss;
 501                     }
 502                 }
 503               else
 504                 {
 505                   ms_type = mst_unknown;
 506                 }
 507             }
 508           else
 509             {
 510               /* FIXME:  Solaris2 shared libraries include lots of
 511                  odd "absolute" and "undefined" symbols, that play
 512                  hob with actions like finding what function the PC
 513                  is in.  Ignore them if they aren't text, data, or bss.  */
 514               /* ms_type = mst_unknown; */
 515               continue; /* Skip this symbol. */
 516             }
 517           msym = record_minimal_symbol
 518             (sym->name, strlen (sym->name), copy_names, symaddr,
 519              ms_type, sym->section, objfile);
 520
 521           if (msym)
 522             {
 523               /* Pass symbol size field in via BFD.  FIXME!!!  */
 524               elf_symbol_type *elf_sym;
 525
 526               /* NOTE: uweigand-20071112: A synthetic symbol does not have an
 527                  ELF-private part.  However, in some cases (e.g. synthetic
 528                  'dot' symbols on ppc64) the udata.p entry is set to point back
 529                  to the original ELF symbol it was derived from.  Get the size
 530                  from that symbol.  */
 531               if (type != ST_SYNTHETIC)
 532                 elf_sym = (elf_symbol_type *) sym;
 533               else
 534                 elf_sym = (elf_symbol_type *) sym->udata.p;
 535
 536               if (elf_sym)
 537                 MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
 538
 539               msym->filename = filesymname;
 540               gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
 541             }
 542
 543           /* For @plt symbols, also record a trampoline to the
 544              destination symbol.  The @plt symbol will be used in
 545              disassembly, and the trampoline will be used when we are
 546              trying to find the target.  */
 547           if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
 548             {
 549               int len = strlen (sym->name);
 550
 551               if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
 552                 {
 553                   struct minimal_symbol *mtramp;
 554
 555                   mtramp = record_minimal_symbol (sym->name, len - 4, 1,
 556                                                   symaddr,
 557                                                   mst_solib_trampoline,
 558                                                   sym->section, objfile);
 559                   if (mtramp)
 560                     {
 561                       MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
 562                       mtramp->filename = filesymname;
 563                       gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
 564                     }
 565                 }
 566             }
 567         }
 568     }
 569 }
 570
 571 struct build_id
 572   {
 573     size_t size;
 574     gdb_byte data[1];
 575   };
 576
 577 /* Locate NT_GNU_BUILD_ID from ABFD and return its content.  */
 578
 579 static struct build_id *
 580 build_id_bfd_get (bfd *abfd)
 581 {
 582   struct build_id *retval;
 583
 584   if (!bfd_check_format (abfd, bfd_object)
 585       || bfd_get_flavour (abfd) != bfd_target_elf_flavour
 586       || elf_tdata (abfd)->build_id == NULL)
 587     return NULL;
 588
 589   retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
 590   retval->size = elf_tdata (abfd)->build_id_size;
 591   memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
 592
 593   return retval;
 594 }
 595
 596 /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value.  */
 597
 598 static int
 599 build_id_verify (const char *filename, struct build_id *check)
 600 {
 601   bfd *abfd;
 602   struct build_id *found = NULL;
 603   int retval = 0;
 604
 605   /* We expect to be silent on the non-existing files.  */
 606   abfd = bfd_open_maybe_remote (filename);
 607   if (abfd == NULL)
 608     return 0;
 609
 610   found = build_id_bfd_get (abfd);
 611
 612   if (found == NULL)
 613     warning (_("File \"%s\" has no build-id, file skipped"), filename);
 614   else if (found->size != check->size
 615            || memcmp (found->data, check->data, found->size) != 0)
 616     warning (_("File \"%s\" has a different build-id, file skipped"), filename);
 617   else
 618     retval = 1;
 619
 620   if (!bfd_close (abfd))
 621     warning (_("cannot close \"%s\": %s"), filename,
 622              bfd_errmsg (bfd_get_error ()));
 623
 624   xfree (found);
 625
 626   return retval;
 627 }
 628
 629 static char *
 630 build_id_to_debug_filename (struct build_id *build_id)
 631 {
 632   char *link, *debugdir, *retval = NULL;
 633
 634   /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
 635   link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
 636                  + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
 637
 638   /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
 639      cause "/.build-id/..." lookups.  */
 640
 641   debugdir = debug_file_directory;
 642   do
 643     {
 644       char *s, *debugdir_end;
 645       gdb_byte *data = build_id->data;
 646       size_t size = build_id->size;
 647
 648       while (*debugdir == DIRNAME_SEPARATOR)
 649         debugdir++;
 650
 651       debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
 652       if (debugdir_end == NULL)
 653         debugdir_end = &debugdir[strlen (debugdir)];
 654
 655       memcpy (link, debugdir, debugdir_end - debugdir);
 656       s = &link[debugdir_end - debugdir];
 657       s += sprintf (s, "/.build-id/");
 658       if (size > 0)
 659         {
 660           size--;
 661           s += sprintf (s, "%02x", (unsigned) *data++);
 662         }
 663       if (size > 0)
 664         *s++ = '/';
 665       while (size-- > 0)
 666         s += sprintf (s, "%02x", (unsigned) *data++);
 667       strcpy (s, ".debug");
 668
 669       /* lrealpath() is expensive even for the usually non-existent files.  */
 670       if (access (link, F_OK) == 0)
 671         retval = lrealpath (link);
 672
 673       if (retval != NULL && !build_id_verify (retval, build_id))
 674         {
 675           xfree (retval);
 676           retval = NULL;
 677         }
 678
 679       if (retval != NULL)
 680         break;
 681
 682       debugdir = debugdir_end;
 683     }
 684   while (*debugdir != 0);
 685
 686   return retval;
 687 }
 688
 689 static char *
 690 find_separate_debug_file_by_buildid (struct objfile *objfile)
 691 {
 692   asection *sect;
 693   char *basename, *name_copy, *debugdir;
 694   char *dir = NULL;
 695   char *debugfile = NULL;
 696   char *canon_name = NULL;
 697   bfd_size_type debuglink_size;
 698   unsigned long crc32;
 699   int i;
 700   struct build_id *build_id;
 701
 702   build_id = build_id_bfd_get (objfile->obfd);
 703   if (build_id != NULL)
 704     {
 705       char *build_id_name;
 706
 707       build_id_name = build_id_to_debug_filename (build_id);
 708       xfree (build_id);
 709       /* Prevent looping on a stripped .debug file.  */
 710       if (build_id_name != NULL && strcmp (build_id_name, objfile->name) == 0)
 711         {
 712           warning (_("\"%s\": separate debug info file has no debug info"),
 713                    build_id_name);
 714           xfree (build_id_name);
 715         }
 716       else if (build_id_name != NULL)
 717         return build_id_name;
 718     }
 719   return NULL;
 720 }
 721
 722 /* Scan and build partial symbols for a symbol file.
 723    We have been initialized by a call to elf_symfile_init, which
 724    currently does nothing.
 725
 726    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 727    in each section.  We simplify it down to a single offset for all
 728    symbols.  FIXME.
 729
 730    This function only does the minimum work necessary for letting the
 731    user "name" things symbolically; it does not read the entire symtab.
 732    Instead, it reads the external and static symbols and puts them in partial
 733    symbol tables.  When more extensive information is requested of a
 734    file, the corresponding partial symbol table is mutated into a full
 735    fledged symbol table by going back and reading the symbols
 736    for real.
 737
 738    We look for sections with specific names, to tell us what debug
 739    format to look for:  FIXME!!!
 740
 741    elfstab_build_psymtabs() handles STABS symbols;
 742    mdebug_build_psymtabs() handles ECOFF debugging information.
 743
 744    Note that ELF files have a "minimal" symbol table, which looks a lot
 745    like a COFF symbol table, but has only the minimal information necessary
 746    for linking.  We process this also, and use the information to
 747    build gdb's minimal symbol table.  This gives us some minimal debugging
 748    capability even for files compiled without -g.  */
 749
 750 static void
 751 elf_symfile_read (struct objfile *objfile, int symfile_flags)
 752 {
 753   bfd *abfd = objfile->obfd;
 754   struct elfinfo ei;
 755   struct cleanup *back_to;
 756   CORE_ADDR offset;
 757   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 758   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 759   asymbol *synthsyms;
 760
 761   init_minimal_symbol_collection ();
 762   back_to = make_cleanup_discard_minimal_symbols ();
 763
 764   memset ((char *) &ei, 0, sizeof (ei));
 765
 766   /* Allocate struct to keep track of the symfile */
 767   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
 768     xmalloc (sizeof (struct dbx_symfile_info));
 769   memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 770   make_cleanup (free_elfinfo, (void *) objfile);
 771
 772   /* Process the normal ELF symbol table first.  This may write some
 773      chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
 774      which can later be used by elfstab_offset_sections.  */
 775
 776   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 777   if (storage_needed < 0)
 778     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 779            bfd_errmsg (bfd_get_error ()));
 780
 781   if (storage_needed > 0)
 782     {
 783       symbol_table = (asymbol **) xmalloc (storage_needed);
 784       make_cleanup (xfree, symbol_table);
 785       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 786
 787       if (symcount < 0)
 788         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 789                bfd_errmsg (bfd_get_error ()));
 790
 791       elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
 792     }
 793
 794   /* Add the dynamic symbols.  */
 795
 796   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 797
 798   if (storage_needed > 0)
 799     {
 800       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 801       make_cleanup (xfree, dyn_symbol_table);
 802       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 803                                                      dyn_symbol_table);
 804
 805       if (dynsymcount < 0)
 806         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 807                bfd_errmsg (bfd_get_error ()));
 808
 809       elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
 810     }
 811
 812   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 813
 814   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 815                                          dynsymcount, dyn_symbol_table,
 816                                          &synthsyms);
 817   if (synthcount > 0)
 818     {
 819       asymbol **synth_symbol_table;
 820       long i;
 821
 822       make_cleanup (xfree, synthsyms);
 823       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 824       for (i = 0; i < synthcount; i++)
 825         synth_symbol_table[i] = synthsyms + i;
 826       make_cleanup (xfree, synth_symbol_table);
 827       elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
 828     }
 829
 830   /* Install any minimal symbols that have been collected as the current
 831      minimal symbols for this objfile.  The debug readers below this point
 832      should not generate new minimal symbols; if they do it's their
 833      responsibility to install them.  "mdebug" appears to be the only one
 834      which will do this.  */
 835
 836   install_minimal_symbols (objfile);
 837   do_cleanups (back_to);
 838
 839   /* Now process debugging information, which is contained in
 840      special ELF sections. */
 841
 842   /* We first have to find them... */
 843   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 844
 845   /* ELF debugging information is inserted into the psymtab in the
 846      order of least informative first - most informative last.  Since
 847      the psymtab table is searched `most recent insertion first' this
 848      increases the probability that more detailed debug information
 849      for a section is found.
 850
 851      For instance, an object file might contain both .mdebug (XCOFF)
 852      and .debug_info (DWARF2) sections then .mdebug is inserted first
 853      (searched last) and DWARF2 is inserted last (searched first).  If
 854      we don't do this then the XCOFF info is found first - for code in
 855      an included file XCOFF info is useless. */
 856
 857   if (ei.mdebugsect)
 858     {
 859       const struct ecoff_debug_swap *swap;
 860
 861       /* .mdebug section, presumably holding ECOFF debugging
 862          information.  */
 863       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 864       if (swap)
 865         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 866     }
 867   if (ei.stabsect)
 868     {
 869       asection *str_sect;
 870
 871       /* Stab sections have an associated string table that looks like
 872          a separate section.  */
 873       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 874
 875       /* FIXME should probably warn about a stab section without a stabstr.  */
 876       if (str_sect)
 877         elfstab_build_psymtabs (objfile,
 878                                 ei.stabsect,
 879                                 str_sect->filepos,
 880                                 bfd_section_size (abfd, str_sect));
 881     }
 882   if (dwarf2_has_info (objfile))
 883     {
 884       /* DWARF 2 sections */
 885       dwarf2_build_psymtabs (objfile);
 886     }
 887
 888   /* FIXME: kettenis/20030504: This still needs to be integrated with
 889      dwarf2read.c in a better way.  */
 890   dwarf2_build_frame_info (objfile);
 891
 892   /* If the file has its own symbol tables it has no separate debug info.
 893      `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
 894      `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'.  */
 895   if (!objfile_has_partial_symbols (objfile))
 896     {
 897       char *debugfile;
 898
 899       debugfile = find_separate_debug_file_by_buildid (objfile);
 900
 901       if (debugfile == NULL)
 902         debugfile = find_separate_debug_file_by_debuglink (objfile);
 903
 904       if (debugfile)
 905         {
 906           bfd *abfd = symfile_bfd_open (debugfile);
 907           symbol_file_add_separate (abfd, symfile_flags, objfile);
 908           xfree (debugfile);
 909         }
 910     }
 911 }
 912
 913 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
 914    the chain of stab_section_info's, that might be dangling from
 915    it.  */
 916
 917 static void
 918 free_elfinfo (void *objp)
 919 {
 920   struct objfile *objfile = (struct objfile *) objp;
 921   struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
 922   struct stab_section_info *ssi, *nssi;
 923
 924   ssi = dbxinfo->stab_section_info;
 925   while (ssi)
 926     {
 927       nssi = ssi->next;
 928       xfree (ssi);
 929       ssi = nssi;
 930     }
 931
 932   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 933 }
 934
 935
 936 /* Initialize anything that needs initializing when a completely new symbol
 937    file is specified (not just adding some symbols from another file, e.g. a
 938    shared library).
 939
 940    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 941
 942 static void
 943 elf_new_init (struct objfile *ignore)
 944 {
 945   stabsread_new_init ();
 946   buildsym_new_init ();
 947 }
 948
 949 /* Perform any local cleanups required when we are done with a particular
 950    objfile.  I.E, we are in the process of discarding all symbol information
 951    for an objfile, freeing up all memory held for it, and unlinking the
 952    objfile struct from the global list of known objfiles. */
 953
 954 static void
 955 elf_symfile_finish (struct objfile *objfile)
 956 {
 957   if (objfile->deprecated_sym_stab_info != NULL)
 958     {
 959       xfree (objfile->deprecated_sym_stab_info);
 960     }
 961
 962   dwarf2_free_objfile (objfile);
 963 }
 964
 965 /* ELF specific initialization routine for reading symbols.
 966
 967    It is passed a pointer to a struct sym_fns which contains, among other
 968    things, the BFD for the file whose symbols are being read, and a slot for
 969    a pointer to "private data" which we can fill with goodies.
 970
 971    For now at least, we have nothing in particular to do, so this function is
 972    just a stub. */
 973
 974 static void
 975 elf_symfile_init (struct objfile *objfile)
 976 {
 977   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 978      find this causes a significant slowdown in gdb then we could
 979      set it in the debug symbol readers only when necessary.  */
 980   objfile->flags |= OBJF_REORDERED;
 981 }
 982
 983 /* When handling an ELF file that contains Sun STABS debug info,
 984    some of the debug info is relative to the particular chunk of the
 985    section that was generated in its individual .o file.  E.g.
 986    offsets to static variables are relative to the start of the data
 987    segment *for that module before linking*.  This information is
 988    painfully squirreled away in the ELF symbol table as local symbols
 989    with wierd names.  Go get 'em when needed.  */
 990
 991 void
 992 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 993 {
 994   char *filename = pst->filename;
 995   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 996   struct stab_section_info *maybe = dbx->stab_section_info;
 997   struct stab_section_info *questionable = 0;
 998   int i;
 999   char *p;
1000
1001   /* The ELF symbol info doesn't include path names, so strip the path
1002      (if any) from the psymtab filename.  */
1003   while (0 != (p = strchr (filename, '/')))
1004     filename = p + 1;
1005
1006   /* FIXME:  This linear search could speed up significantly
1007      if it was chained in the right order to match how we search it,
1008      and if we unchained when we found a match. */
1009   for (; maybe; maybe = maybe->next)
1010     {
1011       if (filename[0] == maybe->filename[0]
1012           && strcmp (filename, maybe->filename) == 0)
1013         {
1014           /* We found a match.  But there might be several source files
1015              (from different directories) with the same name.  */
1016           if (0 == maybe->found)
1017             break;
1018           questionable = maybe; /* Might use it later.  */
1019         }
1020     }
1021
1022   if (maybe == 0 && questionable != 0)
1023     {
1024       complaint (&symfile_complaints,
1025                  _("elf/stab section information questionable for %s"), filename);
1026       maybe = questionable;
1027     }
1028
1029   if (maybe)
1030     {
1031       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
1032       maybe->found++;
1033       pst->section_offsets = (struct section_offsets *)
1034         obstack_alloc (&objfile->objfile_obstack,
1035                        SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1036       for (i = 0; i < maybe->num_sections; i++)
1037         (pst->section_offsets)->offsets[i] = maybe->sections[i];
1038       return;
1039     }
1040
1041   /* We were unable to find any offsets for this file.  Complain.  */
1042   if (dbx->stab_section_info)   /* If there *is* any info, */
1043     complaint (&symfile_complaints,
1044                _("elf/stab section information missing for %s"), filename);
1045 }
1046 \f
1047 /* Register that we are able to handle ELF object file formats.  */
1048
1049 static struct sym_fns elf_sym_fns =
1050 {
1051   bfd_target_elf_flavour,
1052   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
1053   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
1054   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
1055   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
1056   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
1057   elf_symfile_segments,         /* sym_segments: Get segment information from
1058                                    a file.  */
1059   NULL,                         /* sym_read_linetable */
1060   default_symfile_relocate,     /* sym_relocate: Relocate a debug section.  */
1061   NULL                          /* next: pointer to next struct sym_fns */
1062 };
1063
1064 void
1065 _initialize_elfread (void)
1066 {
1067   add_symtab_fns (&elf_sym_fns);
1068 }