gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2
   3    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    Written by Fred Fish at Cygnus Support.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "bfd.h"
  27 #include "gdb_string.h"
  28 #include "elf-bfd.h"
  29 #include "elf/mips.h"
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "buildsym.h"
  34 #include "stabsread.h"
  35 #include "gdb-stabs.h"
  36 #include "complaints.h"
  37 #include "demangle.h"
  38
  39 extern void _initialize_elfread (void);
  40
  41 /* The struct elfinfo is available only during ELF symbol table and
  42    psymtab reading.  It is destroyed at the completion of psymtab-reading.
  43    It's local to elf_symfile_read.  */
  44
  45 struct elfinfo
  46   {
  47     file_ptr dboffset;          /* Offset to dwarf debug section */
  48     unsigned int dbsize;        /* Size of dwarf debug section */
  49     file_ptr lnoffset;          /* Offset to dwarf line number section */
  50     unsigned int lnsize;        /* Size of dwarf line number section */
  51     asection *stabsect;         /* Section pointer for .stab section */
  52     asection *stabindexsect;    /* Section pointer for .stab.index section */
  53     asection *mdebugsect;       /* Section pointer for .mdebug section */
  54   };
  55
  56 static void free_elfinfo (void *);
  57
  58 /* We are called once per section from elf_symfile_read.  We
  59    need to examine each section we are passed, check to see
  60    if it is something we are interested in processing, and
  61    if so, stash away some access information for the section.
  62
  63    For now we recognize the dwarf debug information sections and
  64    line number sections from matching their section names.  The
  65    ELF definition is no real help here since it has no direct
  66    knowledge of DWARF (by design, so any debugging format can be
  67    used).
  68
  69    We also recognize the ".stab" sections used by the Sun compilers
  70    released with Solaris 2.
  71
  72    FIXME: The section names should not be hardwired strings (what
  73    should they be?  I don't think most object file formats have enough
  74    section flags to specify what kind of debug section it is
  75    -kingdon).  */
  76
  77 static void
  78 elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
  79 {
  80   register struct elfinfo *ei;
  81
  82   ei = (struct elfinfo *) eip;
  83   if (STREQ (sectp->name, ".debug"))
  84     {
  85       ei->dboffset = sectp->filepos;
  86       ei->dbsize = bfd_get_section_size_before_reloc (sectp);
  87     }
  88   else if (STREQ (sectp->name, ".line"))
  89     {
  90       ei->lnoffset = sectp->filepos;
  91       ei->lnsize = bfd_get_section_size_before_reloc (sectp);
  92     }
  93   else if (STREQ (sectp->name, ".stab"))
  94     {
  95       ei->stabsect = sectp;
  96     }
  97   else if (STREQ (sectp->name, ".stab.index"))
  98     {
  99       ei->stabindexsect = sectp;
 100     }
 101   else if (STREQ (sectp->name, ".mdebug"))
 102     {
 103       ei->mdebugsect = sectp;
 104     }
 105 }
 106
 107 #if 0                           /* Currently unused */
 108
 109 char *
 110 elf_interpreter (bfd *abfd)
 111 {
 112   sec_ptr interp_sec;
 113   unsigned size;
 114   char *interp = NULL;
 115
 116   interp_sec = bfd_get_section_by_name (abfd, ".interp");
 117   if (interp_sec)
 118     {
 119       size = bfd_section_size (abfd, interp_sec);
 120       interp = alloca (size);
 121       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr) 0,
 122                                     size))
 123         {
 124           interp = savestring (interp, size - 1);
 125         }
 126       else
 127         {
 128           interp = NULL;
 129         }
 130     }
 131   return (interp);
 132 }
 133
 134 #endif
 135
 136 static struct minimal_symbol *
 137 record_minimal_symbol_and_info (char *name, CORE_ADDR address,
 138                                 enum minimal_symbol_type ms_type, char *info,   /* FIXME, is this really char *? */
 139                                 asection *bfd_section, struct objfile *objfile)
 140 {
 141   if (ms_type == mst_text || ms_type == mst_file_text)
 142     address = SMASH_TEXT_ADDRESS (address);
 143
 144   return prim_record_minimal_symbol_and_info
 145     (name, address, ms_type, info, bfd_section->index, bfd_section, objfile);
 146 }
 147
 148 /*
 149
 150    LOCAL FUNCTION
 151
 152    elf_symtab_read -- read the symbol table of an ELF file
 153
 154    SYNOPSIS
 155
 156    void elf_symtab_read (struct objfile *objfile, int dynamic)
 157
 158    DESCRIPTION
 159
 160    Given an objfile and a flag that specifies whether or not the objfile
 161    is for an executable or not (may be shared library for example), add
 162    all the global function and data symbols to the minimal symbol table.
 163
 164    In stabs-in-ELF, as implemented by Sun, there are some local symbols
 165    defined in the ELF symbol table, which can be used to locate
 166    the beginnings of sections from each ".o" file that was linked to
 167    form the executable objfile.  We gather any such info and record it
 168    in data structures hung off the objfile's private data.
 169
 170  */
 171
 172 static void
 173 elf_symtab_read (struct objfile *objfile, int dynamic)
 174 {
 175   long storage_needed;
 176   asymbol *sym;
 177   asymbol **symbol_table;
 178   long number_of_symbols;
 179   long i;
 180   int index;
 181   struct cleanup *back_to;
 182   CORE_ADDR symaddr;
 183   CORE_ADDR offset;
 184   enum minimal_symbol_type ms_type;
 185   /* If sectinfo is nonNULL, it contains section info that should end up
 186      filed in the objfile.  */
 187   struct stab_section_info *sectinfo = NULL;
 188   /* If filesym is nonzero, it points to a file symbol, but we haven't
 189      seen any section info for it yet.  */
 190   asymbol *filesym = 0;
 191 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 192   /* Name of filesym, as saved on the symbol_obstack.  */
 193   char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack);
 194 #endif
 195   struct dbx_symfile_info *dbx = objfile->sym_stab_info;
 196   unsigned long size;
 197   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 198
 199   if (dynamic)
 200     {
 201       storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 202
 203       /* Nothing to be done if there is no dynamic symtab.  */
 204       if (storage_needed < 0)
 205         return;
 206     }
 207   else
 208     {
 209       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 210       if (storage_needed < 0)
 211         error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd),
 212                bfd_errmsg (bfd_get_error ()));
 213     }
 214   if (storage_needed > 0)
 215     {
 216       symbol_table = (asymbol **) xmalloc (storage_needed);
 217       back_to = make_cleanup (xfree, symbol_table);
 218       if (dynamic)
 219         number_of_symbols = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 220                                                              symbol_table);
 221       else
 222         number_of_symbols = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 223       if (number_of_symbols < 0)
 224         error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd),
 225                bfd_errmsg (bfd_get_error ()));
 226
 227       for (i = 0; i < number_of_symbols; i++)
 228         {
 229           sym = symbol_table[i];
 230           if (sym->name == NULL || *sym->name == '\0')
 231             {
 232               /* Skip names that don't exist (shouldn't happen), or names
 233                  that are null strings (may happen). */
 234               continue;
 235             }
 236
 237           offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 238           if (dynamic
 239               && sym->section == &bfd_und_section
 240               && (sym->flags & BSF_FUNCTION))
 241             {
 242               struct minimal_symbol *msym;
 243
 244               /* Symbol is a reference to a function defined in
 245                  a shared library.
 246                  If its value is non zero then it is usually the address
 247                  of the corresponding entry in the procedure linkage table,
 248                  plus the desired section offset.
 249                  If its value is zero then the dynamic linker has to resolve
 250                  the symbol. We are unable to find any meaningful address
 251                  for this symbol in the executable file, so we skip it.  */
 252               symaddr = sym->value;
 253               if (symaddr == 0)
 254                 continue;
 255               symaddr += offset;
 256               msym = record_minimal_symbol_and_info
 257                 ((char *) sym->name, symaddr,
 258                  mst_solib_trampoline, NULL, sym->section, objfile);
 259 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 260               if (msym != NULL)
 261                 msym->filename = filesymname;
 262 #endif
 263               continue;
 264             }
 265
 266           /* If it is a nonstripped executable, do not enter dynamic
 267              symbols, as the dynamic symbol table is usually a subset
 268              of the main symbol table.  */
 269           if (dynamic && !stripped)
 270             continue;
 271           if (sym->flags & BSF_FILE)
 272             {
 273               /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 274                  Chain any old one onto the objfile; remember new sym.  */
 275               if (sectinfo != NULL)
 276                 {
 277                   sectinfo->next = dbx->stab_section_info;
 278                   dbx->stab_section_info = sectinfo;
 279                   sectinfo = NULL;
 280                 }
 281               filesym = sym;
 282 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 283               filesymname =
 284                 obsavestring ((char *) filesym->name, strlen (filesym->name),
 285                               &objfile->symbol_obstack);
 286 #endif
 287             }
 288           else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 289             {
 290               struct minimal_symbol *msym;
 291
 292               /* Select global/local/weak symbols.  Note that bfd puts abs
 293                  symbols in their own section, so all symbols we are
 294                  interested in will have a section. */
 295               /* Bfd symbols are section relative. */
 296               symaddr = sym->value + sym->section->vma;
 297               /* Relocate all non-absolute symbols by the section offset.  */
 298               if (sym->section != &bfd_abs_section)
 299                 {
 300                   symaddr += offset;
 301                 }
 302               /* For non-absolute symbols, use the type of the section
 303                  they are relative to, to intuit text/data.  Bfd provides
 304                  no way of figuring this out for absolute symbols. */
 305               if (sym->section == &bfd_abs_section)
 306                 {
 307                   /* This is a hack to get the minimal symbol type
 308                      right for Irix 5, which has absolute addresses
 309                      with special section indices for dynamic symbols. */
 310                   unsigned short shndx =
 311                   ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 312
 313                   switch (shndx)
 314                     {
 315                     case SHN_MIPS_TEXT:
 316                       ms_type = mst_text;
 317                       break;
 318                     case SHN_MIPS_DATA:
 319                       ms_type = mst_data;
 320                       break;
 321                     case SHN_MIPS_ACOMMON:
 322                       ms_type = mst_bss;
 323                       break;
 324                     default:
 325                       ms_type = mst_abs;
 326                     }
 327
 328                   /* If it is an Irix dynamic symbol, skip section name
 329                      symbols, relocate all others by section offset. */
 330                   if (ms_type != mst_abs)
 331                     {
 332                       if (sym->name[0] == '.')
 333                         continue;
 334                       symaddr += offset;
 335                     }
 336                 }
 337               else if (sym->section->flags & SEC_CODE)
 338                 {
 339                   if (sym->flags & BSF_GLOBAL)
 340                     {
 341                       ms_type = mst_text;
 342                     }
 343                   else if ((sym->name[0] == '.' && sym->name[1] == 'L')
 344                            || ((sym->flags & BSF_LOCAL)
 345                                && sym->name[0] == '$'
 346                                && sym->name[1] == 'L'))
 347                     /* Looks like a compiler-generated label.  Skip
 348                        it.  The assembler should be skipping these (to
 349                        keep executables small), but apparently with
 350                        gcc on the (deleted) delta m88k SVR4, it loses.
 351                        So to have us check too should be harmless (but
 352                        I encourage people to fix this in the assembler
 353                        instead of adding checks here).  */
 354                     continue;
 355                   else
 356                     {
 357                       ms_type = mst_file_text;
 358                     }
 359                 }
 360               else if (sym->section->flags & SEC_ALLOC)
 361                 {
 362                   if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 363                     {
 364                       if (sym->section->flags & SEC_LOAD)
 365                         {
 366                           ms_type = mst_data;
 367                         }
 368                       else
 369                         {
 370                           ms_type = mst_bss;
 371                         }
 372                     }
 373                   else if (sym->flags & BSF_LOCAL)
 374                     {
 375                       /* Named Local variable in a Data section.  Check its
 376                          name for stabs-in-elf.  The STREQ macro checks the
 377                          first character inline, so we only actually do a
 378                          strcmp function call on names that start with 'B'
 379                          or 'D' */
 380                       index = SECT_OFF_MAX;
 381                       if (STREQ ("Bbss.bss", sym->name))
 382                         {
 383                           index = SECT_OFF_BSS (objfile);
 384                         }
 385                       else if (STREQ ("Ddata.data", sym->name))
 386                         {
 387                           index = SECT_OFF_DATA (objfile);
 388                         }
 389                       else if (STREQ ("Drodata.rodata", sym->name))
 390                         {
 391                           index = SECT_OFF_RODATA (objfile);
 392                         }
 393                       if (index != SECT_OFF_MAX)
 394                         {
 395                           /* Found a special local symbol.  Allocate a
 396                              sectinfo, if needed, and fill it in.  */
 397                           if (sectinfo == NULL)
 398                             {
 399                               sectinfo = (struct stab_section_info *)
 400                                 xmmalloc (objfile->md, sizeof (*sectinfo));
 401                               memset (sectinfo, 0,
 402                                       sizeof (*sectinfo));
 403                               if (filesym == NULL)
 404                                 {
 405                                   complaint (&symfile_complaints,
 406                                              "elf/stab section information %s without a preceding file symbol",
 407                                              sym->name);
 408                                 }
 409                               else
 410                                 {
 411                                   sectinfo->filename =
 412                                     (char *) filesym->name;
 413                                 }
 414                             }
 415                           if (index != -1)
 416                             {
 417                               if (sectinfo->sections[index] != 0)
 418                                 {
 419                                   complaint (&symfile_complaints,
 420                                              "duplicated elf/stab section information for %s",
 421                                              sectinfo->filename);
 422                                 }
 423                             }
 424                           else
 425                             internal_error (__FILE__, __LINE__,
 426                                             "Section index uninitialized.");
 427                           /* Bfd symbols are section relative. */
 428                           symaddr = sym->value + sym->section->vma;
 429                           /* Relocate non-absolute symbols by the section offset. */
 430                           if (sym->section != &bfd_abs_section)
 431                             {
 432                               symaddr += offset;
 433                             }
 434                           if (index != -1)
 435                             sectinfo->sections[index] = symaddr;
 436                           else
 437                             internal_error (__FILE__, __LINE__,
 438                                             "Section index uninitialized.");
 439                           /* The special local symbols don't go in the
 440                              minimal symbol table, so ignore this one. */
 441                           continue;
 442                         }
 443                       /* Not a special stabs-in-elf symbol, do regular
 444                          symbol processing. */
 445                       if (sym->section->flags & SEC_LOAD)
 446                         {
 447                           ms_type = mst_file_data;
 448                         }
 449                       else
 450                         {
 451                           ms_type = mst_file_bss;
 452                         }
 453                     }
 454                   else
 455                     {
 456                       ms_type = mst_unknown;
 457                     }
 458                 }
 459               else
 460                 {
 461                   /* FIXME:  Solaris2 shared libraries include lots of
 462                      odd "absolute" and "undefined" symbols, that play
 463                      hob with actions like finding what function the PC
 464                      is in.  Ignore them if they aren't text, data, or bss.  */
 465                   /* ms_type = mst_unknown; */
 466                   continue;     /* Skip this symbol. */
 467                 }
 468               /* Pass symbol size field in via BFD.  FIXME!!!  */
 469               size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 470               msym = record_minimal_symbol_and_info
 471                 ((char *) sym->name, symaddr,
 472                  ms_type, (void *) size, sym->section, objfile);
 473 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 474               if (msym != NULL)
 475                 msym->filename = filesymname;
 476 #endif
 477               ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
 478             }
 479         }
 480       do_cleanups (back_to);
 481     }
 482 }
 483
 484 /* Scan and build partial symbols for a symbol file.
 485    We have been initialized by a call to elf_symfile_init, which
 486    currently does nothing.
 487
 488    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 489    in each section.  We simplify it down to a single offset for all
 490    symbols.  FIXME.
 491
 492    MAINLINE is true if we are reading the main symbol
 493    table (as opposed to a shared lib or dynamically loaded file).
 494
 495    This function only does the minimum work necessary for letting the
 496    user "name" things symbolically; it does not read the entire symtab.
 497    Instead, it reads the external and static symbols and puts them in partial
 498    symbol tables.  When more extensive information is requested of a
 499    file, the corresponding partial symbol table is mutated into a full
 500    fledged symbol table by going back and reading the symbols
 501    for real.
 502
 503    We look for sections with specific names, to tell us what debug
 504    format to look for:  FIXME!!!
 505
 506    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 507    elfstab_build_psymtabs() handles STABS symbols;
 508    mdebug_build_psymtabs() handles ECOFF debugging information.
 509
 510    Note that ELF files have a "minimal" symbol table, which looks a lot
 511    like a COFF symbol table, but has only the minimal information necessary
 512    for linking.  We process this also, and use the information to
 513    build gdb's minimal symbol table.  This gives us some minimal debugging
 514    capability even for files compiled without -g.  */
 515
 516 static void
 517 elf_symfile_read (struct objfile *objfile, int mainline)
 518 {
 519   bfd *abfd = objfile->obfd;
 520   struct elfinfo ei;
 521   struct cleanup *back_to;
 522   CORE_ADDR offset;
 523
 524   init_minimal_symbol_collection ();
 525   back_to = make_cleanup_discard_minimal_symbols ();
 526
 527   memset ((char *) &ei, 0, sizeof (ei));
 528
 529   /* Allocate struct to keep track of the symfile */
 530   objfile->sym_stab_info = (struct dbx_symfile_info *)
 531     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
 532   memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 533   make_cleanup (free_elfinfo, (void *) objfile);
 534
 535   /* Process the normal ELF symbol table first.  This may write some
 536      chain of info into the dbx_symfile_info in objfile->sym_stab_info,
 537      which can later be used by elfstab_offset_sections.  */
 538
 539   elf_symtab_read (objfile, 0);
 540
 541   /* Add the dynamic symbols.  */
 542
 543   elf_symtab_read (objfile, 1);
 544
 545   /* Install any minimal symbols that have been collected as the current
 546      minimal symbols for this objfile.  The debug readers below this point
 547      should not generate new minimal symbols; if they do it's their
 548      responsibility to install them.  "mdebug" appears to be the only one
 549      which will do this.  */
 550
 551   install_minimal_symbols (objfile);
 552   do_cleanups (back_to);
 553
 554   /* Now process debugging information, which is contained in
 555      special ELF sections. */
 556
 557   /* If we are reinitializing, or if we have never loaded syms yet,
 558      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 559      functions do not all also re-initialize the psymbol table. */
 560   if (mainline)
 561     {
 562       init_psymbol_list (objfile, 0);
 563       mainline = 0;
 564     }
 565
 566   /* We first have to find them... */
 567   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 568
 569   /* ELF debugging information is inserted into the psymtab in the
 570      order of least informative first - most informative last.  Since
 571      the psymtab table is searched `most recent insertion first' this
 572      increases the probability that more detailed debug information
 573      for a section is found.
 574
 575      For instance, an object file might contain both .mdebug (XCOFF)
 576      and .debug_info (DWARF2) sections then .mdebug is inserted first
 577      (searched last) and DWARF2 is inserted last (searched first).  If
 578      we don't do this then the XCOFF info is found first - for code in
 579      an included file XCOFF info is useless. */
 580
 581   if (ei.mdebugsect)
 582     {
 583       const struct ecoff_debug_swap *swap;
 584
 585       /* .mdebug section, presumably holding ECOFF debugging
 586          information.  */
 587       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 588       if (swap)
 589         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 590     }
 591   if (ei.stabsect)
 592     {
 593       asection *str_sect;
 594
 595       /* Stab sections have an associated string table that looks like
 596          a separate section.  */
 597       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 598
 599       /* FIXME should probably warn about a stab section without a stabstr.  */
 600       if (str_sect)
 601         elfstab_build_psymtabs (objfile,
 602                                 mainline,
 603                                 ei.stabsect,
 604                                 str_sect->filepos,
 605                                 bfd_section_size (abfd, str_sect));
 606     }
 607   if (dwarf2_has_info (abfd))
 608     {
 609       /* DWARF 2 sections */
 610       dwarf2_build_psymtabs (objfile, mainline);
 611     }
 612   else if (ei.dboffset && ei.lnoffset)
 613     {
 614       /* DWARF sections */
 615       dwarf_build_psymtabs (objfile,
 616                             mainline,
 617                             ei.dboffset, ei.dbsize,
 618                             ei.lnoffset, ei.lnsize);
 619     }
 620
 621   if (DWARF2_BUILD_FRAME_INFO_P ())
 622     DWARF2_BUILD_FRAME_INFO(objfile);
 623 }
 624
 625 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 626    stab_section_info's, that might be dangling from it.  */
 627
 628 static void
 629 free_elfinfo (void *objp)
 630 {
 631   struct objfile *objfile = (struct objfile *) objp;
 632   struct dbx_symfile_info *dbxinfo = objfile->sym_stab_info;
 633   struct stab_section_info *ssi, *nssi;
 634
 635   ssi = dbxinfo->stab_section_info;
 636   while (ssi)
 637     {
 638       nssi = ssi->next;
 639       xmfree (objfile->md, ssi);
 640       ssi = nssi;
 641     }
 642
 643   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 644 }
 645
 646
 647 /* Initialize anything that needs initializing when a completely new symbol
 648    file is specified (not just adding some symbols from another file, e.g. a
 649    shared library).
 650
 651    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 652
 653 static void
 654 elf_new_init (struct objfile *ignore)
 655 {
 656   stabsread_new_init ();
 657   buildsym_new_init ();
 658 }
 659
 660 /* Perform any local cleanups required when we are done with a particular
 661    objfile.  I.E, we are in the process of discarding all symbol information
 662    for an objfile, freeing up all memory held for it, and unlinking the
 663    objfile struct from the global list of known objfiles. */
 664
 665 static void
 666 elf_symfile_finish (struct objfile *objfile)
 667 {
 668   if (objfile->sym_stab_info != NULL)
 669     {
 670       xmfree (objfile->md, objfile->sym_stab_info);
 671     }
 672 }
 673
 674 /* ELF specific initialization routine for reading symbols.
 675
 676    It is passed a pointer to a struct sym_fns which contains, among other
 677    things, the BFD for the file whose symbols are being read, and a slot for
 678    a pointer to "private data" which we can fill with goodies.
 679
 680    For now at least, we have nothing in particular to do, so this function is
 681    just a stub. */
 682
 683 static void
 684 elf_symfile_init (struct objfile *objfile)
 685 {
 686   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 687      find this causes a significant slowdown in gdb then we could
 688      set it in the debug symbol readers only when necessary.  */
 689   objfile->flags |= OBJF_REORDERED;
 690 }
 691
 692 /* When handling an ELF file that contains Sun STABS debug info,
 693    some of the debug info is relative to the particular chunk of the
 694    section that was generated in its individual .o file.  E.g.
 695    offsets to static variables are relative to the start of the data
 696    segment *for that module before linking*.  This information is
 697    painfully squirreled away in the ELF symbol table as local symbols
 698    with wierd names.  Go get 'em when needed.  */
 699
 700 void
 701 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 702 {
 703   char *filename = pst->filename;
 704   struct dbx_symfile_info *dbx = objfile->sym_stab_info;
 705   struct stab_section_info *maybe = dbx->stab_section_info;
 706   struct stab_section_info *questionable = 0;
 707   int i;
 708   char *p;
 709
 710   /* The ELF symbol info doesn't include path names, so strip the path
 711      (if any) from the psymtab filename.  */
 712   while (0 != (p = strchr (filename, '/')))
 713     filename = p + 1;
 714
 715   /* FIXME:  This linear search could speed up significantly
 716      if it was chained in the right order to match how we search it,
 717      and if we unchained when we found a match. */
 718   for (; maybe; maybe = maybe->next)
 719     {
 720       if (filename[0] == maybe->filename[0]
 721           && STREQ (filename, maybe->filename))
 722         {
 723           /* We found a match.  But there might be several source files
 724              (from different directories) with the same name.  */
 725           if (0 == maybe->found)
 726             break;
 727           questionable = maybe; /* Might use it later.  */
 728         }
 729     }
 730
 731   if (maybe == 0 && questionable != 0)
 732     {
 733       complaint (&symfile_complaints,
 734                  "elf/stab section information questionable for %s", filename);
 735       maybe = questionable;
 736     }
 737
 738   if (maybe)
 739     {
 740       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 741       maybe->found++;
 742       pst->section_offsets = (struct section_offsets *)
 743         obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
 744       for (i = 0; i < SECT_OFF_MAX; i++)
 745         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 746       return;
 747     }
 748
 749   /* We were unable to find any offsets for this file.  Complain.  */
 750   if (dbx->stab_section_info)   /* If there *is* any info, */
 751     complaint (&symfile_complaints,
 752                "elf/stab section information missing for %s", filename);
 753 }
 754 \f
 755 /* Register that we are able to handle ELF object file formats.  */
 756
 757 static struct sym_fns elf_sym_fns =
 758 {
 759   bfd_target_elf_flavour,
 760   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 761   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 762   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 763   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 764   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 765   NULL                          /* next: pointer to next struct sym_fns */
 766 };
 767
 768 void
 769 _initialize_elfread (void)
 770 {
 771   add_symtab_fns (&elf_sym_fns);
 772 }