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