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               ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
 520             }
 521         }
 522       do_cleanups (back_to);
 523     }
 524 }
 525
 526 /* Scan and build partial symbols for a symbol file.
 527    We have been initialized by a call to elf_symfile_init, which
 528    currently does nothing.
 529
 530    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 531    in each section.  We simplify it down to a single offset for all
 532    symbols.  FIXME.
 533
 534    MAINLINE is true if we are reading the main symbol
 535    table (as opposed to a shared lib or dynamically loaded file).
 536
 537    This function only does the minimum work necessary for letting the
 538    user "name" things symbolically; it does not read the entire symtab.
 539    Instead, it reads the external and static symbols and puts them in partial
 540    symbol tables.  When more extensive information is requested of a
 541    file, the corresponding partial symbol table is mutated into a full
 542    fledged symbol table by going back and reading the symbols
 543    for real.
 544
 545    We look for sections with specific names, to tell us what debug
 546    format to look for:  FIXME!!!
 547
 548    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 549    elfstab_build_psymtabs() handles STABS symbols;
 550    mdebug_build_psymtabs() handles ECOFF debugging information.
 551
 552    Note that ELF files have a "minimal" symbol table, which looks a lot
 553    like a COFF symbol table, but has only the minimal information necessary
 554    for linking.  We process this also, and use the information to
 555    build gdb's minimal symbol table.  This gives us some minimal debugging
 556    capability even for files compiled without -g.  */
 557
 558 static void
 559 elf_symfile_read (struct objfile *objfile, int mainline)
 560 {
 561   bfd *abfd = objfile->obfd;
 562   struct elfinfo ei;
 563   struct cleanup *back_to;
 564   CORE_ADDR offset;
 565
 566   init_minimal_symbol_collection ();
 567   back_to = make_cleanup_discard_minimal_symbols ();
 568
 569   memset ((char *) &ei, 0, sizeof (ei));
 570
 571   /* Allocate struct to keep track of the symfile */
 572   objfile->sym_stab_info = (struct dbx_symfile_info *)
 573     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
 574   memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 575   make_cleanup (free_elfinfo, (PTR) objfile);
 576
 577   /* Process the normal ELF symbol table first.  This may write some
 578      chain of info into the dbx_symfile_info in objfile->sym_stab_info,
 579      which can later be used by elfstab_offset_sections.  */
 580
 581   elf_symtab_read (objfile, 0);
 582
 583   /* Add the dynamic symbols.  */
 584
 585   elf_symtab_read (objfile, 1);
 586
 587   /* Now process debugging information, which is contained in
 588      special ELF sections. */
 589
 590   /* If we are reinitializing, or if we have never loaded syms yet,
 591      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 592      functions do not all also re-initialize the psymbol table. */
 593   if (mainline)
 594     {
 595       init_psymbol_list (objfile, 0);
 596       mainline = 0;
 597     }
 598
 599   /* We first have to find them... */
 600   bfd_map_over_sections (abfd, elf_locate_sections, (PTR) & ei);
 601
 602   /* ELF debugging information is inserted into the psymtab in the
 603      order of least informative first - most informative last.  Since
 604      the psymtab table is searched `most recent insertion first' this
 605      increases the probability that more detailed debug information
 606      for a section is found.
 607
 608      For instance, an object file might contain both .mdebug (XCOFF)
 609      and .debug_info (DWARF2) sections then .mdebug is inserted first
 610      (searched last) and DWARF2 is inserted last (searched first).  If
 611      we don't do this then the XCOFF info is found first - for code in
 612      an included file XCOFF info is useless. */
 613
 614   if (ei.mdebugsect)
 615     {
 616       const struct ecoff_debug_swap *swap;
 617
 618       /* .mdebug section, presumably holding ECOFF debugging
 619          information.  */
 620       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 621       if (swap)
 622         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 623     }
 624   if (ei.stabsect)
 625     {
 626       asection *str_sect;
 627
 628       /* Stab sections have an associated string table that looks like
 629          a separate section.  */
 630       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 631
 632       /* FIXME should probably warn about a stab section without a stabstr.  */
 633       if (str_sect)
 634         elfstab_build_psymtabs (objfile,
 635                                 mainline,
 636                                 ei.stabsect->filepos,
 637                                 bfd_section_size (abfd, ei.stabsect),
 638                                 str_sect->filepos,
 639                                 bfd_section_size (abfd, str_sect));
 640     }
 641   if (dwarf2_has_info (abfd))
 642     {
 643       /* DWARF 2 sections */
 644       dwarf2_build_psymtabs (objfile, mainline);
 645     }
 646   else if (ei.dboffset && ei.lnoffset)
 647     {
 648       /* DWARF sections */
 649       dwarf_build_psymtabs (objfile,
 650                             mainline,
 651                             ei.dboffset, ei.dbsize,
 652                             ei.lnoffset, ei.lnsize);
 653     }
 654
 655   if (DWARF2_BUILD_FRAME_INFO_P ())
 656     DWARF2_BUILD_FRAME_INFO(objfile);
 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       xmfree (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       xmfree (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 }