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