contrib/gdb/gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2
   3    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001, 2002, 2003, 2004 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., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, 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->sym_stab_info;
 165   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 166
 167   if (1)
 168     {
 169       for (i = 0; i < number_of_symbols; i++)
 170         {
 171           sym = symbol_table[i];
 172           if (sym->name == NULL || *sym->name == '\0')
 173             {
 174               /* Skip names that don't exist (shouldn't happen), or names
 175                  that are null strings (may happen). */
 176               continue;
 177             }
 178
 179           offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 180           if (dynamic
 181               && sym->section == &bfd_und_section
 182               && (sym->flags & BSF_FUNCTION))
 183             {
 184               struct minimal_symbol *msym;
 185
 186               /* Symbol is a reference to a function defined in
 187                  a shared library.
 188                  If its value is non zero then it is usually the address
 189                  of the corresponding entry in the procedure linkage table,
 190                  plus the desired section offset.
 191                  If its value is zero then the dynamic linker has to resolve
 192                  the symbol. We are unable to find any meaningful address
 193                  for this symbol in the executable file, so we skip it.  */
 194               symaddr = sym->value;
 195               if (symaddr == 0)
 196                 continue;
 197               symaddr += offset;
 198               msym = record_minimal_symbol
 199                 ((char *) sym->name, symaddr,
 200                  mst_solib_trampoline, sym->section, objfile);
 201 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 202               if (msym != NULL)
 203                 msym->filename = filesymname;
 204 #endif
 205               continue;
 206             }
 207
 208           /* If it is a nonstripped executable, do not enter dynamic
 209              symbols, as the dynamic symbol table is usually a subset
 210              of the main symbol table.  */
 211           if (dynamic && !stripped)
 212             continue;
 213           if (sym->flags & BSF_FILE)
 214             {
 215               /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 216                  Chain any old one onto the objfile; remember new sym.  */
 217               if (sectinfo != NULL)
 218                 {
 219                   sectinfo->next = dbx->stab_section_info;
 220                   dbx->stab_section_info = sectinfo;
 221                   sectinfo = NULL;
 222                 }
 223               filesym = sym;
 224 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 225               filesymname =
 226                 obsavestring ((char *) filesym->name, strlen (filesym->name),
 227                               &objfile->objfile_obstack);
 228 #endif
 229             }
 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                                 xmmalloc (objfile->md, 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
 427 /* Scan and build partial symbols for a symbol file.
 428    We have been initialized by a call to elf_symfile_init, which
 429    currently does nothing.
 430
 431    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 432    in each section.  We simplify it down to a single offset for all
 433    symbols.  FIXME.
 434
 435    MAINLINE is true if we are reading the main symbol
 436    table (as opposed to a shared lib or dynamically loaded file).
 437
 438    This function only does the minimum work necessary for letting the
 439    user "name" things symbolically; it does not read the entire symtab.
 440    Instead, it reads the external and static symbols and puts them in partial
 441    symbol tables.  When more extensive information is requested of a
 442    file, the corresponding partial symbol table is mutated into a full
 443    fledged symbol table by going back and reading the symbols
 444    for real.
 445
 446    We look for sections with specific names, to tell us what debug
 447    format to look for:  FIXME!!!
 448
 449    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 450    elfstab_build_psymtabs() handles STABS symbols;
 451    mdebug_build_psymtabs() handles ECOFF debugging information.
 452
 453    Note that ELF files have a "minimal" symbol table, which looks a lot
 454    like a COFF symbol table, but has only the minimal information necessary
 455    for linking.  We process this also, and use the information to
 456    build gdb's minimal symbol table.  This gives us some minimal debugging
 457    capability even for files compiled without -g.  */
 458
 459 static void
 460 elf_symfile_read (struct objfile *objfile, int mainline)
 461 {
 462   bfd *abfd = objfile->obfd;
 463   struct elfinfo ei;
 464   struct cleanup *back_to;
 465   CORE_ADDR offset;
 466   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 467   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 468   asymbol *synthsyms;
 469
 470   init_minimal_symbol_collection ();
 471   back_to = make_cleanup_discard_minimal_symbols ();
 472
 473   memset ((char *) &ei, 0, sizeof (ei));
 474
 475   /* Allocate struct to keep track of the symfile */
 476   objfile->sym_stab_info = (struct dbx_symfile_info *)
 477     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
 478   memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 479   make_cleanup (free_elfinfo, (void *) objfile);
 480
 481   /* Process the normal ELF symbol table first.  This may write some
 482      chain of info into the dbx_symfile_info in objfile->sym_stab_info,
 483      which can later be used by elfstab_offset_sections.  */
 484
 485   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 486   if (storage_needed < 0)
 487     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 488            bfd_errmsg (bfd_get_error ()));
 489
 490   if (storage_needed > 0)
 491     {
 492       symbol_table = (asymbol **) xmalloc (storage_needed);
 493       make_cleanup (xfree, symbol_table);
 494       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 495
 496       if (symcount < 0)
 497         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 498                bfd_errmsg (bfd_get_error ()));
 499
 500       elf_symtab_read (objfile, 0, symcount, symbol_table);
 501     }
 502
 503   /* Add the dynamic symbols.  */
 504
 505   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 506
 507   if (storage_needed > 0)
 508     {
 509       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 510       make_cleanup (xfree, dyn_symbol_table);
 511       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 512                                                      dyn_symbol_table);
 513
 514       if (dynsymcount < 0)
 515         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 516                bfd_errmsg (bfd_get_error ()));
 517
 518       elf_symtab_read (objfile, 1, dynsymcount, dyn_symbol_table);
 519     }
 520
 521   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 522
 523   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 524                                          dynsymcount, dyn_symbol_table,
 525                                          &synthsyms);
 526   if (synthcount > 0)
 527     {
 528       asymbol **synth_symbol_table;
 529       long i;
 530
 531       make_cleanup (xfree, synthsyms);
 532       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 533       for (i = 0; i < synthcount; i++)
 534         {
 535           synth_symbol_table[i] = synthsyms + i;
 536           /* Synthetic symbols are not, strictly speaking, either local
 537              or global.  But we can treat them as global symbols, since
 538              they are effectively dynamic symbols.  */
 539           synth_symbol_table[i]->flags |= BSF_GLOBAL;
 540         }
 541       make_cleanup (xfree, synth_symbol_table);
 542       elf_symtab_read (objfile, 0, synthcount, synth_symbol_table);
 543     }
 544
 545   /* Install any minimal symbols that have been collected as the current
 546      minimal symbols for this objfile.  The debug readers below this point
 547      should not generate new minimal symbols; if they do it's their
 548      responsibility to install them.  "mdebug" appears to be the only one
 549      which will do this.  */
 550
 551   install_minimal_symbols (objfile);
 552   do_cleanups (back_to);
 553
 554   /* Now process debugging information, which is contained in
 555      special ELF sections. */
 556
 557   /* If we are reinitializing, or if we have never loaded syms yet,
 558      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 559      functions do not all also re-initialize the psymbol table. */
 560   if (mainline)
 561     {
 562       init_psymbol_list (objfile, 0);
 563       mainline = 0;
 564     }
 565
 566   /* We first have to find them... */
 567   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 568
 569   /* ELF debugging information is inserted into the psymtab in the
 570      order of least informative first - most informative last.  Since
 571      the psymtab table is searched `most recent insertion first' this
 572      increases the probability that more detailed debug information
 573      for a section is found.
 574
 575      For instance, an object file might contain both .mdebug (XCOFF)
 576      and .debug_info (DWARF2) sections then .mdebug is inserted first
 577      (searched last) and DWARF2 is inserted last (searched first).  If
 578      we don't do this then the XCOFF info is found first - for code in
 579      an included file XCOFF info is useless. */
 580
 581   if (ei.mdebugsect)
 582     {
 583       const struct ecoff_debug_swap *swap;
 584
 585       /* .mdebug section, presumably holding ECOFF debugging
 586          information.  */
 587       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 588       if (swap)
 589         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 590     }
 591   if (ei.stabsect)
 592     {
 593       asection *str_sect;
 594
 595       /* Stab sections have an associated string table that looks like
 596          a separate section.  */
 597       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 598
 599       /* FIXME should probably warn about a stab section without a stabstr.  */
 600       if (str_sect)
 601         elfstab_build_psymtabs (objfile,
 602                                 mainline,
 603                                 ei.stabsect,
 604                                 str_sect->filepos,
 605                                 bfd_section_size (abfd, str_sect));
 606     }
 607   if (dwarf2_has_info (abfd))
 608     {
 609       /* DWARF 2 sections */
 610       dwarf2_build_psymtabs (objfile, mainline);
 611     }
 612   else if (ei.dboffset && ei.lnoffset)
 613     {
 614       /* DWARF sections */
 615       dwarf_build_psymtabs (objfile,
 616                             mainline,
 617                             ei.dboffset, ei.dbsize,
 618                             ei.lnoffset, ei.lnsize);
 619     }
 620
 621   /* FIXME: kettenis/20030504: This still needs to be integrated with
 622      dwarf2read.c in a better way.  */
 623   dwarf2_build_frame_info (objfile);
 624 }
 625
 626 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 627    stab_section_info's, that might be dangling from 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->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       xmfree (objfile->md, 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->sym_stab_info != NULL)
 670     {
 671       xmfree (objfile->md, objfile->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->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 }