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 (const char *name, int name_len, int copy_name,
 176                        CORE_ADDR address,
 177                        enum minimal_symbol_type ms_type,
 178                        asection *bfd_section, struct objfile *objfile)
 179 {
 180   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 181
 182   if (ms_type == mst_text || ms_type == mst_file_text)
 183     address = gdbarch_smash_text_address (gdbarch, address);
 184
 185   return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
 186                                           ms_type, bfd_section->index,
 187                                           bfd_section, objfile);
 188 }
 189
 190 /*
 191
 192    LOCAL FUNCTION
 193
 194    elf_symtab_read -- read the symbol table of an ELF file
 195
 196    SYNOPSIS
 197
 198    void elf_symtab_read (struct objfile *objfile, int type,
 199                          long number_of_symbols, asymbol **symbol_table)
 200
 201    DESCRIPTION
 202
 203    Given an objfile, a symbol table, and a flag indicating whether the
 204    symbol table contains regular, dynamic, or synthetic symbols, add all
 205    the global function and data symbols to the minimal symbol table.
 206
 207    In stabs-in-ELF, as implemented by Sun, there are some local symbols
 208    defined in the ELF symbol table, which can be used to locate
 209    the beginnings of sections from each ".o" file that was linked to
 210    form the executable objfile.  We gather any such info and record it
 211    in data structures hung off the objfile's private data.
 212
 213  */
 214
 215 #define ST_REGULAR 0
 216 #define ST_DYNAMIC 1
 217 #define ST_SYNTHETIC 2
 218
 219 static void
 220 elf_symtab_read (struct objfile *objfile, int type,
 221                  long number_of_symbols, asymbol **symbol_table,
 222                  int copy_names)
 223 {
 224   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 225   long storage_needed;
 226   asymbol *sym;
 227   long i;
 228   CORE_ADDR symaddr;
 229   CORE_ADDR offset;
 230   enum minimal_symbol_type ms_type;
 231   /* If sectinfo is nonNULL, it contains section info that should end up
 232      filed in the objfile.  */
 233   struct stab_section_info *sectinfo = NULL;
 234   /* If filesym is nonzero, it points to a file symbol, but we haven't
 235      seen any section info for it yet.  */
 236   asymbol *filesym = 0;
 237   /* Name of filesym.  This is either a constant string or is saved on
 238      the objfile's obstack.  */
 239   char *filesymname = "";
 240   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 241   int stripped = (bfd_get_symcount (objfile->obfd) == 0);
 242
 243   for (i = 0; i < number_of_symbols; i++)
 244     {
 245       sym = symbol_table[i];
 246       if (sym->name == NULL || *sym->name == '\0')
 247         {
 248           /* Skip names that don't exist (shouldn't happen), or names
 249              that are null strings (may happen). */
 250           continue;
 251         }
 252
 253       /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
 254          symbols which do not correspond to objects in the symbol table,
 255          but have some other target-specific meaning.  */
 256       if (bfd_is_target_special_symbol (objfile->obfd, sym))
 257         {
 258           if (gdbarch_record_special_symbol_p (gdbarch))
 259             gdbarch_record_special_symbol (gdbarch, objfile, sym);
 260           continue;
 261         }
 262
 263       offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 264       if (type == ST_DYNAMIC
 265           && sym->section == &bfd_und_section
 266           && (sym->flags & BSF_FUNCTION))
 267         {
 268           struct minimal_symbol *msym;
 269           bfd *abfd = objfile->obfd;
 270           asection *sect;
 271
 272           /* Symbol is a reference to a function defined in
 273              a shared library.
 274              If its value is non zero then it is usually the address
 275              of the corresponding entry in the procedure linkage table,
 276              plus the desired section offset.
 277              If its value is zero then the dynamic linker has to resolve
 278              the symbol. We are unable to find any meaningful address
 279              for this symbol in the executable file, so we skip it.  */
 280           symaddr = sym->value;
 281           if (symaddr == 0)
 282             continue;
 283
 284           /* sym->section is the undefined section.  However, we want to
 285              record the section where the PLT stub resides with the
 286              minimal symbol.  Search the section table for the one that
 287              covers the stub's address.  */
 288           for (sect = abfd->sections; sect != NULL; sect = sect->next)
 289             {
 290               if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
 291                 continue;
 292
 293               if (symaddr >= bfd_get_section_vma (abfd, sect)
 294                   && symaddr < bfd_get_section_vma (abfd, sect)
 295                                + bfd_get_section_size (sect))
 296                 break;
 297             }
 298           if (!sect)
 299             continue;
 300
 301           symaddr += ANOFFSET (objfile->section_offsets, sect->index);
 302
 303           msym = record_minimal_symbol
 304             (sym->name, strlen (sym->name), copy_names,
 305              symaddr, mst_solib_trampoline, sect, objfile);
 306           if (msym != NULL)
 307             msym->filename = filesymname;
 308           continue;
 309         }
 310
 311       /* If it is a nonstripped executable, do not enter dynamic
 312          symbols, as the dynamic symbol table is usually a subset
 313          of the main symbol table.  */
 314       if (type == ST_DYNAMIC && !stripped)
 315         continue;
 316       if (sym->flags & BSF_FILE)
 317         {
 318           /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
 319              Chain any old one onto the objfile; remember new sym.  */
 320           if (sectinfo != NULL)
 321             {
 322               sectinfo->next = dbx->stab_section_info;
 323               dbx->stab_section_info = sectinfo;
 324               sectinfo = NULL;
 325             }
 326           filesym = sym;
 327           filesymname =
 328             obsavestring ((char *) filesym->name, strlen (filesym->name),
 329                           &objfile->objfile_obstack);
 330         }
 331       else if (sym->flags & BSF_SECTION_SYM)
 332         continue;
 333       else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 334         {
 335           struct minimal_symbol *msym;
 336
 337           /* Select global/local/weak symbols.  Note that bfd puts abs
 338              symbols in their own section, so all symbols we are
 339              interested in will have a section. */
 340           /* Bfd symbols are section relative. */
 341           symaddr = sym->value + sym->section->vma;
 342           /* Relocate all non-absolute and non-TLS symbols by the
 343              section offset.  */
 344           if (sym->section != &bfd_abs_section
 345               && !(sym->section->flags & SEC_THREAD_LOCAL))
 346             {
 347               symaddr += offset;
 348             }
 349           /* For non-absolute symbols, use the type of the section
 350              they are relative to, to intuit text/data.  Bfd provides
 351              no way of figuring this out for absolute symbols. */
 352           if (sym->section == &bfd_abs_section)
 353             {
 354               /* This is a hack to get the minimal symbol type
 355                  right for Irix 5, which has absolute addresses
 356                  with special section indices for dynamic symbols.
 357
 358                  NOTE: uweigand-20071112: Synthetic symbols do not
 359                  have an ELF-private part, so do not touch those.  */
 360               unsigned int shndx = type == ST_SYNTHETIC ? 0 :
 361                 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
 362
 363               switch (shndx)
 364                 {
 365                 case SHN_MIPS_TEXT:
 366                   ms_type = mst_text;
 367                   break;
 368                 case SHN_MIPS_DATA:
 369                   ms_type = mst_data;
 370                   break;
 371                 case SHN_MIPS_ACOMMON:
 372                   ms_type = mst_bss;
 373                   break;
 374                 default:
 375                   ms_type = mst_abs;
 376                 }
 377
 378               /* If it is an Irix dynamic symbol, skip section name
 379                  symbols, relocate all others by section offset. */
 380               if (ms_type != mst_abs)
 381                 {
 382                   if (sym->name[0] == '.')
 383                     continue;
 384                   symaddr += offset;
 385                 }
 386             }
 387           else if (sym->section->flags & SEC_CODE)
 388             {
 389               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 390                 {
 391                   ms_type = mst_text;
 392                 }
 393               else if ((sym->name[0] == '.' && sym->name[1] == 'L')
 394                        || ((sym->flags & BSF_LOCAL)
 395                            && sym->name[0] == '$'
 396                            && sym->name[1] == 'L'))
 397                 /* Looks like a compiler-generated label.  Skip
 398                    it.  The assembler should be skipping these (to
 399                    keep executables small), but apparently with
 400                    gcc on the (deleted) delta m88k SVR4, it loses.
 401                    So to have us check too should be harmless (but
 402                    I encourage people to fix this in the assembler
 403                    instead of adding checks here).  */
 404                 continue;
 405               else
 406                 {
 407                   ms_type = mst_file_text;
 408                 }
 409             }
 410           else if (sym->section->flags & SEC_ALLOC)
 411             {
 412               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 413                 {
 414                   if (sym->section->flags & SEC_LOAD)
 415                     {
 416                       ms_type = mst_data;
 417                     }
 418                   else
 419                     {
 420                       ms_type = mst_bss;
 421                     }
 422                 }
 423               else if (sym->flags & BSF_LOCAL)
 424                 {
 425                   /* Named Local variable in a Data section.
 426                      Check its name for stabs-in-elf.  */
 427                   int special_local_sect;
 428                   if (strcmp ("Bbss.bss", sym->name) == 0)
 429                     special_local_sect = SECT_OFF_BSS (objfile);
 430                   else if (strcmp ("Ddata.data", sym->name) == 0)
 431                     special_local_sect = SECT_OFF_DATA (objfile);
 432                   else if (strcmp ("Drodata.rodata", sym->name) == 0)
 433                     special_local_sect = SECT_OFF_RODATA (objfile);
 434                   else
 435                     special_local_sect = -1;
 436                   if (special_local_sect >= 0)
 437                     {
 438                       /* Found a special local symbol.  Allocate a
 439                          sectinfo, if needed, and fill it in.  */
 440                       if (sectinfo == NULL)
 441                         {
 442                           int max_index;
 443                           size_t size;
 444
 445                           max_index = SECT_OFF_BSS (objfile);
 446                           if (objfile->sect_index_data > max_index)
 447                             max_index = objfile->sect_index_data;
 448                           if (objfile->sect_index_rodata > max_index)
 449                             max_index = objfile->sect_index_rodata;
 450
 451                           /* max_index is the largest index we'll
 452                              use into this array, so we must
 453                              allocate max_index+1 elements for it.
 454                              However, 'struct stab_section_info'
 455                              already includes one element, so we
 456                              need to allocate max_index aadditional
 457                              elements.  */
 458                           size = (sizeof (struct stab_section_info)
 459                                   + (sizeof (CORE_ADDR)
 460                                      * max_index));
 461                           sectinfo = (struct stab_section_info *)
 462                             xmalloc (size);
 463                           memset (sectinfo, 0, size);
 464                           sectinfo->num_sections = max_index;
 465                           if (filesym == NULL)
 466                             {
 467                               complaint (&symfile_complaints,
 468                                          _("elf/stab section information %s without a preceding file symbol"),
 469                                          sym->name);
 470                             }
 471                           else
 472                             {
 473                               sectinfo->filename =
 474                                 (char *) filesym->name;
 475                             }
 476                         }
 477                       if (sectinfo->sections[special_local_sect] != 0)
 478                         complaint (&symfile_complaints,
 479                                    _("duplicated elf/stab section information for %s"),
 480                                    sectinfo->filename);
 481                       /* BFD symbols are section relative.  */
 482                       symaddr = sym->value + sym->section->vma;
 483                       /* Relocate non-absolute symbols by the
 484                          section offset.  */
 485                       if (sym->section != &bfd_abs_section)
 486                         symaddr += offset;
 487                       sectinfo->sections[special_local_sect] = symaddr;
 488                       /* The special local symbols don't go in the
 489                          minimal symbol table, so ignore this one.  */
 490                       continue;
 491                     }
 492                   /* Not a special stabs-in-elf symbol, do regular
 493                      symbol processing.  */
 494                   if (sym->section->flags & SEC_LOAD)
 495                     {
 496                       ms_type = mst_file_data;
 497                     }
 498                   else
 499                     {
 500                       ms_type = mst_file_bss;
 501                     }
 502                 }
 503               else
 504                 {
 505                   ms_type = mst_unknown;
 506                 }
 507             }
 508           else
 509             {
 510               /* FIXME:  Solaris2 shared libraries include lots of
 511                  odd "absolute" and "undefined" symbols, that play
 512                  hob with actions like finding what function the PC
 513                  is in.  Ignore them if they aren't text, data, or bss.  */
 514               /* ms_type = mst_unknown; */
 515               continue; /* Skip this symbol. */
 516             }
 517           msym = record_minimal_symbol
 518             (sym->name, strlen (sym->name), copy_names, symaddr,
 519              ms_type, sym->section, objfile);
 520
 521           if (msym)
 522             {
 523               /* Pass symbol size field in via BFD.  FIXME!!!  */
 524               elf_symbol_type *elf_sym;
 525
 526               /* NOTE: uweigand-20071112: A synthetic symbol does not have an
 527                  ELF-private part.  However, in some cases (e.g. synthetic
 528                  'dot' symbols on ppc64) the udata.p entry is set to point back
 529                  to the original ELF symbol it was derived from.  Get the size
 530                  from that symbol.  */
 531               if (type != ST_SYNTHETIC)
 532                 elf_sym = (elf_symbol_type *) sym;
 533               else
 534                 elf_sym = (elf_symbol_type *) sym->udata.p;
 535
 536               if (elf_sym)
 537                 MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
 538
 539               msym->filename = filesymname;
 540               gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
 541             }
 542
 543           /* For @plt symbols, also record a trampoline to the
 544              destination symbol.  The @plt symbol will be used in
 545              disassembly, and the trampoline will be used when we are
 546              trying to find the target.  */
 547           if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
 548             {
 549               int len = strlen (sym->name);
 550
 551               if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
 552                 {
 553                   struct minimal_symbol *mtramp;
 554
 555                   mtramp = record_minimal_symbol (sym->name, len - 4, 1,
 556                                                   symaddr,
 557                                                   mst_solib_trampoline,
 558                                                   sym->section, objfile);
 559                   if (mtramp)
 560                     {
 561                       MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
 562                       mtramp->filename = filesymname;
 563                       gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
 564                     }
 565                 }
 566             }
 567         }
 568     }
 569 }
 570
 571 /* Scan and build partial symbols for a symbol file.
 572    We have been initialized by a call to elf_symfile_init, which
 573    currently does nothing.
 574
 575    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 576    in each section.  We simplify it down to a single offset for all
 577    symbols.  FIXME.
 578
 579    MAINLINE is true if we are reading the main symbol
 580    table (as opposed to a shared lib or dynamically loaded file).
 581
 582    This function only does the minimum work necessary for letting the
 583    user "name" things symbolically; it does not read the entire symtab.
 584    Instead, it reads the external and static symbols and puts them in partial
 585    symbol tables.  When more extensive information is requested of a
 586    file, the corresponding partial symbol table is mutated into a full
 587    fledged symbol table by going back and reading the symbols
 588    for real.
 589
 590    We look for sections with specific names, to tell us what debug
 591    format to look for:  FIXME!!!
 592
 593    elfstab_build_psymtabs() handles STABS symbols;
 594    mdebug_build_psymtabs() handles ECOFF debugging information.
 595
 596    Note that ELF files have a "minimal" symbol table, which looks a lot
 597    like a COFF symbol table, but has only the minimal information necessary
 598    for linking.  We process this also, and use the information to
 599    build gdb's minimal symbol table.  This gives us some minimal debugging
 600    capability even for files compiled without -g.  */
 601
 602 static void
 603 elf_symfile_read (struct objfile *objfile, int mainline)
 604 {
 605   bfd *abfd = objfile->obfd;
 606   struct elfinfo ei;
 607   struct cleanup *back_to;
 608   CORE_ADDR offset;
 609   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 610   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 611   asymbol *synthsyms;
 612
 613   init_minimal_symbol_collection ();
 614   back_to = make_cleanup_discard_minimal_symbols ();
 615
 616   memset ((char *) &ei, 0, sizeof (ei));
 617
 618   /* Allocate struct to keep track of the symfile */
 619   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
 620     xmalloc (sizeof (struct dbx_symfile_info));
 621   memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 622   make_cleanup (free_elfinfo, (void *) objfile);
 623
 624   /* Process the normal ELF symbol table first.  This may write some
 625      chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
 626      which can later be used by elfstab_offset_sections.  */
 627
 628   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 629   if (storage_needed < 0)
 630     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 631            bfd_errmsg (bfd_get_error ()));
 632
 633   if (storage_needed > 0)
 634     {
 635       symbol_table = (asymbol **) xmalloc (storage_needed);
 636       make_cleanup (xfree, symbol_table);
 637       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 638
 639       if (symcount < 0)
 640         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 641                bfd_errmsg (bfd_get_error ()));
 642
 643       elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
 644     }
 645
 646   /* Add the dynamic symbols.  */
 647
 648   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 649
 650   if (storage_needed > 0)
 651     {
 652       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 653       make_cleanup (xfree, dyn_symbol_table);
 654       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 655                                                      dyn_symbol_table);
 656
 657       if (dynsymcount < 0)
 658         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 659                bfd_errmsg (bfd_get_error ()));
 660
 661       elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
 662     }
 663
 664   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 665
 666   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 667                                          dynsymcount, dyn_symbol_table,
 668                                          &synthsyms);
 669   if (synthcount > 0)
 670     {
 671       asymbol **synth_symbol_table;
 672       long i;
 673
 674       make_cleanup (xfree, synthsyms);
 675       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 676       for (i = 0; i < synthcount; i++)
 677         synth_symbol_table[i] = synthsyms + i;
 678       make_cleanup (xfree, synth_symbol_table);
 679       elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
 680     }
 681
 682   /* Install any minimal symbols that have been collected as the current
 683      minimal symbols for this objfile.  The debug readers below this point
 684      should not generate new minimal symbols; if they do it's their
 685      responsibility to install them.  "mdebug" appears to be the only one
 686      which will do this.  */
 687
 688   install_minimal_symbols (objfile);
 689   do_cleanups (back_to);
 690
 691   /* Now process debugging information, which is contained in
 692      special ELF sections. */
 693
 694   /* If we are reinitializing, or if we have never loaded syms yet,
 695      set table to empty.  MAINLINE is cleared so that *_read_psymtab
 696      functions do not all also re-initialize the psymbol table. */
 697   if (mainline)
 698     {
 699       init_psymbol_list (objfile, 0);
 700       mainline = 0;
 701     }
 702
 703   /* We first have to find them... */
 704   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 705
 706   /* ELF debugging information is inserted into the psymtab in the
 707      order of least informative first - most informative last.  Since
 708      the psymtab table is searched `most recent insertion first' this
 709      increases the probability that more detailed debug information
 710      for a section is found.
 711
 712      For instance, an object file might contain both .mdebug (XCOFF)
 713      and .debug_info (DWARF2) sections then .mdebug is inserted first
 714      (searched last) and DWARF2 is inserted last (searched first).  If
 715      we don't do this then the XCOFF info is found first - for code in
 716      an included file XCOFF info is useless. */
 717
 718   if (ei.mdebugsect)
 719     {
 720       const struct ecoff_debug_swap *swap;
 721
 722       /* .mdebug section, presumably holding ECOFF debugging
 723          information.  */
 724       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 725       if (swap)
 726         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 727     }
 728   if (ei.stabsect)
 729     {
 730       asection *str_sect;
 731
 732       /* Stab sections have an associated string table that looks like
 733          a separate section.  */
 734       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 735
 736       /* FIXME should probably warn about a stab section without a stabstr.  */
 737       if (str_sect)
 738         elfstab_build_psymtabs (objfile,
 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 }