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