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