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