gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2    Copyright 1991, 92, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "bfd.h"
  24 #include "gdb_string.h"
  25 #include "elf-bfd.h"
  26 #include "elf/mips.h"
  27 #include "symtab.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30 #include "buildsym.h"
  31 #include "stabsread.h"
  32 #include "gdb-stabs.h"
  33 #include "complaints.h"
  34 #include "demangle.h"
  35
  36 extern void _initialize_elfread (void);
  37
  38 /* The struct elfinfo is available only during ELF symbol table and
  39    psymtab reading.  It is destroyed at the completion of psymtab-reading.
  40    It's local to elf_symfile_read.  */
  41
  42 struct elfinfo
  43   {
  44     file_ptr dboffset;          /* Offset to dwarf debug section */
  45     unsigned int dbsize;        /* Size of dwarf debug section */
  46     file_ptr lnoffset;          /* Offset to dwarf line number section */
  47     unsigned int lnsize;        /* Size of dwarf line number section */
  48     asection *stabsect;         /* Section pointer for .stab section */
  49     asection *stabindexsect;    /* Section pointer for .stab.index section */
  50     asection *mdebugsect;       /* Section pointer for .mdebug section */
  51   };
  52
  53 /* Various things we might complain about... */
  54
  55 struct complaint section_info_complaint =
  56 {"elf/stab section information %s without a preceding file symbol", 0, 0};
  57
  58 struct complaint section_info_dup_complaint =
  59 {"duplicated elf/stab section information for %s", 0, 0};
  60
  61 struct complaint stab_info_mismatch_complaint =
  62 {"elf/stab section information missing for %s", 0, 0};
  63
  64 struct complaint stab_info_questionable_complaint =
  65 {"elf/stab section information questionable for %s", 0, 0};
  66
  67 static void elf_symfile_init (struct objfile *);
  68
  69 static void elf_new_init (struct objfile *);
  70
  71 static void elf_symfile_read (struct objfile *, int);
  72
  73 static void elf_symfile_finish (struct objfile *);
  74
  75 static void elf_symtab_read (struct objfile *, int);
  76
  77 static void free_elfinfo (void *);
  78
  79 static struct minimal_symbol *record_minimal_symbol_and_info (char *,
  80                                                               CORE_ADDR,
  81                                                               enum
  82                                                               minimal_symbol_type,
  83                                                               char *,
  84                                                               asection *
  85                                                               bfd_section,
  86                                                               struct objfile
  87                                                               *);
  88
  89 static void elf_locate_sections (bfd *, asection *, void *);
  90
  91 /* We are called once per section from elf_symfile_read.  We
  92    need to examine each section we are passed, check to see
  93    if it is something we are interested in processing, and
  94    if so, stash away some access information for the section.
  95
  96    For now we recognize the dwarf debug information sections and
  97    line number sections from matching their section names.  The
  98    ELF definition is no real help here since it has no direct
  99    knowledge of DWARF (by design, so any debugging format can be
 100    used).
 101
 102    We also recognize the ".stab" sections used by the Sun compilers
 103    released with Solaris 2.
 104
 105    FIXME: The section names should not be hardwired strings (what
 106    should they be?  I don't think most object file formats have enough
 107    section flags to specify what kind of debug section it is
 108    -kingdon).  */
 109
 110 static void
 111 elf_locate_sections (bfd *ignore_abfd, asection *sectp, PTR eip)
 112 {
 113   register struct elfinfo *ei;
 114
 115   ei = (struct elfinfo *) eip;
 116   if (STREQ (sectp->name, ".debug"))
 117     {
 118       ei->dboffset = sectp->filepos;
 119       ei->dbsize = bfd_get_section_size_before_reloc (sectp);
 120     }
 121   else if (STREQ (sectp->name, ".line"))
 122     {
 123       ei->lnoffset = sectp->filepos;
 124       ei->lnsize = bfd_get_section_size_before_reloc (sectp);
 125     }
 126   else if (STREQ (sectp->name, ".stab"))
 127     {
 128       ei->stabsect = sectp;
 129     }
 130   else if (STREQ (sectp->name, ".stab.index"))
 131     {
 132       ei->stabindexsect = sectp;
 133     }
 134   else if (STREQ (sectp->name, ".mdebug"))
 135     {
 136       ei->mdebugsect = sectp;
 137     }
 138 }
 139
 140 #if 0                           /* Currently unused */
 141
 142 char *
 143 elf_interpreter (bfd *abfd)
 144 {
 145   sec_ptr interp_sec;
 146   unsigned size;
 147   char *interp = NULL;
 148
 149   interp_sec = bfd_get_section_by_name (abfd, ".interp");
 150   if (interp_sec)
 151     {
 152       size = bfd_section_size (abfd, interp_sec);
 153       interp = alloca (size);
 154       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr) 0,
 155                                     size))
 156         {
 157           interp = savestring (interp, size - 1);
 158         }
 159       else
 160         {
 161           interp = NULL;
 162         }
 163     }
 164   return (interp);
 165 }
 166
 167 #endif
 168
 169 static struct minimal_symbol *
 170 record_minimal_symbol_and_info (char *name, CORE_ADDR address,
 171                                 enum minimal_symbol_type ms_type, char *info,   /* FIXME, is this really char *? */
 172                                 asection *bfd_section, struct objfile *objfile)
 173 {
 174 #ifdef SMASH_TEXT_ADDRESS
 175   if (ms_type == mst_text || ms_type == mst_file_text)
 176     SMASH_TEXT_ADDRESS (address);
 177 #endif
 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 ("Section index uninitialized.");
 468                           /* Bfd symbols are section relative. */
 469                           symaddr = sym->value + sym->section->vma;
 470                           /* Relocate non-absolute symbols by the section offset. */
 471                           if (sym->section != &bfd_abs_section)
 472                             {
 473                               symaddr += offset;
 474                             }
 475                           if (index != -1)
 476                             sectinfo->sections[index] = symaddr;
 477                           else
 478                             internal_error ("Section index uninitialized.");
 479                           /* The special local symbols don't go in the
 480                              minimal symbol table, so ignore this one. */
 481                           continue;
 482                         }
 483                       /* Not a special stabs-in-elf symbol, do regular
 484                          symbol processing. */
 485                       if (sym->section->flags & SEC_LOAD)
 486                         {
 487                           ms_type = mst_file_data;
 488                         }
 489                       else
 490                         {
 491                           ms_type = mst_file_bss;
 492                         }
 493                     }
 494                   else
 495                     {
 496                       ms_type = mst_unknown;
 497                     }
 498                 }
 499               else
 500                 {
 501                   /* FIXME:  Solaris2 shared libraries include lots of
 502                      odd "absolute" and "undefined" symbols, that play
 503                      hob with actions like finding what function the PC
 504                      is in.  Ignore them if they aren't text, data, or bss.  */
 505                   /* ms_type = mst_unknown; */
 506                   continue;     /* Skip this symbol. */
 507                 }
 508               /* Pass symbol size field in via BFD.  FIXME!!!  */
 509               size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 510               msym = record_minimal_symbol_and_info
 511                 ((char *) sym->name, symaddr,
 512                  ms_type, (PTR) size, sym->section, objfile);
 513 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 514               if (msym != NULL)
 515                 msym->filename = filesymname;
 516 #endif
 517 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
 518               ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
 519 #endif
 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   /* Install any minimal symbols that have been collected as the current
 656      minimal symbols for this objfile. */
 657
 658   install_minimal_symbols (objfile);
 659
 660   do_cleanups (back_to);
 661 }
 662
 663 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 664    stab_section_info's, that might be dangling from it.  */
 665
 666 static void
 667 free_elfinfo (PTR objp)
 668 {
 669   struct objfile *objfile = (struct objfile *) objp;
 670   struct dbx_symfile_info *dbxinfo = objfile->sym_stab_info;
 671   struct stab_section_info *ssi, *nssi;
 672
 673   ssi = dbxinfo->stab_section_info;
 674   while (ssi)
 675     {
 676       nssi = ssi->next;
 677       mfree (objfile->md, ssi);
 678       ssi = nssi;
 679     }
 680
 681   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 682 }
 683
 684
 685 /* Initialize anything that needs initializing when a completely new symbol
 686    file is specified (not just adding some symbols from another file, e.g. a
 687    shared library).
 688
 689    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 690
 691 static void
 692 elf_new_init (struct objfile *ignore)
 693 {
 694   stabsread_new_init ();
 695   buildsym_new_init ();
 696 }
 697
 698 /* Perform any local cleanups required when we are done with a particular
 699    objfile.  I.E, we are in the process of discarding all symbol information
 700    for an objfile, freeing up all memory held for it, and unlinking the
 701    objfile struct from the global list of known objfiles. */
 702
 703 static void
 704 elf_symfile_finish (struct objfile *objfile)
 705 {
 706   if (objfile->sym_stab_info != NULL)
 707     {
 708       mfree (objfile->md, objfile->sym_stab_info);
 709     }
 710 }
 711
 712 /* ELF specific initialization routine for reading symbols.
 713
 714    It is passed a pointer to a struct sym_fns which contains, among other
 715    things, the BFD for the file whose symbols are being read, and a slot for
 716    a pointer to "private data" which we can fill with goodies.
 717
 718    For now at least, we have nothing in particular to do, so this function is
 719    just a stub. */
 720
 721 static void
 722 elf_symfile_init (struct objfile *objfile)
 723 {
 724   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 725      find this causes a significant slowdown in gdb then we could
 726      set it in the debug symbol readers only when necessary.  */
 727   objfile->flags |= OBJF_REORDERED;
 728 }
 729
 730 /* When handling an ELF file that contains Sun STABS debug info,
 731    some of the debug info is relative to the particular chunk of the
 732    section that was generated in its individual .o file.  E.g.
 733    offsets to static variables are relative to the start of the data
 734    segment *for that module before linking*.  This information is
 735    painfully squirreled away in the ELF symbol table as local symbols
 736    with wierd names.  Go get 'em when needed.  */
 737
 738 void
 739 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 740 {
 741   char *filename = pst->filename;
 742   struct dbx_symfile_info *dbx = objfile->sym_stab_info;
 743   struct stab_section_info *maybe = dbx->stab_section_info;
 744   struct stab_section_info *questionable = 0;
 745   int i;
 746   char *p;
 747
 748   /* The ELF symbol info doesn't include path names, so strip the path
 749      (if any) from the psymtab filename.  */
 750   while (0 != (p = strchr (filename, '/')))
 751     filename = p + 1;
 752
 753   /* FIXME:  This linear search could speed up significantly
 754      if it was chained in the right order to match how we search it,
 755      and if we unchained when we found a match. */
 756   for (; maybe; maybe = maybe->next)
 757     {
 758       if (filename[0] == maybe->filename[0]
 759           && STREQ (filename, maybe->filename))
 760         {
 761           /* We found a match.  But there might be several source files
 762              (from different directories) with the same name.  */
 763           if (0 == maybe->found)
 764             break;
 765           questionable = maybe; /* Might use it later.  */
 766         }
 767     }
 768
 769   if (maybe == 0 && questionable != 0)
 770     {
 771       complain (&stab_info_questionable_complaint, filename);
 772       maybe = questionable;
 773     }
 774
 775   if (maybe)
 776     {
 777       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 778       maybe->found++;
 779       pst->section_offsets = (struct section_offsets *)
 780         obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
 781       for (i = 0; i < SECT_OFF_MAX; i++)
 782         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 783       return;
 784     }
 785
 786   /* We were unable to find any offsets for this file.  Complain.  */
 787   if (dbx->stab_section_info)   /* If there *is* any info, */
 788     complain (&stab_info_mismatch_complaint, filename);
 789 }
 790 \f
 791 /* Register that we are able to handle ELF object file formats.  */
 792
 793 static struct sym_fns elf_sym_fns =
 794 {
 795   bfd_target_elf_flavour,
 796   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 797   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 798   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 799   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 800   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 801   NULL                          /* next: pointer to next struct sym_fns */
 802 };
 803
 804 void
 805 _initialize_elfread (void)
 806 {
 807   add_symtab_fns (&elf_sym_fns);
 808 }