gdb/elfread.c

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