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                       /* Named Local variable in a Data section.  Check its
 376                          name for stabs-in-elf.  The STREQ macro checks the
 377                          first character inline, so we only actually do a
 378                          strcmp function call on names that start with 'B'
 379                          or 'D' */
 380                       index = SECT_OFF_MAX;
 381                       if (STREQ ("Bbss.bss", sym->name))
 382                         {
 383                           index = SECT_OFF_BSS (objfile);
 384                         }
 385                       else if (STREQ ("Ddata.data", sym->name))
 386                         {
 387                           index = SECT_OFF_DATA (objfile);
 388                         }
 389                       else if (STREQ ("Drodata.rodata", sym->name))
 390                         {
 391                           index = SECT_OFF_RODATA (objfile);
 392                         }
 393                       if (index != SECT_OFF_MAX)
 394                         {
 395                           /* Found a special local symbol.  Allocate a
 396                              sectinfo, if needed, and fill it in.  */
 397                           if (sectinfo == NULL)
 398                             {
 399                               sectinfo = (struct stab_section_info *)
 400                                 xmmalloc (objfile->md, sizeof (*sectinfo));
 401                               memset (sectinfo, 0,
 402                                       sizeof (*sectinfo));
 403                               if (filesym == NULL)
 404                                 {
 405                                   complaint (&symfile_complaints,
 406                                              "elf/stab section information %s without a preceding file symbol",
 407                                              sym->name);
 408                                 }
 409                               else
 410                                 {
 411                                   sectinfo->filename =
 412                                     (char *) filesym->name;
 413                                 }
 414                             }
 415                           if (index != -1)
 416                             {
 417                               if (sectinfo->sections[index] != 0)
 418                                 {
 419                                   complaint (&symfile_complaints,
 420                                              "duplicated elf/stab section information for %s",
 421                                              sectinfo->filename);
 422                                 }
 423                             }
 424                           else
 425                             internal_error (__FILE__, __LINE__,
 426                                             "Section index uninitialized.");
 427                           /* Bfd symbols are section relative. */
 428                           symaddr = sym->value + sym->section->vma;
 429                           /* Relocate non-absolute symbols by the section offset. */
 430                           if (sym->section != &bfd_abs_section)
 431                             {
 432                               symaddr += offset;
 433                             }
 434                           if (index != -1)
 435                             sectinfo->sections[index] = symaddr;
 436                           else
 437                             internal_error (__FILE__, __LINE__,
 438                                             "Section index uninitialized.");
 439                           /* The special local symbols don't go in the
 440                              minimal symbol table, so ignore this one. */
 441                           continue;
 442                         }
 443                       /* Not a special stabs-in-elf symbol, do regular
 444                          symbol processing. */
 445                       if (sym->section->flags & SEC_LOAD)
 446                         {
 447                           ms_type = mst_file_data;
 448                         }
 449                       else
 450                         {
 451                           ms_type = mst_file_bss;
 452                         }
 453                     }
 454                   else
 455                     {
 456                       ms_type = mst_unknown;
 457                     }
 458                 }
 459               else
 460                 {
 461                   /* FIXME:  Solaris2 shared libraries include lots of
 462                      odd "absolute" and "undefined" symbols, that play
 463                      hob with actions like finding what function the PC
 464                      is in.  Ignore them if they aren't text, data, or bss.  */
 465                   /* ms_type = mst_unknown; */
 466                   continue;     /* Skip this symbol. */
 467                 }
 468               /* Pass symbol size field in via BFD.  FIXME!!!  */
 469               size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 470               msym = record_minimal_symbol_and_info
 471                 ((char *) sym->name, symaddr,
 472                  ms_type, (void *) size, sym->section, objfile);
 473 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 474               if (msym != NULL)
 475                 msym->filename = filesymname;
 476 #endif
 477               ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
 478             }
 479         }
 480       do_cleanups (back_to);
 481     }
 482 }
 483
 484 /* Scan and build partial symbols for a symbol file.
 485    We have been initialized by a call to elf_symfile_init, which
 486    currently does nothing.
 487
 488    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 489    in each section.  We simplify it down to a single offset for all
 490    symbols.  FIXME.
 491
 492    MAINLINE is true if we are reading the main symbol
 493    table (as opposed to a shared lib or dynamically loaded file).
 494
 495    This function only does the minimum work necessary for letting the
 496    user "name" things symbolically; it does not read the entire symtab.
 497    Instead, it reads the external and static symbols and puts them in partial
 498    symbol tables.  When more extensive information is requested of a
 499    file, the corresponding partial symbol table is mutated into a full
 500    fledged symbol table by going back and reading the symbols
 501    for real.
 502
 503    We look for sections with specific names, to tell us what debug
 504    format to look for:  FIXME!!!
 505
 506    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 507    elfstab_build_psymtabs() handles STABS symbols;
 508    mdebug_build_psymtabs() handles ECOFF debugging information.
 509
 510    Note that ELF files have a "minimal" symbol table, which looks a lot
 511    like a COFF symbol table, but has only the minimal information necessary
 512    for linking.  We process this also, and use the information to
 513    build gdb's minimal symbol table.  This gives us some minimal debugging
 514    capability even for files compiled without -g.  */
 515
 516 static void
 517 elf_symfile_read (struct objfile *objfile, int mainline)
 518 {
 519   bfd *abfd = objfile->obfd;
 520   struct elfinfo ei;
 521   struct cleanup *back_to;
 522   CORE_ADDR offset;
 523
 524   init_minimal_symbol_collection ();
 525   back_to = make_cleanup_discard_minimal_symbols ();
 526
 527   memset ((char *) &ei, 0, sizeof (ei));
 528
 529   /* Allocate struct to keep track of the symfile */
 530   objfile->sym_stab_info = (struct dbx_symfile_info *)
 531     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
 532   memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 533   make_cleanup (free_elfinfo, (void *) objfile);
 534
 535   /* Process the normal ELF symbol table first.  This may write some
 536      chain of info into the dbx_symfile_info in objfile->sym_stab_info,
 537      which can later be used by elfstab_offset_sections.  */
 538
 539   elf_symtab_read (objfile, 0);
 540
 541   /* Add the dynamic symbols.  */
 542
 543   elf_symtab_read (objfile, 1);
 544
 545   /* Now process debugging information, which is contained in
 546      special ELF sections. */
 547
 548   /* If we are reinitializing, or if we have never loaded syms yet,
 549      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 550      functions do not all also re-initialize the psymbol table. */
 551   if (mainline)
 552     {
 553       init_psymbol_list (objfile, 0);
 554       mainline = 0;
 555     }
 556
 557   /* We first have to find them... */
 558   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 559
 560   /* ELF debugging information is inserted into the psymtab in the
 561      order of least informative first - most informative last.  Since
 562      the psymtab table is searched `most recent insertion first' this
 563      increases the probability that more detailed debug information
 564      for a section is found.
 565
 566      For instance, an object file might contain both .mdebug (XCOFF)
 567      and .debug_info (DWARF2) sections then .mdebug is inserted first
 568      (searched last) and DWARF2 is inserted last (searched first).  If
 569      we don't do this then the XCOFF info is found first - for code in
 570      an included file XCOFF info is useless. */
 571
 572   if (ei.mdebugsect)
 573     {
 574       const struct ecoff_debug_swap *swap;
 575
 576       /* .mdebug section, presumably holding ECOFF debugging
 577          information.  */
 578       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 579       if (swap)
 580         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 581     }
 582   if (ei.stabsect)
 583     {
 584       asection *str_sect;
 585
 586       /* Stab sections have an associated string table that looks like
 587          a separate section.  */
 588       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 589
 590       /* FIXME should probably warn about a stab section without a stabstr.  */
 591       if (str_sect)
 592         elfstab_build_psymtabs (objfile,
 593                                 mainline,
 594                                 ei.stabsect->filepos,
 595                                 bfd_section_size (abfd, ei.stabsect),
 596                                 str_sect->filepos,
 597                                 bfd_section_size (abfd, str_sect));
 598     }
 599   if (dwarf2_has_info (abfd))
 600     {
 601       /* DWARF 2 sections */
 602       dwarf2_build_psymtabs (objfile, mainline);
 603     }
 604   else if (ei.dboffset && ei.lnoffset)
 605     {
 606       /* DWARF sections */
 607       dwarf_build_psymtabs (objfile,
 608                             mainline,
 609                             ei.dboffset, ei.dbsize,
 610                             ei.lnoffset, ei.lnsize);
 611     }
 612
 613   if (DWARF2_BUILD_FRAME_INFO_P ())
 614     DWARF2_BUILD_FRAME_INFO(objfile);
 615
 616   /* Install any minimal symbols that have been collected as the current
 617      minimal symbols for this objfile. */
 618
 619   install_minimal_symbols (objfile);
 620
 621   do_cleanups (back_to);
 622 }
 623
 624 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 625    stab_section_info's, that might be dangling from it.  */
 626
 627 static void
 628 free_elfinfo (void *objp)
 629 {
 630   struct objfile *objfile = (struct objfile *) objp;
 631   struct dbx_symfile_info *dbxinfo = objfile->sym_stab_info;
 632   struct stab_section_info *ssi, *nssi;
 633
 634   ssi = dbxinfo->stab_section_info;
 635   while (ssi)
 636     {
 637       nssi = ssi->next;
 638       xmfree (objfile->md, ssi);
 639       ssi = nssi;
 640     }
 641
 642   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 643 }
 644
 645
 646 /* Initialize anything that needs initializing when a completely new symbol
 647    file is specified (not just adding some symbols from another file, e.g. a
 648    shared library).
 649
 650    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 651
 652 static void
 653 elf_new_init (struct objfile *ignore)
 654 {
 655   stabsread_new_init ();
 656   buildsym_new_init ();
 657 }
 658
 659 /* Perform any local cleanups required when we are done with a particular
 660    objfile.  I.E, we are in the process of discarding all symbol information
 661    for an objfile, freeing up all memory held for it, and unlinking the
 662    objfile struct from the global list of known objfiles. */
 663
 664 static void
 665 elf_symfile_finish (struct objfile *objfile)
 666 {
 667   if (objfile->sym_stab_info != NULL)
 668     {
 669       xmfree (objfile->md, objfile->sym_stab_info);
 670     }
 671 }
 672
 673 /* ELF specific initialization routine for reading symbols.
 674
 675    It is passed a pointer to a struct sym_fns which contains, among other
 676    things, the BFD for the file whose symbols are being read, and a slot for
 677    a pointer to "private data" which we can fill with goodies.
 678
 679    For now at least, we have nothing in particular to do, so this function is
 680    just a stub. */
 681
 682 static void
 683 elf_symfile_init (struct objfile *objfile)
 684 {
 685   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 686      find this causes a significant slowdown in gdb then we could
 687      set it in the debug symbol readers only when necessary.  */
 688   objfile->flags |= OBJF_REORDERED;
 689 }
 690
 691 /* When handling an ELF file that contains Sun STABS debug info,
 692    some of the debug info is relative to the particular chunk of the
 693    section that was generated in its individual .o file.  E.g.
 694    offsets to static variables are relative to the start of the data
 695    segment *for that module before linking*.  This information is
 696    painfully squirreled away in the ELF symbol table as local symbols
 697    with wierd names.  Go get 'em when needed.  */
 698
 699 void
 700 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 701 {
 702   char *filename = pst->filename;
 703   struct dbx_symfile_info *dbx = objfile->sym_stab_info;
 704   struct stab_section_info *maybe = dbx->stab_section_info;
 705   struct stab_section_info *questionable = 0;
 706   int i;
 707   char *p;
 708
 709   /* The ELF symbol info doesn't include path names, so strip the path
 710      (if any) from the psymtab filename.  */
 711   while (0 != (p = strchr (filename, '/')))
 712     filename = p + 1;
 713
 714   /* FIXME:  This linear search could speed up significantly
 715      if it was chained in the right order to match how we search it,
 716      and if we unchained when we found a match. */
 717   for (; maybe; maybe = maybe->next)
 718     {
 719       if (filename[0] == maybe->filename[0]
 720           && STREQ (filename, maybe->filename))
 721         {
 722           /* We found a match.  But there might be several source files
 723              (from different directories) with the same name.  */
 724           if (0 == maybe->found)
 725             break;
 726           questionable = maybe; /* Might use it later.  */
 727         }
 728     }
 729
 730   if (maybe == 0 && questionable != 0)
 731     {
 732       complaint (&symfile_complaints,
 733                  "elf/stab section information questionable for %s", filename);
 734       maybe = questionable;
 735     }
 736
 737   if (maybe)
 738     {
 739       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 740       maybe->found++;
 741       pst->section_offsets = (struct section_offsets *)
 742         obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
 743       for (i = 0; i < SECT_OFF_MAX; i++)
 744         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 745       return;
 746     }
 747
 748   /* We were unable to find any offsets for this file.  Complain.  */
 749   if (dbx->stab_section_info)   /* If there *is* any info, */
 750     complaint (&symfile_complaints,
 751                "elf/stab section information missing for %s", filename);
 752 }
 753 \f
 754 /* Register that we are able to handle ELF object file formats.  */
 755
 756 static struct sym_fns elf_sym_fns =
 757 {
 758   bfd_target_elf_flavour,
 759   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 760   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 761   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 762   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 763   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 764   NULL                          /* next: pointer to next struct sym_fns */
 765 };
 766
 767 void
 768 _initialize_elfread (void)
 769 {
 770   add_symtab_fns (&elf_sym_fns);
 771 }