gdb/elfread.c

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