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