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