gdb/elfread.c

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