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           bfd *abfd = objfile->obfd;
 244           asection *sect;
 245
 246           /* Symbol is a reference to a function defined in
 247              a shared library.
 248              If its value is non zero then it is usually the address
 249              of the corresponding entry in the procedure linkage table,
 250              plus the desired section offset.
 251              If its value is zero then the dynamic linker has to resolve
 252              the symbol. We are unable to find any meaningful address
 253              for this symbol in the executable file, so we skip it.  */
 254           symaddr = sym->value;
 255           if (symaddr == 0)
 256             continue;
 257
 258           /* sym->section is the undefined section.  However, we want to
 259              record the section where the PLT stub resides with the
 260              minimal symbol.  Search the section table for the one that
 261              covers the stub's address.  */
 262           for (sect = abfd->sections; sect != NULL; sect = sect->next)
 263             {
 264               if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
 265                 continue;
 266
 267               if (symaddr >= bfd_get_section_vma (abfd, sect)
 268                   && symaddr < bfd_get_section_vma (abfd, sect)
 269                                + bfd_get_section_size (sect))
 270                 break;
 271             }
 272           if (!sect)
 273             continue;
 274
 275           symaddr += ANOFFSET (objfile->section_offsets, sect->index);
 276
 277           msym = record_minimal_symbol
 278             ((char *) sym->name, symaddr, mst_solib_trampoline, sect, objfile);
 279           if (msym != NULL)
 280             msym->filename = filesymname;
 281           continue;
 282         }
 283
 284       /* If it is a nonstripped executable, do not enter dynamic
 285          symbols, as the dynamic symbol table is usually a subset
 286          of the main symbol table.  */
 287       if (dynamic && !stripped)
 288         continue;
 289       if (sym->flags & BSF_FILE)
 290         {
 291           /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 292              Chain any old one onto the objfile; remember new sym.  */
 293           if (sectinfo != NULL)
 294             {
 295               sectinfo->next = dbx->stab_section_info;
 296               dbx->stab_section_info = sectinfo;
 297               sectinfo = NULL;
 298             }
 299           filesym = sym;
 300           filesymname =
 301             obsavestring ((char *) filesym->name, strlen (filesym->name),
 302                           &objfile->objfile_obstack);
 303         }
 304       else if (sym->flags & BSF_SECTION_SYM)
 305         continue;
 306       else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 307         {
 308           struct minimal_symbol *msym;
 309
 310           /* Select global/local/weak symbols.  Note that bfd puts abs
 311              symbols in their own section, so all symbols we are
 312              interested in will have a section. */
 313           /* Bfd symbols are section relative. */
 314           symaddr = sym->value + sym->section->vma;
 315           /* Relocate all non-absolute symbols by the section offset.  */
 316           if (sym->section != &bfd_abs_section)
 317             {
 318               symaddr += offset;
 319             }
 320           /* For non-absolute symbols, use the type of the section
 321              they are relative to, to intuit text/data.  Bfd provides
 322              no way of figuring this out for absolute symbols. */
 323           if (sym->section == &bfd_abs_section)
 324             {
 325               /* This is a hack to get the minimal symbol type
 326                  right for Irix 5, which has absolute addresses
 327                  with special section indices for dynamic symbols. */
 328               unsigned short shndx =
 329                 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 330
 331               switch (shndx)
 332                 {
 333                 case SHN_MIPS_TEXT:
 334                   ms_type = mst_text;
 335                   break;
 336                 case SHN_MIPS_DATA:
 337                   ms_type = mst_data;
 338                   break;
 339                 case SHN_MIPS_ACOMMON:
 340                   ms_type = mst_bss;
 341                   break;
 342                 default:
 343                   ms_type = mst_abs;
 344                 }
 345
 346               /* If it is an Irix dynamic symbol, skip section name
 347                  symbols, relocate all others by section offset. */
 348               if (ms_type != mst_abs)
 349                 {
 350                   if (sym->name[0] == '.')
 351                     continue;
 352                   symaddr += offset;
 353                 }
 354             }
 355           else if (sym->section->flags & SEC_CODE)
 356             {
 357               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 358                 {
 359                   ms_type = mst_text;
 360                 }
 361               else if ((sym->name[0] == '.' && sym->name[1] == 'L')
 362                        || ((sym->flags & BSF_LOCAL)
 363                            && sym->name[0] == '$'
 364                            && sym->name[1] == 'L'))
 365                 /* Looks like a compiler-generated label.  Skip
 366                    it.  The assembler should be skipping these (to
 367                    keep executables small), but apparently with
 368                    gcc on the (deleted) delta m88k SVR4, it loses.
 369                    So to have us check too should be harmless (but
 370                    I encourage people to fix this in the assembler
 371                    instead of adding checks here).  */
 372                 continue;
 373               else
 374                 {
 375                   ms_type = mst_file_text;
 376                 }
 377             }
 378           else if (sym->section->flags & SEC_ALLOC)
 379             {
 380               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 381                 {
 382                   if (sym->section->flags & SEC_LOAD)
 383                     {
 384                       ms_type = mst_data;
 385                     }
 386                   else
 387                     {
 388                       ms_type = mst_bss;
 389                     }
 390                 }
 391               else if (sym->flags & BSF_LOCAL)
 392                 {
 393                   /* Named Local variable in a Data section.
 394                      Check its name for stabs-in-elf.  */
 395                   int special_local_sect;
 396                   if (strcmp ("Bbss.bss", sym->name) == 0)
 397                     special_local_sect = SECT_OFF_BSS (objfile);
 398                   else if (strcmp ("Ddata.data", sym->name) == 0)
 399                     special_local_sect = SECT_OFF_DATA (objfile);
 400                   else if (strcmp ("Drodata.rodata", sym->name) == 0)
 401                     special_local_sect = SECT_OFF_RODATA (objfile);
 402                   else
 403                     special_local_sect = -1;
 404                   if (special_local_sect >= 0)
 405                     {
 406                       /* Found a special local symbol.  Allocate a
 407                          sectinfo, if needed, and fill it in.  */
 408                       if (sectinfo == NULL)
 409                         {
 410                           int max_index;
 411                           size_t size;
 412
 413                           max_index
 414                             = max (SECT_OFF_BSS (objfile),
 415                                    max (SECT_OFF_DATA (objfile),
 416                                         SECT_OFF_RODATA (objfile)));
 417
 418                           /* max_index is the largest index we'll
 419                              use into this array, so we must
 420                              allocate max_index+1 elements for it.
 421                              However, 'struct stab_section_info'
 422                              already includes one element, so we
 423                              need to allocate max_index aadditional
 424                              elements.  */
 425                           size = (sizeof (struct stab_section_info)
 426                                   + (sizeof (CORE_ADDR)
 427                                      * max_index));
 428                           sectinfo = (struct stab_section_info *)
 429                             xmalloc (size);
 430                           memset (sectinfo, 0, size);
 431                           sectinfo->num_sections = max_index;
 432                           if (filesym == NULL)
 433                             {
 434                               complaint (&symfile_complaints,
 435                                          _("elf/stab section information %s without a preceding file symbol"),
 436                                          sym->name);
 437                             }
 438                           else
 439                             {
 440                               sectinfo->filename =
 441                                 (char *) filesym->name;
 442                             }
 443                         }
 444                       if (sectinfo->sections[special_local_sect] != 0)
 445                         complaint (&symfile_complaints,
 446                                    _("duplicated elf/stab section information for %s"),
 447                                    sectinfo->filename);
 448                       /* BFD symbols are section relative.  */
 449                       symaddr = sym->value + sym->section->vma;
 450                       /* Relocate non-absolute symbols by the
 451                          section offset.  */
 452                       if (sym->section != &bfd_abs_section)
 453                         symaddr += offset;
 454                       sectinfo->sections[special_local_sect] = symaddr;
 455                       /* The special local symbols don't go in the
 456                          minimal symbol table, so ignore this one.  */
 457                       continue;
 458                     }
 459                   /* Not a special stabs-in-elf symbol, do regular
 460                      symbol processing.  */
 461                   if (sym->section->flags & SEC_LOAD)
 462                     {
 463                       ms_type = mst_file_data;
 464                     }
 465                   else
 466                     {
 467                       ms_type = mst_file_bss;
 468                     }
 469                 }
 470               else
 471                 {
 472                   ms_type = mst_unknown;
 473                 }
 474             }
 475           else
 476             {
 477               /* FIXME:  Solaris2 shared libraries include lots of
 478                  odd "absolute" and "undefined" symbols, that play
 479                  hob with actions like finding what function the PC
 480                  is in.  Ignore them if they aren't text, data, or bss.  */
 481               /* ms_type = mst_unknown; */
 482               continue; /* Skip this symbol. */
 483             }
 484           msym = record_minimal_symbol
 485             ((char *) sym->name, symaddr,
 486              ms_type, sym->section, objfile);
 487           if (msym)
 488             {
 489               /* Pass symbol size field in via BFD.  FIXME!!!  */
 490               unsigned long size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
 491               MSYMBOL_SIZE(msym) = size;
 492             }
 493           if (msym != NULL)
 494             msym->filename = filesymname;
 495           gdbarch_elf_make_msymbol_special (current_gdbarch, sym, msym);
 496         }
 497     }
 498 }
 499
 500 /* Scan and build partial symbols for a symbol file.
 501    We have been initialized by a call to elf_symfile_init, which
 502    currently does nothing.
 503
 504    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 505    in each section.  We simplify it down to a single offset for all
 506    symbols.  FIXME.
 507
 508    MAINLINE is true if we are reading the main symbol
 509    table (as opposed to a shared lib or dynamically loaded file).
 510
 511    This function only does the minimum work necessary for letting the
 512    user "name" things symbolically; it does not read the entire symtab.
 513    Instead, it reads the external and static symbols and puts them in partial
 514    symbol tables.  When more extensive information is requested of a
 515    file, the corresponding partial symbol table is mutated into a full
 516    fledged symbol table by going back and reading the symbols
 517    for real.
 518
 519    We look for sections with specific names, to tell us what debug
 520    format to look for:  FIXME!!!
 521
 522    elfstab_build_psymtabs() handles STABS symbols;
 523    mdebug_build_psymtabs() handles ECOFF debugging information.
 524
 525    Note that ELF files have a "minimal" symbol table, which looks a lot
 526    like a COFF symbol table, but has only the minimal information necessary
 527    for linking.  We process this also, and use the information to
 528    build gdb's minimal symbol table.  This gives us some minimal debugging
 529    capability even for files compiled without -g.  */
 530
 531 static void
 532 elf_symfile_read (struct objfile *objfile, int mainline)
 533 {
 534   bfd *abfd = objfile->obfd;
 535   struct elfinfo ei;
 536   struct cleanup *back_to;
 537   CORE_ADDR offset;
 538   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 539   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 540   asymbol *synthsyms;
 541
 542   init_minimal_symbol_collection ();
 543   back_to = make_cleanup_discard_minimal_symbols ();
 544
 545   memset ((char *) &ei, 0, sizeof (ei));
 546
 547   /* Allocate struct to keep track of the symfile */
 548   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
 549     xmalloc (sizeof (struct dbx_symfile_info));
 550   memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 551   make_cleanup (free_elfinfo, (void *) objfile);
 552
 553   /* Process the normal ELF symbol table first.  This may write some
 554      chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
 555      which can later be used by elfstab_offset_sections.  */
 556
 557   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 558   if (storage_needed < 0)
 559     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 560            bfd_errmsg (bfd_get_error ()));
 561
 562   if (storage_needed > 0)
 563     {
 564       symbol_table = (asymbol **) xmalloc (storage_needed);
 565       make_cleanup (xfree, symbol_table);
 566       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 567
 568       if (symcount < 0)
 569         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 570                bfd_errmsg (bfd_get_error ()));
 571
 572       elf_symtab_read (objfile, 0, symcount, symbol_table);
 573     }
 574
 575   /* Add the dynamic symbols.  */
 576
 577   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 578
 579   if (storage_needed > 0)
 580     {
 581       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 582       make_cleanup (xfree, dyn_symbol_table);
 583       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 584                                                      dyn_symbol_table);
 585
 586       if (dynsymcount < 0)
 587         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 588                bfd_errmsg (bfd_get_error ()));
 589
 590       elf_symtab_read (objfile, 1, dynsymcount, dyn_symbol_table);
 591     }
 592
 593   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 594
 595   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 596                                          dynsymcount, dyn_symbol_table,
 597                                          &synthsyms);
 598   if (synthcount > 0)
 599     {
 600       asymbol **synth_symbol_table;
 601       long i;
 602
 603       make_cleanup (xfree, synthsyms);
 604       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 605       for (i = 0; i < synthcount; i++)
 606         synth_symbol_table[i] = synthsyms + i;
 607       make_cleanup (xfree, synth_symbol_table);
 608       elf_symtab_read (objfile, 0, synthcount, synth_symbol_table);
 609     }
 610
 611   /* Install any minimal symbols that have been collected as the current
 612      minimal symbols for this objfile.  The debug readers below this point
 613      should not generate new minimal symbols; if they do it's their
 614      responsibility to install them.  "mdebug" appears to be the only one
 615      which will do this.  */
 616
 617   install_minimal_symbols (objfile);
 618   do_cleanups (back_to);
 619
 620   /* Now process debugging information, which is contained in
 621      special ELF sections. */
 622
 623   /* If we are reinitializing, or if we have never loaded syms yet,
 624      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 625      functions do not all also re-initialize the psymbol table. */
 626   if (mainline)
 627     {
 628       init_psymbol_list (objfile, 0);
 629       mainline = 0;
 630     }
 631
 632   /* We first have to find them... */
 633   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 634
 635   /* ELF debugging information is inserted into the psymtab in the
 636      order of least informative first - most informative last.  Since
 637      the psymtab table is searched `most recent insertion first' this
 638      increases the probability that more detailed debug information
 639      for a section is found.
 640
 641      For instance, an object file might contain both .mdebug (XCOFF)
 642      and .debug_info (DWARF2) sections then .mdebug is inserted first
 643      (searched last) and DWARF2 is inserted last (searched first).  If
 644      we don't do this then the XCOFF info is found first - for code in
 645      an included file XCOFF info is useless. */
 646
 647   if (ei.mdebugsect)
 648     {
 649       const struct ecoff_debug_swap *swap;
 650
 651       /* .mdebug section, presumably holding ECOFF debugging
 652          information.  */
 653       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 654       if (swap)
 655         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 656     }
 657   if (ei.stabsect)
 658     {
 659       asection *str_sect;
 660
 661       /* Stab sections have an associated string table that looks like
 662          a separate section.  */
 663       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 664
 665       /* FIXME should probably warn about a stab section without a stabstr.  */
 666       if (str_sect)
 667         elfstab_build_psymtabs (objfile,
 668                                 mainline,
 669                                 ei.stabsect,
 670                                 str_sect->filepos,
 671                                 bfd_section_size (abfd, str_sect));
 672     }
 673   if (dwarf2_has_info (objfile))
 674     {
 675       /* DWARF 2 sections */
 676       dwarf2_build_psymtabs (objfile, mainline);
 677     }
 678
 679   /* FIXME: kettenis/20030504: This still needs to be integrated with
 680      dwarf2read.c in a better way.  */
 681   dwarf2_build_frame_info (objfile);
 682 }
 683
 684 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
 685    the chain of stab_section_info's, that might be dangling from
 686    it.  */
 687
 688 static void
 689 free_elfinfo (void *objp)
 690 {
 691   struct objfile *objfile = (struct objfile *) objp;
 692   struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
 693   struct stab_section_info *ssi, *nssi;
 694
 695   ssi = dbxinfo->stab_section_info;
 696   while (ssi)
 697     {
 698       nssi = ssi->next;
 699       xfree (ssi);
 700       ssi = nssi;
 701     }
 702
 703   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 704 }
 705
 706
 707 /* Initialize anything that needs initializing when a completely new symbol
 708    file is specified (not just adding some symbols from another file, e.g. a
 709    shared library).
 710
 711    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 712
 713 static void
 714 elf_new_init (struct objfile *ignore)
 715 {
 716   stabsread_new_init ();
 717   buildsym_new_init ();
 718 }
 719
 720 /* Perform any local cleanups required when we are done with a particular
 721    objfile.  I.E, we are in the process of discarding all symbol information
 722    for an objfile, freeing up all memory held for it, and unlinking the
 723    objfile struct from the global list of known objfiles. */
 724
 725 static void
 726 elf_symfile_finish (struct objfile *objfile)
 727 {
 728   if (objfile->deprecated_sym_stab_info != NULL)
 729     {
 730       xfree (objfile->deprecated_sym_stab_info);
 731     }
 732
 733   dwarf2_free_objfile (objfile);
 734 }
 735
 736 /* ELF specific initialization routine for reading symbols.
 737
 738    It is passed a pointer to a struct sym_fns which contains, among other
 739    things, the BFD for the file whose symbols are being read, and a slot for
 740    a pointer to "private data" which we can fill with goodies.
 741
 742    For now at least, we have nothing in particular to do, so this function is
 743    just a stub. */
 744
 745 static void
 746 elf_symfile_init (struct objfile *objfile)
 747 {
 748   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 749      find this causes a significant slowdown in gdb then we could
 750      set it in the debug symbol readers only when necessary.  */
 751   objfile->flags |= OBJF_REORDERED;
 752 }
 753
 754 /* When handling an ELF file that contains Sun STABS debug info,
 755    some of the debug info is relative to the particular chunk of the
 756    section that was generated in its individual .o file.  E.g.
 757    offsets to static variables are relative to the start of the data
 758    segment *for that module before linking*.  This information is
 759    painfully squirreled away in the ELF symbol table as local symbols
 760    with wierd names.  Go get 'em when needed.  */
 761
 762 void
 763 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 764 {
 765   char *filename = pst->filename;
 766   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 767   struct stab_section_info *maybe = dbx->stab_section_info;
 768   struct stab_section_info *questionable = 0;
 769   int i;
 770   char *p;
 771
 772   /* The ELF symbol info doesn't include path names, so strip the path
 773      (if any) from the psymtab filename.  */
 774   while (0 != (p = strchr (filename, '/')))
 775     filename = p + 1;
 776
 777   /* FIXME:  This linear search could speed up significantly
 778      if it was chained in the right order to match how we search it,
 779      and if we unchained when we found a match. */
 780   for (; maybe; maybe = maybe->next)
 781     {
 782       if (filename[0] == maybe->filename[0]
 783           && strcmp (filename, maybe->filename) == 0)
 784         {
 785           /* We found a match.  But there might be several source files
 786              (from different directories) with the same name.  */
 787           if (0 == maybe->found)
 788             break;
 789           questionable = maybe; /* Might use it later.  */
 790         }
 791     }
 792
 793   if (maybe == 0 && questionable != 0)
 794     {
 795       complaint (&symfile_complaints,
 796                  _("elf/stab section information questionable for %s"), filename);
 797       maybe = questionable;
 798     }
 799
 800   if (maybe)
 801     {
 802       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 803       maybe->found++;
 804       pst->section_offsets = (struct section_offsets *)
 805         obstack_alloc (&objfile->objfile_obstack,
 806                        SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 807       for (i = 0; i < maybe->num_sections; i++)
 808         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 809       return;
 810     }
 811
 812   /* We were unable to find any offsets for this file.  Complain.  */
 813   if (dbx->stab_section_info)   /* If there *is* any info, */
 814     complaint (&symfile_complaints,
 815                _("elf/stab section information missing for %s"), filename);
 816 }
 817 \f
 818 /* Register that we are able to handle ELF object file formats.  */
 819
 820 static struct sym_fns elf_sym_fns =
 821 {
 822   bfd_target_elf_flavour,
 823   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 824   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 825   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 826   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 827   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 828   elf_symfile_segments,         /* sym_segments: Get segment information from
 829                                    a file.  */
 830   NULL,                         /* sym_read_linetable */
 831   NULL                          /* next: pointer to next struct sym_fns */
 832 };
 833
 834 void
 835 _initialize_elfread (void)
 836 {
 837   add_symtab_fns (&elf_sym_fns);
 838 }