gdb/elfread.c

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