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