gdb/elfread.c

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