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 Free Software Foundation, Inc.
   5
   6    Written by Fred Fish at Cygnus Support.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.  */
  24
  25 #include "defs.h"
  26 #include "bfd.h"
  27 #include "gdb_string.h"
  28 #include "elf-bfd.h"
  29 #include "elf/mips.h"
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "buildsym.h"
  34 #include "stabsread.h"
  35 #include "gdb-stabs.h"
  36 #include "complaints.h"
  37 #include "demangle.h"
  38
  39 extern void _initialize_elfread (void);
  40
  41 /* The struct elfinfo is available only during ELF symbol table and
  42    psymtab reading.  It is destroyed at the completion of psymtab-reading.
  43    It's local to elf_symfile_read.  */
  44
  45 struct elfinfo
  46   {
  47     asection *stabsect;         /* Section pointer for .stab section */
  48     asection *stabindexsect;    /* Section pointer for .stab.index section */
  49     asection *mdebugsect;       /* Section pointer for .mdebug section */
  50   };
  51
  52 static void free_elfinfo (void *);
  53
  54 /* We are called once per section from elf_symfile_read.  We
  55    need to examine each section we are passed, check to see
  56    if it is something we are interested in processing, and
  57    if so, stash away some access information for the section.
  58
  59    For now we recognize the dwarf debug information sections and
  60    line number sections from matching their section names.  The
  61    ELF definition is no real help here since it has no direct
  62    knowledge of DWARF (by design, so any debugging format can be
  63    used).
  64
  65    We also recognize the ".stab" sections used by the Sun compilers
  66    released with Solaris 2.
  67
  68    FIXME: The section names should not be hardwired strings (what
  69    should they be?  I don't think most object file formats have enough
  70    section flags to specify what kind of debug section it is
  71    -kingdon).  */
  72
  73 static void
  74 elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
  75 {
  76   struct elfinfo *ei;
  77
  78   ei = (struct elfinfo *) eip;
  79   if (strcmp (sectp->name, ".stab") == 0)
  80     {
  81       ei->stabsect = sectp;
  82     }
  83   else if (strcmp (sectp->name, ".stab.index") == 0)
  84     {
  85       ei->stabindexsect = sectp;
  86     }
  87   else if (strcmp (sectp->name, ".mdebug") == 0)
  88     {
  89       ei->mdebugsect = sectp;
  90     }
  91 }
  92
  93 static struct minimal_symbol *
  94 record_minimal_symbol (char *name, CORE_ADDR address,
  95                        enum minimal_symbol_type ms_type,
  96                        asection *bfd_section, struct objfile *objfile)
  97 {
  98   if (ms_type == mst_text || ms_type == mst_file_text)
  99     address = SMASH_TEXT_ADDRESS (address);
 100
 101   return prim_record_minimal_symbol_and_info
 102     (name, address, ms_type, NULL, bfd_section->index, bfd_section, objfile);
 103 }
 104
 105 /*
 106
 107    LOCAL FUNCTION
 108
 109    elf_symtab_read -- read the symbol table of an ELF file
 110
 111    SYNOPSIS
 112
 113    void elf_symtab_read (struct objfile *objfile, int dynamic,
 114                          long number_of_symbols, asymbol **symbol_table)
 115
 116    DESCRIPTION
 117
 118    Given an objfile, a symbol table, and a flag indicating whether the
 119    symbol table contains dynamic symbols, add all the global function
 120    and data symbols to the minimal symbol table.
 121
 122    In stabs-in-ELF, as implemented by Sun, there are some local symbols
 123    defined in the ELF symbol table, which can be used to locate
 124    the beginnings of sections from each ".o" file that was linked to
 125    form the executable objfile.  We gather any such info and record it
 126    in data structures hung off the objfile's private data.
 127
 128  */
 129
 130 static void
 131 elf_symtab_read (struct objfile *objfile, int dynamic,
 132                  long number_of_symbols, asymbol **symbol_table)
 133 {
 134   long storage_needed;
 135   asymbol *sym;
 136   long i;
 137   CORE_ADDR symaddr;
 138   CORE_ADDR offset;
 139   enum minimal_symbol_type ms_type;
 140   /* If sectinfo is nonNULL, it contains section info that should end up
 141      filed in the objfile.  */
 142   struct stab_section_info *sectinfo = NULL;
 143   /* If filesym is nonzero, it points to a file symbol, but we haven't
 144      seen any section info for it yet.  */
 145   asymbol *filesym = 0;
 146 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 147   /* Name of filesym, as saved on the objfile_obstack.  */
 148   char *filesymname = obsavestring ("", 0, &objfile->objfile_obstack);
 149 #endif
 150   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 151   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 152
 153   for (i = 0; i < number_of_symbols; i++)
 154     {
 155       sym = symbol_table[i];
 156       if (sym->name == NULL || *sym->name == '\0')
 157         {
 158           /* Skip names that don't exist (shouldn't happen), or names
 159              that are null strings (may happen). */
 160           continue;
 161         }
 162
 163       /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
 164          symbols which do not correspond to objects in the symbol table,
 165          but have some other target-specific meaning.  */
 166       if (bfd_is_target_special_symbol (objfile->obfd, sym))
 167         continue;
 168
 169       offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 170       if (dynamic
 171           && sym->section == &bfd_und_section
 172           && (sym->flags & BSF_FUNCTION))
 173         {
 174           struct minimal_symbol *msym;
 175
 176           /* Symbol is a reference to a function defined in
 177              a shared library.
 178              If its value is non zero then it is usually the address
 179              of the corresponding entry in the procedure linkage table,
 180              plus the desired section offset.
 181              If its value is zero then the dynamic linker has to resolve
 182              the symbol. We are unable to find any meaningful address
 183              for this symbol in the executable file, so we skip it.  */
 184           symaddr = sym->value;
 185           if (symaddr == 0)
 186             continue;
 187           symaddr += offset;
 188           msym = record_minimal_symbol
 189             ((char *) sym->name, symaddr,
 190              mst_solib_trampoline, sym->section, objfile);
 191 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 192           if (msym != NULL)
 193             msym->filename = filesymname;
 194 #endif
 195           continue;
 196         }
 197
 198       /* If it is a nonstripped executable, do not enter dynamic
 199          symbols, as the dynamic symbol table is usually a subset
 200          of the main symbol table.  */
 201       if (dynamic && !stripped)
 202         continue;
 203       if (sym->flags & BSF_FILE)
 204         {
 205           /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 206              Chain any old one onto the objfile; remember new sym.  */
 207           if (sectinfo != NULL)
 208             {
 209               sectinfo->next = dbx->stab_section_info;
 210               dbx->stab_section_info = sectinfo;
 211               sectinfo = NULL;
 212             }
 213           filesym = sym;
 214 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 215           filesymname =
 216             obsavestring ((char *) filesym->name, strlen (filesym->name),
 217                           &objfile->objfile_obstack);
 218 #endif
 219         }
 220       else if (sym->flags & BSF_SECTION_SYM)
 221         continue;
 222       else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 223         {
 224           struct minimal_symbol *msym;
 225
 226           /* Select global/local/weak symbols.  Note that bfd puts abs
 227              symbols in their own section, so all symbols we are
 228              interested in will have a section. */
 229           /* Bfd symbols are section relative. */
 230           symaddr = sym->value + sym->section->vma;
 231           /* Relocate all non-absolute symbols by the section offset.  */
 232           if (sym->section != &bfd_abs_section)
 233             {
 234               symaddr += offset;
 235             }
 236           /* For non-absolute symbols, use the type of the section
 237              they are relative to, to intuit text/data.  Bfd provides
 238              no way of figuring this out for absolute symbols. */
 239           if (sym->section == &bfd_abs_section)
 240             {
 241               /* This is a hack to get the minimal symbol type
 242                  right for Irix 5, which has absolute addresses
 243                  with special section indices for dynamic symbols. */
 244               unsigned short shndx =
 245                 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 246
 247               switch (shndx)
 248                 {
 249                 case SHN_MIPS_TEXT:
 250                   ms_type = mst_text;
 251                   break;
 252                 case SHN_MIPS_DATA:
 253                   ms_type = mst_data;
 254                   break;
 255                 case SHN_MIPS_ACOMMON:
 256                   ms_type = mst_bss;
 257                   break;
 258                 default:
 259                   ms_type = mst_abs;
 260                 }
 261
 262               /* If it is an Irix dynamic symbol, skip section name
 263                  symbols, relocate all others by section offset. */
 264               if (ms_type != mst_abs)
 265                 {
 266                   if (sym->name[0] == '.')
 267                     continue;
 268                   symaddr += offset;
 269                 }
 270             }
 271           else if (sym->section->flags & SEC_CODE)
 272             {
 273               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 274                 {
 275                   ms_type = mst_text;
 276                 }
 277               else if ((sym->name[0] == '.' && sym->name[1] == 'L')
 278                        || ((sym->flags & BSF_LOCAL)
 279                            && sym->name[0] == '$'
 280                            && sym->name[1] == 'L'))
 281                 /* Looks like a compiler-generated label.  Skip
 282                    it.  The assembler should be skipping these (to
 283                    keep executables small), but apparently with
 284                    gcc on the (deleted) delta m88k SVR4, it loses.
 285                    So to have us check too should be harmless (but
 286                    I encourage people to fix this in the assembler
 287                    instead of adding checks here).  */
 288                 continue;
 289               else
 290                 {
 291                   ms_type = mst_file_text;
 292                 }
 293             }
 294           else if (sym->section->flags & SEC_ALLOC)
 295             {
 296               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 297                 {
 298                   if (sym->section->flags & SEC_LOAD)
 299                     {
 300                       ms_type = mst_data;
 301                     }
 302                   else
 303                     {
 304                       ms_type = mst_bss;
 305                     }
 306                 }
 307               else if (sym->flags & BSF_LOCAL)
 308                 {
 309                   /* Named Local variable in a Data section.
 310                      Check its name for stabs-in-elf.  */
 311                   int special_local_sect;
 312                   if (strcmp ("Bbss.bss", sym->name) == 0)
 313                     special_local_sect = SECT_OFF_BSS (objfile);
 314                   else if (strcmp ("Ddata.data", sym->name) == 0)
 315                     special_local_sect = SECT_OFF_DATA (objfile);
 316                   else if (strcmp ("Drodata.rodata", sym->name) == 0)
 317                     special_local_sect = SECT_OFF_RODATA (objfile);
 318                   else
 319                     special_local_sect = -1;
 320                   if (special_local_sect >= 0)
 321                     {
 322                       /* Found a special local symbol.  Allocate a
 323                          sectinfo, if needed, and fill it in.  */
 324                       if (sectinfo == NULL)
 325                         {
 326                           int max_index;
 327                           size_t size;
 328
 329                           max_index
 330                             = max (SECT_OFF_BSS (objfile),
 331                                    max (SECT_OFF_DATA (objfile),
 332                                         SECT_OFF_RODATA (objfile)));
 333
 334                           /* max_index is the largest index we'll
 335                              use into this array, so we must
 336                              allocate max_index+1 elements for it.
 337                              However, 'struct stab_section_info'
 338                              already includes one element, so we
 339                              need to allocate max_index aadditional
 340                              elements.  */
 341                           size = (sizeof (struct stab_section_info)
 342                                   + (sizeof (CORE_ADDR)
 343                                      * max_index));
 344                           sectinfo = (struct stab_section_info *)
 345                             xmalloc (size);
 346                           memset (sectinfo, 0, size);
 347                           sectinfo->num_sections = max_index;
 348                           if (filesym == NULL)
 349                             {
 350                               complaint (&symfile_complaints,
 351                                          _("elf/stab section information %s without a preceding file symbol"),
 352                                          sym->name);
 353                             }
 354                           else
 355                             {
 356                               sectinfo->filename =
 357                                 (char *) filesym->name;
 358                             }
 359                         }
 360                       if (sectinfo->sections[special_local_sect] != 0)
 361                         complaint (&symfile_complaints,
 362                                    _("duplicated elf/stab section information for %s"),
 363                                    sectinfo->filename);
 364                       /* BFD symbols are section relative.  */
 365                       symaddr = sym->value + sym->section->vma;
 366                       /* Relocate non-absolute symbols by the
 367                          section offset.  */
 368                       if (sym->section != &bfd_abs_section)
 369                         symaddr += offset;
 370                       sectinfo->sections[special_local_sect] = symaddr;
 371                       /* The special local symbols don't go in the
 372                          minimal symbol table, so ignore this one.  */
 373                       continue;
 374                     }
 375                   /* Not a special stabs-in-elf symbol, do regular
 376                      symbol processing.  */
 377                   if (sym->section->flags & SEC_LOAD)
 378                     {
 379                       ms_type = mst_file_data;
 380                     }
 381                   else
 382                     {
 383                       ms_type = mst_file_bss;
 384                     }
 385                 }
 386               else
 387                 {
 388                   ms_type = mst_unknown;
 389                 }
 390             }
 391           else
 392             {
 393               /* FIXME:  Solaris2 shared libraries include lots of
 394                  odd "absolute" and "undefined" symbols, that play
 395                  hob with actions like finding what function the PC
 396                  is in.  Ignore them if they aren't text, data, or bss.  */
 397               /* ms_type = mst_unknown; */
 398               continue; /* Skip this symbol. */
 399             }
 400           msym = record_minimal_symbol
 401             ((char *) sym->name, symaddr,
 402              ms_type, sym->section, objfile);
 403           if (msym)
 404             {
 405               /* Pass symbol size field in via BFD.  FIXME!!!  */
 406               unsigned long size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 407               MSYMBOL_SIZE(msym) = size;
 408             }
 409 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 410           if (msym != NULL)
 411             msym->filename = filesymname;
 412 #endif
 413           gdbarch_elf_make_msymbol_special (current_gdbarch, sym, msym);
 414         }
 415     }
 416 }
 417
 418 /* Scan and build partial symbols for a symbol file.
 419    We have been initialized by a call to elf_symfile_init, which
 420    currently does nothing.
 421
 422    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 423    in each section.  We simplify it down to a single offset for all
 424    symbols.  FIXME.
 425
 426    MAINLINE is true if we are reading the main symbol
 427    table (as opposed to a shared lib or dynamically loaded file).
 428
 429    This function only does the minimum work necessary for letting the
 430    user "name" things symbolically; it does not read the entire symtab.
 431    Instead, it reads the external and static symbols and puts them in partial
 432    symbol tables.  When more extensive information is requested of a
 433    file, the corresponding partial symbol table is mutated into a full
 434    fledged symbol table by going back and reading the symbols
 435    for real.
 436
 437    We look for sections with specific names, to tell us what debug
 438    format to look for:  FIXME!!!
 439
 440    elfstab_build_psymtabs() handles STABS symbols;
 441    mdebug_build_psymtabs() handles ECOFF debugging information.
 442
 443    Note that ELF files have a "minimal" symbol table, which looks a lot
 444    like a COFF symbol table, but has only the minimal information necessary
 445    for linking.  We process this also, and use the information to
 446    build gdb's minimal symbol table.  This gives us some minimal debugging
 447    capability even for files compiled without -g.  */
 448
 449 static void
 450 elf_symfile_read (struct objfile *objfile, int mainline)
 451 {
 452   bfd *abfd = objfile->obfd;
 453   struct elfinfo ei;
 454   struct cleanup *back_to;
 455   CORE_ADDR offset;
 456   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 457   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 458   asymbol *synthsyms;
 459
 460   init_minimal_symbol_collection ();
 461   back_to = make_cleanup_discard_minimal_symbols ();
 462
 463   memset ((char *) &ei, 0, sizeof (ei));
 464
 465   /* Allocate struct to keep track of the symfile */
 466   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
 467     xmalloc (sizeof (struct dbx_symfile_info));
 468   memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 469   make_cleanup (free_elfinfo, (void *) objfile);
 470
 471   /* Process the normal ELF symbol table first.  This may write some
 472      chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
 473      which can later be used by elfstab_offset_sections.  */
 474
 475   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 476   if (storage_needed < 0)
 477     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 478            bfd_errmsg (bfd_get_error ()));
 479
 480   if (storage_needed > 0)
 481     {
 482       symbol_table = (asymbol **) xmalloc (storage_needed);
 483       make_cleanup (xfree, symbol_table);
 484       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 485
 486       if (symcount < 0)
 487         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 488                bfd_errmsg (bfd_get_error ()));
 489
 490       elf_symtab_read (objfile, 0, symcount, symbol_table);
 491     }
 492
 493   /* Add the dynamic symbols.  */
 494
 495   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 496
 497   if (storage_needed > 0)
 498     {
 499       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 500       make_cleanup (xfree, dyn_symbol_table);
 501       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 502                                                      dyn_symbol_table);
 503
 504       if (dynsymcount < 0)
 505         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 506                bfd_errmsg (bfd_get_error ()));
 507
 508       elf_symtab_read (objfile, 1, dynsymcount, dyn_symbol_table);
 509     }
 510
 511   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 512
 513   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 514                                          dynsymcount, dyn_symbol_table,
 515                                          &synthsyms);
 516   if (synthcount > 0)
 517     {
 518       asymbol **synth_symbol_table;
 519       long i;
 520
 521       make_cleanup (xfree, synthsyms);
 522       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 523       for (i = 0; i < synthcount; i++)
 524         synth_symbol_table[i] = synthsyms + i;
 525       make_cleanup (xfree, synth_symbol_table);
 526       elf_symtab_read (objfile, 0, synthcount, synth_symbol_table);
 527     }
 528
 529   /* Install any minimal symbols that have been collected as the current
 530      minimal symbols for this objfile.  The debug readers below this point
 531      should not generate new minimal symbols; if they do it's their
 532      responsibility to install them.  "mdebug" appears to be the only one
 533      which will do this.  */
 534
 535   install_minimal_symbols (objfile);
 536   do_cleanups (back_to);
 537
 538   /* Now process debugging information, which is contained in
 539      special ELF sections. */
 540
 541   /* If we are reinitializing, or if we have never loaded syms yet,
 542      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 543      functions do not all also re-initialize the psymbol table. */
 544   if (mainline)
 545     {
 546       init_psymbol_list (objfile, 0);
 547       mainline = 0;
 548     }
 549
 550   /* We first have to find them... */
 551   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 552
 553   /* ELF debugging information is inserted into the psymtab in the
 554      order of least informative first - most informative last.  Since
 555      the psymtab table is searched `most recent insertion first' this
 556      increases the probability that more detailed debug information
 557      for a section is found.
 558
 559      For instance, an object file might contain both .mdebug (XCOFF)
 560      and .debug_info (DWARF2) sections then .mdebug is inserted first
 561      (searched last) and DWARF2 is inserted last (searched first).  If
 562      we don't do this then the XCOFF info is found first - for code in
 563      an included file XCOFF info is useless. */
 564
 565   if (ei.mdebugsect)
 566     {
 567       const struct ecoff_debug_swap *swap;
 568
 569       /* .mdebug section, presumably holding ECOFF debugging
 570          information.  */
 571       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 572       if (swap)
 573         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 574     }
 575   if (ei.stabsect)
 576     {
 577       asection *str_sect;
 578
 579       /* Stab sections have an associated string table that looks like
 580          a separate section.  */
 581       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 582
 583       /* FIXME should probably warn about a stab section without a stabstr.  */
 584       if (str_sect)
 585         elfstab_build_psymtabs (objfile,
 586                                 mainline,
 587                                 ei.stabsect,
 588                                 str_sect->filepos,
 589                                 bfd_section_size (abfd, str_sect));
 590     }
 591   if (dwarf2_has_info (objfile))
 592     {
 593       /* DWARF 2 sections */
 594       dwarf2_build_psymtabs (objfile, mainline);
 595     }
 596
 597   /* FIXME: kettenis/20030504: This still needs to be integrated with
 598      dwarf2read.c in a better way.  */
 599   dwarf2_build_frame_info (objfile);
 600 }
 601
 602 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
 603    the chain of stab_section_info's, that might be dangling from
 604    it.  */
 605
 606 static void
 607 free_elfinfo (void *objp)
 608 {
 609   struct objfile *objfile = (struct objfile *) objp;
 610   struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
 611   struct stab_section_info *ssi, *nssi;
 612
 613   ssi = dbxinfo->stab_section_info;
 614   while (ssi)
 615     {
 616       nssi = ssi->next;
 617       xfree (ssi);
 618       ssi = nssi;
 619     }
 620
 621   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 622 }
 623
 624
 625 /* Initialize anything that needs initializing when a completely new symbol
 626    file is specified (not just adding some symbols from another file, e.g. a
 627    shared library).
 628
 629    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 630
 631 static void
 632 elf_new_init (struct objfile *ignore)
 633 {
 634   stabsread_new_init ();
 635   buildsym_new_init ();
 636 }
 637
 638 /* Perform any local cleanups required when we are done with a particular
 639    objfile.  I.E, we are in the process of discarding all symbol information
 640    for an objfile, freeing up all memory held for it, and unlinking the
 641    objfile struct from the global list of known objfiles. */
 642
 643 static void
 644 elf_symfile_finish (struct objfile *objfile)
 645 {
 646   if (objfile->deprecated_sym_stab_info != NULL)
 647     {
 648       xfree (objfile->deprecated_sym_stab_info);
 649     }
 650 }
 651
 652 /* ELF specific initialization routine for reading symbols.
 653
 654    It is passed a pointer to a struct sym_fns which contains, among other
 655    things, the BFD for the file whose symbols are being read, and a slot for
 656    a pointer to "private data" which we can fill with goodies.
 657
 658    For now at least, we have nothing in particular to do, so this function is
 659    just a stub. */
 660
 661 static void
 662 elf_symfile_init (struct objfile *objfile)
 663 {
 664   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 665      find this causes a significant slowdown in gdb then we could
 666      set it in the debug symbol readers only when necessary.  */
 667   objfile->flags |= OBJF_REORDERED;
 668 }
 669
 670 /* When handling an ELF file that contains Sun STABS debug info,
 671    some of the debug info is relative to the particular chunk of the
 672    section that was generated in its individual .o file.  E.g.
 673    offsets to static variables are relative to the start of the data
 674    segment *for that module before linking*.  This information is
 675    painfully squirreled away in the ELF symbol table as local symbols
 676    with wierd names.  Go get 'em when needed.  */
 677
 678 void
 679 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 680 {
 681   char *filename = pst->filename;
 682   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 683   struct stab_section_info *maybe = dbx->stab_section_info;
 684   struct stab_section_info *questionable = 0;
 685   int i;
 686   char *p;
 687
 688   /* The ELF symbol info doesn't include path names, so strip the path
 689      (if any) from the psymtab filename.  */
 690   while (0 != (p = strchr (filename, '/')))
 691     filename = p + 1;
 692
 693   /* FIXME:  This linear search could speed up significantly
 694      if it was chained in the right order to match how we search it,
 695      and if we unchained when we found a match. */
 696   for (; maybe; maybe = maybe->next)
 697     {
 698       if (filename[0] == maybe->filename[0]
 699           && strcmp (filename, maybe->filename) == 0)
 700         {
 701           /* We found a match.  But there might be several source files
 702              (from different directories) with the same name.  */
 703           if (0 == maybe->found)
 704             break;
 705           questionable = maybe; /* Might use it later.  */
 706         }
 707     }
 708
 709   if (maybe == 0 && questionable != 0)
 710     {
 711       complaint (&symfile_complaints,
 712                  _("elf/stab section information questionable for %s"), filename);
 713       maybe = questionable;
 714     }
 715
 716   if (maybe)
 717     {
 718       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 719       maybe->found++;
 720       pst->section_offsets = (struct section_offsets *)
 721         obstack_alloc (&objfile->objfile_obstack,
 722                        SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 723       for (i = 0; i < maybe->num_sections; i++)
 724         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 725       return;
 726     }
 727
 728   /* We were unable to find any offsets for this file.  Complain.  */
 729   if (dbx->stab_section_info)   /* If there *is* any info, */
 730     complaint (&symfile_complaints,
 731                _("elf/stab section information missing for %s"), filename);
 732 }
 733 \f
 734 /* Register that we are able to handle ELF object file formats.  */
 735
 736 static struct sym_fns elf_sym_fns =
 737 {
 738   bfd_target_elf_flavour,
 739   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 740   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 741   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 742   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 743   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 744   NULL                          /* next: pointer to next struct sym_fns */
 745 };
 746
 747 void
 748 _initialize_elfread (void)
 749 {
 750   add_symtab_fns (&elf_sym_fns);
 751 }