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