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