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