gdb/elfread.c

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