gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2    Copyright 1991, 1992 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /************************************************************************
  22  *                                                                      *
  23  *                              NOTICE                                  *
  24  *                                                                      *
  25  * This file is still under construction.  When it is complete, this    *
  26  * notice will be removed.  Until then, direct any questions or changes *
  27  * to Fred Fish at Cygnus Support (fnf@cygnus.com)                      *
  28  *                                                                      *
  29  * FIXME        Still needs support for shared libraries.               *
  30  * FIXME        Still needs support for core files.                     *
  31  * FIXME        The ".debug" and ".line" section names are hardwired.   *
  32  *                                                                      *
  33  ************************************************************************/
  34
  35 #include "defs.h"
  36 #include "elf/common.h"
  37 #include "elf/external.h"
  38 #include "elf/internal.h"
  39 #include "bfd.h"
  40 #include "libbfd.h"             /* For bfd_elf_find_section */
  41 #include "symtab.h"
  42 #include "symfile.h"
  43 #include "objfiles.h"
  44 #include "buildsym.h"
  45 #include "gdb-stabs.h"
  46
  47 #define STREQ(a,b) (strcmp((a),(b))==0)
  48
  49 /* The struct elfinfo is available only during ELF symbol table and
  50    psymtab reading.  It is destroyed at the complation of psymtab-reading.
  51    It's local to elf_symfile_read.  */
  52
  53 struct elfinfo {
  54   file_ptr dboffset;            /* Offset to dwarf debug section */
  55   unsigned int dbsize;          /* Size of dwarf debug section */
  56   file_ptr lnoffset;            /* Offset to dwarf line number section */
  57   unsigned int lnsize;          /* Size of dwarf line number section */
  58   asection *stabsect;           /* Section pointer for .stab section */
  59   asection *stabindexsect;      /* Section pointer for .stab.index section */
  60 };
  61
  62 /* Various things we might complain about... */
  63
  64 struct complaint section_info_complaint =
  65   {"elf/stab section information %s without a preceding file symbol", 0, 0};
  66
  67 struct complaint section_info_dup_complaint =
  68   {"duplicated elf/stab section information for %s", 0, 0};
  69
  70 struct complaint stab_info_mismatch_complaint =
  71   {"elf/stab section information missing for %s", 0, 0};
  72
  73 struct complaint stab_info_questionable_complaint =
  74   {"elf/stab section information questionable for %s", 0, 0};
  75
  76 static void
  77 elf_symfile_init PARAMS ((struct objfile *));
  78
  79 static void
  80 elf_new_init PARAMS ((struct objfile *));
  81
  82 static void
  83 elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  84
  85 static void
  86 elf_symfile_finish PARAMS ((struct objfile *));
  87
  88 static void
  89 elf_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *));
  90
  91 static void
  92 free_elfinfo PARAMS ((PTR));
  93
  94 static struct section_offsets *
  95 elf_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
  96
  97 #if 0
  98 static void
  99 record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type,
 100                                struct objfile *));
 101 #endif
 102
 103 static void
 104 record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR,
 105                                         enum minimal_symbol_type, char *,
 106                                         struct objfile *));
 107
 108 static void
 109 elf_locate_sections PARAMS ((bfd *, asection *, PTR));
 110
 111 /* We are called once per section from elf_symfile_read.  We
 112    need to examine each section we are passed, check to see
 113    if it is something we are interested in processing, and
 114    if so, stash away some access information for the section.
 115
 116    For now we recognize the dwarf debug information sections and
 117    line number sections from matching their section names.  The
 118    ELF definition is no real help here since it has no direct
 119    knowledge of DWARF (by design, so any debugging format can be
 120    used).
 121
 122    We also recognize the ".stab" sections used by the Sun compilers
 123    released with Solaris 2.
 124
 125    FIXME:  The section names should not be hardwired strings. */
 126
 127 static void
 128 elf_locate_sections (ignore_abfd, sectp, eip)
 129      bfd *ignore_abfd;
 130      asection *sectp;
 131      PTR eip;
 132 {
 133   register struct elfinfo *ei;
 134
 135   ei = (struct elfinfo *) eip;
 136   if (STREQ (sectp -> name, ".debug"))
 137     {
 138       ei -> dboffset = sectp -> filepos;
 139       ei -> dbsize = bfd_get_section_size_before_reloc (sectp);
 140     }
 141   else if (STREQ (sectp -> name, ".line"))
 142     {
 143       ei -> lnoffset = sectp -> filepos;
 144       ei -> lnsize = bfd_get_section_size_before_reloc (sectp);
 145     }
 146   else if (STREQ (sectp -> name, ".stab"))
 147     {
 148       ei -> stabsect = sectp;
 149     }
 150   else if (STREQ (sectp -> name, ".stab.index"))
 151     {
 152       ei -> stabindexsect = sectp;
 153     }
 154 }
 155
 156 #if 0   /* Currently unused */
 157
 158 char *
 159 elf_interpreter (abfd)
 160      bfd *abfd;
 161 {
 162   sec_ptr interp_sec;
 163   unsigned size;
 164   char *interp = NULL;
 165
 166   interp_sec = bfd_get_section_by_name (abfd, ".interp");
 167   if (interp_sec)
 168     {
 169       size = bfd_section_size (abfd, interp_sec);
 170       interp = alloca (size);
 171       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
 172                                     size))
 173         {
 174           interp = savestring (interp, size - 1);
 175         }
 176       else
 177         {
 178           interp = NULL;
 179         }
 180     }
 181   return (interp);
 182 }
 183
 184 #endif
 185
 186 /*
 187
 188 LOCAL FUNCTION
 189
 190         record_minimal_symbol -- add entry to minimal symbol table
 191
 192 SYNOPSIS
 193
 194         static void record_minimal_symbol (char *name, CORE_ADDR address)
 195
 196 DESCRIPTION
 197
 198         Given a pointer to the name of a symbol that should be added to the
 199         minimal symbol table and the address associated with that symbol, records
 200         this information for later use in building the minimal symbol table.
 201
 202  */
 203
 204 #if 0   /* FIXME:  Unused */
 205
 206 static void
 207 record_minimal_symbol (name, address, ms_type, objfile)
 208      char *name;
 209      CORE_ADDR address;
 210      enum minimal_symbol_type ms_type;
 211      struct objfile *objfile;
 212 {
 213   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
 214   prim_record_minimal_symbol (name, address, ms_type);
 215 }
 216
 217 #endif
 218
 219 static void
 220 record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
 221      char *name;
 222      CORE_ADDR address;
 223      enum minimal_symbol_type ms_type;
 224      char *info;                /* FIXME, is this really char *? */
 225      struct objfile *objfile;
 226 {
 227   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
 228   prim_record_minimal_symbol_and_info (name, address, ms_type, info);
 229 }
 230
 231 /*
 232
 233 LOCAL FUNCTION
 234
 235         elf_symtab_read -- read the symbol table of an ELF file
 236
 237 SYNOPSIS
 238
 239         void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
 240                               struct objfile *objfile)
 241
 242 DESCRIPTION
 243
 244         Given an open bfd, a base address to relocate symbols to, and a
 245         flag that specifies whether or not this bfd is for an executable
 246         or not (may be shared library for example), add all the global
 247         function and data symbols to the minimal symbol table.
 248
 249         In stabs-in-ELF, as implemented by Sun, there are some local symbols
 250         defined in the ELF symbol table, which can be used to locate
 251         the beginnings of sections from each ".o" file that was linked to
 252         form the executable objfile.  We gather any such info and record it
 253         in data structures hung off the objfile's private data.
 254
 255 */
 256
 257 static void
 258 elf_symtab_read (abfd, addr, objfile)
 259      bfd *abfd;
 260      CORE_ADDR addr;
 261      struct objfile *objfile;
 262 {
 263   unsigned int storage_needed;
 264   asymbol *sym;
 265   asymbol **symbol_table;
 266   unsigned int number_of_symbols;
 267   unsigned int i;
 268   int index;
 269   struct cleanup *back_to;
 270   CORE_ADDR symaddr;
 271   enum minimal_symbol_type ms_type;
 272   /* If sectinfo is nonzero, it contains section info that should end up
 273      filed in the objfile.  */
 274   struct stab_section_info *sectinfo = 0;
 275   /* If filesym is nonzero, it points to a file symbol, but we haven't
 276      seen any section info for it yet.  */
 277   asymbol *filesym = 0;
 278   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
 279                                  objfile->sym_private;
 280
 281   storage_needed = get_symtab_upper_bound (abfd);
 282
 283   if (storage_needed > 0)
 284     {
 285       symbol_table = (asymbol **) xmalloc (storage_needed);
 286       back_to = make_cleanup (free, symbol_table);
 287       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 288
 289       for (i = 0; i < number_of_symbols; i++)
 290         {
 291           sym = symbol_table[i];
 292           /* Select global/weak symbols that are defined in a specific section.
 293              Note that bfd now puts abs symbols in their own section, so
 294              all symbols we are interested in will have a section. */
 295           if ((sym -> flags & (BSF_GLOBAL | BSF_WEAK))
 296               && (sym -> section != NULL))
 297             {
 298               symaddr = sym -> value;
 299               /* Relocate all non-absolute symbols by base address.  */
 300               if (sym -> section != &bfd_abs_section)
 301                 symaddr += addr;
 302
 303               /* For non-absolute symbols, use the type of the section
 304                  they are relative to, to intuit text/data.  Bfd provides
 305                  no way of figuring this out for absolute symbols. */
 306               if (sym -> section -> flags & SEC_CODE)
 307                 {
 308                   ms_type = mst_text;
 309                 }
 310               else if (sym -> section -> flags & SEC_DATA)
 311                 {
 312                   ms_type = mst_data;
 313                 }
 314               else
 315                 {
 316                   /* FIXME:  Solaris2 shared libraries include lots of
 317                      odd "absolute" and "undefined" symbols, that play
 318                      hob with actions like finding what function the PC
 319                      is in.  Ignore them if they aren't text or data.  */
 320                   /* ms_type = mst_unknown; */
 321                   continue;             /* Skip this symbol. */
 322                 }
 323               /* Pass symbol size field in via BFD.  FIXME!!!  */
 324               record_minimal_symbol_and_info ((char *) sym -> name,
 325                          symaddr, ms_type, sym->udata, objfile);
 326             }
 327
 328           /* See if this is a debugging symbol that helps Solaris
 329              stabs-in-elf debugging.  */
 330
 331           else if (sym->flags & BSF_FILE)
 332             {
 333               /* Chain any old one onto the objfile; remember new sym.  */
 334               if (sectinfo)
 335                 {
 336                     sectinfo->next = dbx->stab_section_info;
 337                     dbx->stab_section_info = sectinfo;
 338                     sectinfo = 0;
 339                 }
 340               filesym = sym;
 341             }
 342           else if ((sym->flags & BSF_LOCAL) &&
 343                    (sym->section) &&
 344                    (sym->section->flags & SEC_DATA) &&
 345                    (sym->name))
 346             {
 347               /* Named Local variable in a Data section.  Check its name.  */
 348               index = -1;
 349               switch (sym->name[1])
 350                 {
 351                   case 'b':
 352                         if (!strcmp ("Bbss.bss", sym->name))
 353                           index = SECT_OFF_BSS;
 354                         break;
 355                   case 'd':
 356                         if (!strcmp ("Ddata.data", sym->name))
 357                           index = SECT_OFF_DATA;
 358                         break;
 359                   case 'r':
 360                         if (!strcmp ("Drodata.rodata", sym->name))
 361                           index = SECT_OFF_RODATA;
 362                         break;
 363                 }
 364               if (index > 0)
 365                 {
 366                   /* We have some new info.  Allocate a sectinfo, if
 367                      needed, and fill it in.  */
 368                   if (!sectinfo)
 369                     {
 370                       sectinfo = (struct stab_section_info *)
 371                                  xmmalloc (objfile -> md,
 372                                            sizeof (*sectinfo));
 373                       memset ((PTR) sectinfo, 0, sizeof (*sectinfo));
 374                       if (!filesym)
 375                         complain (&section_info_complaint, (char *)sym->name);
 376                       else
 377                         sectinfo->filename = (char *)filesym->name;
 378                     }
 379                   if (sectinfo->sections[index])
 380                     complain (&section_info_dup_complaint,
 381                               (char *)sectinfo->filename);
 382
 383                   symaddr = sym -> value;
 384                   /* Relocate all non-absolute symbols by base address.  */
 385                   if (sym -> section != &bfd_abs_section)
 386                       symaddr += addr;
 387                   sectinfo->sections[index] = symaddr;
 388                 }
 389             }
 390         }
 391       do_cleanups (back_to);
 392     }
 393 }
 394
 395 /* Scan and build partial symbols for a symbol file.
 396    We have been initialized by a call to elf_symfile_init, which
 397    currently does nothing.
 398
 399    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 400    in each section.  We simplify it down to a single offset for all
 401    symbols.  FIXME.
 402
 403    MAINLINE is true if we are reading the main symbol
 404    table (as opposed to a shared lib or dynamically loaded file).
 405
 406    This function only does the minimum work necessary for letting the
 407    user "name" things symbolically; it does not read the entire symtab.
 408    Instead, it reads the external and static symbols and puts them in partial
 409    symbol tables.  When more extensive information is requested of a
 410    file, the corresponding partial symbol table is mutated into a full
 411    fledged symbol table by going back and reading the symbols
 412    for real.
 413
 414    We look for sections with specific names, to tell us what debug
 415    format to look for:  FIXME!!!
 416
 417    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 418    elfstab_build_psymtabs() handles STABS symbols.
 419
 420    Note that ELF files have a "minimal" symbol table, which looks a lot
 421    like a COFF symbol table, but has only the minimal information necessary
 422    for linking.  We process this also, and use the information to
 423    build gdb's minimal symbol table.  This gives us some minimal debugging
 424    capability even for files compiled without -g.  */
 425
 426 static void
 427 elf_symfile_read (objfile, section_offsets, mainline)
 428      struct objfile *objfile;
 429      struct section_offsets *section_offsets;
 430      int mainline;
 431 {
 432   bfd *abfd = objfile->obfd;
 433   struct elfinfo ei;
 434   struct dbx_symfile_info *dbx;
 435   struct cleanup *back_to;
 436   asection *text_sect;
 437   CORE_ADDR offset;
 438
 439   init_minimal_symbol_collection ();
 440   back_to = make_cleanup (discard_minimal_symbols, 0);
 441
 442   memset ((char *) &ei, 0, sizeof (ei));
 443
 444   /* Allocate struct to keep track of the symfile */
 445   objfile->sym_private = (PTR)
 446     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
 447   memset ((char *) objfile->sym_private, 0, sizeof (struct dbx_symfile_info));
 448   make_cleanup (free_elfinfo, (PTR) objfile);
 449
 450   /* Process the normal ELF symbol table first.  This may write some
 451      chain of info into the dbx_symfile_info in objfile->sym_private,
 452      which can later be used by elfstab_offset_sections.  */
 453
 454   /* FIXME, should take a section_offsets param, not just an offset.  */
 455   offset = ANOFFSET (section_offsets, 0);
 456   elf_symtab_read (abfd, offset, objfile);
 457
 458   /* Now process debugging information, which is contained in
 459      special ELF sections.  We first have to find them... */
 460
 461   bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei);
 462   if (ei.dboffset && ei.lnoffset)
 463     {
 464       /* DWARF sections */
 465       dwarf_build_psymtabs (objfile,
 466                             section_offsets, mainline,
 467                             ei.dboffset, ei.dbsize,
 468                             ei.lnoffset, ei.lnsize);
 469     }
 470   if (ei.stabsect)
 471     {
 472       /* STABS sections */
 473
 474       /* FIXME:  Sun didn't really know how to implement this well.
 475          They made .stab sections that don't point to the .stabstr
 476          section with the sh_link field.  BFD doesn't make string table
 477          sections visible to the caller.  So we have to search the
 478          ELF section table, not the BFD section table, for the string
 479          table.  */
 480       struct elf_internal_shdr *elf_sect;
 481
 482       elf_sect = bfd_elf_find_section (abfd, ".stabstr");
 483       if (elf_sect)
 484         elfstab_build_psymtabs (objfile,
 485           section_offsets,
 486           mainline,
 487           ei.stabsect->filepos,                         /* .stab offset */
 488           bfd_get_section_size_before_reloc (ei.stabsect),/* .stab size */
 489           (file_ptr) elf_sect->sh_offset,               /* .stabstr offset */
 490           elf_sect->sh_size);                           /* .stabstr size */
 491     }
 492
 493   if (!have_partial_symbols ())
 494     {
 495       wrap_here ("");
 496       printf_filtered ("(no debugging symbols found)...");
 497       wrap_here ("");
 498     }
 499
 500   /* Install any minimal symbols that have been collected as the current
 501      minimal symbols for this objfile. */
 502
 503   install_minimal_symbols (objfile);
 504
 505   do_cleanups (back_to);
 506 }
 507
 508 /* This cleans up the objfile's sym_private pointer, and the chain of
 509    stab_section_info's, that might be dangling from it.  */
 510
 511 static void
 512 free_elfinfo (objp)
 513      PTR objp;
 514 {
 515   struct objfile *objfile = (struct objfile *)objp;
 516   struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
 517                                      objfile->sym_private;
 518   struct stab_section_info *ssi, *nssi;
 519
 520   ssi = dbxinfo->stab_section_info;
 521   while (ssi)
 522     {
 523       nssi = ssi->next;
 524       mfree (objfile->md, ssi);
 525       ssi = nssi;
 526     }
 527
 528   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 529 }
 530
 531
 532 /* Initialize anything that needs initializing when a completely new symbol
 533    file is specified (not just adding some symbols from another file, e.g. a
 534    shared library).
 535
 536    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 537
 538 static void
 539 elf_new_init (ignore)
 540      struct objfile *ignore;
 541 {
 542   stabsread_new_init ();
 543   buildsym_new_init ();
 544 }
 545
 546 /* Perform any local cleanups required when we are done with a particular
 547    objfile.  I.E, we are in the process of discarding all symbol information
 548    for an objfile, freeing up all memory held for it, and unlinking the
 549    objfile struct from the global list of known objfiles. */
 550
 551 static void
 552 elf_symfile_finish (objfile)
 553      struct objfile *objfile;
 554 {
 555   if (objfile -> sym_private != NULL)
 556     {
 557       mfree (objfile -> md, objfile -> sym_private);
 558     }
 559 }
 560
 561 /* ELF specific initialization routine for reading symbols.
 562
 563    It is passed a pointer to a struct sym_fns which contains, among other
 564    things, the BFD for the file whose symbols are being read, and a slot for
 565    a pointer to "private data" which we can fill with goodies.
 566
 567    For now at least, we have nothing in particular to do, so this function is
 568    just a stub. */
 569
 570 static void
 571 elf_symfile_init (ignore)
 572      struct objfile *ignore;
 573 {
 574 }
 575
 576 /* ELF specific parsing routine for section offsets.
 577
 578    Plain and simple for now.  */
 579
 580 static
 581 struct section_offsets *
 582 elf_symfile_offsets (objfile, addr)
 583      struct objfile *objfile;
 584      CORE_ADDR addr;
 585 {
 586   struct section_offsets *section_offsets;
 587   int i;
 588
 589   section_offsets = (struct section_offsets *)
 590     obstack_alloc (&objfile -> psymbol_obstack,
 591                    sizeof (struct section_offsets) +
 592                           sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 593
 594   for (i = 0; i < SECT_OFF_MAX; i++)
 595     ANOFFSET (section_offsets, i) = addr;
 596
 597   return section_offsets;
 598 }
 599 \f
 600 /* When handling an ELF file that contains Sun STABS debug info,
 601    some of the debug info is relative to the particular chunk of the
 602    section that was generated in its individual .o file.  E.g.
 603    offsets to static variables are relative to the start of the data
 604    segment *for that module before linking*.  This information is
 605    painfully squirreled away in the ELF symbol table as local symbols
 606    with wierd names.  Go get 'em when needed.  */
 607
 608 void
 609 elfstab_offset_sections (objfile, pst)
 610      struct objfile *objfile;
 611      struct partial_symtab *pst;
 612 {
 613   char *filename = pst->filename;
 614   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
 615                                  objfile->sym_private;
 616   struct stab_section_info *maybe = dbx->stab_section_info;
 617   struct stab_section_info *questionable = 0;
 618   int i;
 619   char *p;
 620
 621   /* The ELF symbol info doesn't include path names, so strip the path
 622      (if any) from the psymtab filename.  */
 623   while (0 != (p = strchr (filename, '/')))
 624     filename = p+1;
 625
 626   /* FIXME:  This linear search could speed up significantly
 627      if it was chained in the right order to match how we search it,
 628      and if we unchained when we found a match. */
 629   for (; maybe; maybe = maybe->next)
 630     {
 631       if (filename[0] == maybe->filename[0]
 632           && !strcmp (filename, maybe->filename))
 633         {
 634           /* We found a match.  But there might be several source files
 635              (from different directories) with the same name.  */
 636           if (0 == maybe->found)
 637             break;
 638           questionable = maybe;         /* Might use it later.  */
 639         }
 640     }
 641
 642   if (maybe == 0 && questionable != 0)
 643     {
 644       complain (&stab_info_questionable_complaint, filename);
 645       maybe = questionable;
 646     }
 647
 648   if (maybe)
 649     {
 650       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 651       maybe->found++;
 652       pst->section_offsets = (struct section_offsets *)
 653         obstack_alloc (&objfile -> psymbol_obstack,
 654                        sizeof (struct section_offsets) +
 655                sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1));
 656
 657       for (i = 0; i < SECT_OFF_MAX; i++)
 658         ANOFFSET (pst->section_offsets, i) = maybe->sections[i];
 659       return;
 660     }
 661
 662   /* We were unable to find any offsets for this file.  Complain.  */
 663   if (dbx->stab_section_info)           /* If there *is* any info, */
 664     complain (&stab_info_mismatch_complaint, filename);
 665 }
 666 \f
 667 /*  Register that we are able to handle ELF object file formats and DWARF
 668     debugging formats.
 669
 670     Unlike other object file formats, where the debugging information format
 671     is implied by the object file format, the ELF object file format and the
 672     DWARF debugging information format are two distinct, and potentially
 673     separate entities.  I.E. it is perfectly possible to have ELF objects
 674     with debugging formats other than DWARF.  And it is conceivable that the
 675     DWARF debugging format might be used with another object file format,
 676     like COFF, by simply using COFF's custom section feature.
 677
 678     GDB, and to a lesser extent BFD, should support the notion of separate
 679     object file formats and debugging information formats.  For now, we just
 680     use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
 681     object file format and the DWARF debugging format. */
 682
 683 static struct sym_fns elf_sym_fns =
 684 {
 685   "elf",                /* sym_name: name or name prefix of BFD target type */
 686   3,                    /* sym_namelen: number of significant sym_name chars */
 687   elf_new_init,         /* sym_new_init: init anything gbl to entire symtab */
 688   elf_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
 689   elf_symfile_read,     /* sym_read: read a symbol file into symtab */
 690   elf_symfile_finish,   /* sym_finish: finished with file, cleanup */
 691   elf_symfile_offsets,  /* sym_offsets:  Translate ext. to int. relocation */
 692   NULL                  /* next: pointer to next struct sym_fns */
 693 };
 694
 695 void
 696 _initialize_elfread ()
 697 {
 698   add_symtab_fns (&elf_sym_fns);
 699 }