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