gdb/elfread.c

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