gdb/elfread.c

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