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