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