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    This function only does the minimum work necessary for letting the
 580    user "name" things symbolically; it does not read the entire symtab.
 581    Instead, it reads the external and static symbols and puts them in partial
 582    symbol tables.  When more extensive information is requested of a
 583    file, the corresponding partial symbol table is mutated into a full
 584    fledged symbol table by going back and reading the symbols
 585    for real.
 586
 587    We look for sections with specific names, to tell us what debug
 588    format to look for:  FIXME!!!
 589
 590    elfstab_build_psymtabs() handles STABS symbols;
 591    mdebug_build_psymtabs() handles ECOFF debugging information.
 592
 593    Note that ELF files have a "minimal" symbol table, which looks a lot
 594    like a COFF symbol table, but has only the minimal information necessary
 595    for linking.  We process this also, and use the information to
 596    build gdb's minimal symbol table.  This gives us some minimal debugging
 597    capability even for files compiled without -g.  */
 598
 599 static void
 600 elf_symfile_read (struct objfile *objfile, int symfile_flags)
 601 {
 602   bfd *abfd = objfile->obfd;
 603   struct elfinfo ei;
 604   struct cleanup *back_to;
 605   CORE_ADDR offset;
 606   long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
 607   asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
 608   asymbol *synthsyms;
 609
 610   init_minimal_symbol_collection ();
 611   back_to = make_cleanup_discard_minimal_symbols ();
 612
 613   memset ((char *) &ei, 0, sizeof (ei));
 614
 615   /* Allocate struct to keep track of the symfile */
 616   objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
 617     xmalloc (sizeof (struct dbx_symfile_info));
 618   memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 619   make_cleanup (free_elfinfo, (void *) objfile);
 620
 621   /* Process the normal ELF symbol table first.  This may write some
 622      chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
 623      which can later be used by elfstab_offset_sections.  */
 624
 625   storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 626   if (storage_needed < 0)
 627     error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 628            bfd_errmsg (bfd_get_error ()));
 629
 630   if (storage_needed > 0)
 631     {
 632       symbol_table = (asymbol **) xmalloc (storage_needed);
 633       make_cleanup (xfree, symbol_table);
 634       symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 635
 636       if (symcount < 0)
 637         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 638                bfd_errmsg (bfd_get_error ()));
 639
 640       elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
 641     }
 642
 643   /* Add the dynamic symbols.  */
 644
 645   storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
 646
 647   if (storage_needed > 0)
 648     {
 649       dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
 650       make_cleanup (xfree, dyn_symbol_table);
 651       dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
 652                                                      dyn_symbol_table);
 653
 654       if (dynsymcount < 0)
 655         error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
 656                bfd_errmsg (bfd_get_error ()));
 657
 658       elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
 659     }
 660
 661   /* Add synthetic symbols - for instance, names for any PLT entries.  */
 662
 663   synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
 664                                          dynsymcount, dyn_symbol_table,
 665                                          &synthsyms);
 666   if (synthcount > 0)
 667     {
 668       asymbol **synth_symbol_table;
 669       long i;
 670
 671       make_cleanup (xfree, synthsyms);
 672       synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
 673       for (i = 0; i < synthcount; i++)
 674         synth_symbol_table[i] = synthsyms + i;
 675       make_cleanup (xfree, synth_symbol_table);
 676       elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
 677     }
 678
 679   /* Install any minimal symbols that have been collected as the current
 680      minimal symbols for this objfile.  The debug readers below this point
 681      should not generate new minimal symbols; if they do it's their
 682      responsibility to install them.  "mdebug" appears to be the only one
 683      which will do this.  */
 684
 685   install_minimal_symbols (objfile);
 686   do_cleanups (back_to);
 687
 688   /* Now process debugging information, which is contained in
 689      special ELF sections. */
 690
 691   /* We first have to find them... */
 692   bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
 693
 694   /* ELF debugging information is inserted into the psymtab in the
 695      order of least informative first - most informative last.  Since
 696      the psymtab table is searched `most recent insertion first' this
 697      increases the probability that more detailed debug information
 698      for a section is found.
 699
 700      For instance, an object file might contain both .mdebug (XCOFF)
 701      and .debug_info (DWARF2) sections then .mdebug is inserted first
 702      (searched last) and DWARF2 is inserted last (searched first).  If
 703      we don't do this then the XCOFF info is found first - for code in
 704      an included file XCOFF info is useless. */
 705
 706   if (ei.mdebugsect)
 707     {
 708       const struct ecoff_debug_swap *swap;
 709
 710       /* .mdebug section, presumably holding ECOFF debugging
 711          information.  */
 712       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 713       if (swap)
 714         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
 715     }
 716   if (ei.stabsect)
 717     {
 718       asection *str_sect;
 719
 720       /* Stab sections have an associated string table that looks like
 721          a separate section.  */
 722       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
 723
 724       /* FIXME should probably warn about a stab section without a stabstr.  */
 725       if (str_sect)
 726         elfstab_build_psymtabs (objfile,
 727                                 ei.stabsect,
 728                                 str_sect->filepos,
 729                                 bfd_section_size (abfd, str_sect));
 730     }
 731   if (dwarf2_has_info (objfile))
 732     {
 733       /* DWARF 2 sections */
 734       dwarf2_build_psymtabs (objfile);
 735     }
 736
 737   /* FIXME: kettenis/20030504: This still needs to be integrated with
 738      dwarf2read.c in a better way.  */
 739   dwarf2_build_frame_info (objfile);
 740
 741   /* If the file has its own symbol tables it has no separate debug info.
 742      `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
 743      `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'.  */
 744   if (!objfile_has_partial_symbols (objfile))
 745     {
 746       char *debugfile;
 747
 748       debugfile = find_separate_debug_file_by_buildid (objfile);
 749
 750       if (debugfile == NULL)
 751         debugfile = find_separate_debug_file_by_debuglink (objfile);
 752
 753       if (debugfile)
 754         {
 755           bfd *abfd = symfile_bfd_open (debugfile);
 756           symbol_file_add_separate (abfd, symfile_flags, objfile);
 757           xfree (debugfile);
 758         }
 759     }
 760 }
 761
 762 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
 763    the chain of stab_section_info's, that might be dangling from
 764    it.  */
 765
 766 static void
 767 free_elfinfo (void *objp)
 768 {
 769   struct objfile *objfile = (struct objfile *) objp;
 770   struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
 771   struct stab_section_info *ssi, *nssi;
 772
 773   ssi = dbxinfo->stab_section_info;
 774   while (ssi)
 775     {
 776       nssi = ssi->next;
 777       xfree (ssi);
 778       ssi = nssi;
 779     }
 780
 781   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 782 }
 783
 784
 785 /* Initialize anything that needs initializing when a completely new symbol
 786    file is specified (not just adding some symbols from another file, e.g. a
 787    shared library).
 788
 789    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 790
 791 static void
 792 elf_new_init (struct objfile *ignore)
 793 {
 794   stabsread_new_init ();
 795   buildsym_new_init ();
 796 }
 797
 798 /* Perform any local cleanups required when we are done with a particular
 799    objfile.  I.E, we are in the process of discarding all symbol information
 800    for an objfile, freeing up all memory held for it, and unlinking the
 801    objfile struct from the global list of known objfiles. */
 802
 803 static void
 804 elf_symfile_finish (struct objfile *objfile)
 805 {
 806   if (objfile->deprecated_sym_stab_info != NULL)
 807     {
 808       xfree (objfile->deprecated_sym_stab_info);
 809     }
 810
 811   dwarf2_free_objfile (objfile);
 812 }
 813
 814 /* ELF specific initialization routine for reading symbols.
 815
 816    It is passed a pointer to a struct sym_fns which contains, among other
 817    things, the BFD for the file whose symbols are being read, and a slot for
 818    a pointer to "private data" which we can fill with goodies.
 819
 820    For now at least, we have nothing in particular to do, so this function is
 821    just a stub. */
 822
 823 static void
 824 elf_symfile_init (struct objfile *objfile)
 825 {
 826   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
 827      find this causes a significant slowdown in gdb then we could
 828      set it in the debug symbol readers only when necessary.  */
 829   objfile->flags |= OBJF_REORDERED;
 830 }
 831
 832 /* When handling an ELF file that contains Sun STABS debug info,
 833    some of the debug info is relative to the particular chunk of the
 834    section that was generated in its individual .o file.  E.g.
 835    offsets to static variables are relative to the start of the data
 836    segment *for that module before linking*.  This information is
 837    painfully squirreled away in the ELF symbol table as local symbols
 838    with wierd names.  Go get 'em when needed.  */
 839
 840 void
 841 elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
 842 {
 843   char *filename = pst->filename;
 844   struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
 845   struct stab_section_info *maybe = dbx->stab_section_info;
 846   struct stab_section_info *questionable = 0;
 847   int i;
 848   char *p;
 849
 850   /* The ELF symbol info doesn't include path names, so strip the path
 851      (if any) from the psymtab filename.  */
 852   while (0 != (p = strchr (filename, '/')))
 853     filename = p + 1;
 854
 855   /* FIXME:  This linear search could speed up significantly
 856      if it was chained in the right order to match how we search it,
 857      and if we unchained when we found a match. */
 858   for (; maybe; maybe = maybe->next)
 859     {
 860       if (filename[0] == maybe->filename[0]
 861           && strcmp (filename, maybe->filename) == 0)
 862         {
 863           /* We found a match.  But there might be several source files
 864              (from different directories) with the same name.  */
 865           if (0 == maybe->found)
 866             break;
 867           questionable = maybe; /* Might use it later.  */
 868         }
 869     }
 870
 871   if (maybe == 0 && questionable != 0)
 872     {
 873       complaint (&symfile_complaints,
 874                  _("elf/stab section information questionable for %s"), filename);
 875       maybe = questionable;
 876     }
 877
 878   if (maybe)
 879     {
 880       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 881       maybe->found++;
 882       pst->section_offsets = (struct section_offsets *)
 883         obstack_alloc (&objfile->objfile_obstack,
 884                        SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 885       for (i = 0; i < maybe->num_sections; i++)
 886         (pst->section_offsets)->offsets[i] = maybe->sections[i];
 887       return;
 888     }
 889
 890   /* We were unable to find any offsets for this file.  Complain.  */
 891   if (dbx->stab_section_info)   /* If there *is* any info, */
 892     complaint (&symfile_complaints,
 893                _("elf/stab section information missing for %s"), filename);
 894 }
 895 \f
 896 /* Register that we are able to handle ELF object file formats.  */
 897
 898 static struct sym_fns elf_sym_fns =
 899 {
 900   bfd_target_elf_flavour,
 901   elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
 902   elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
 903   elf_symfile_read,             /* sym_read: read a symbol file into symtab */
 904   elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
 905   default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
 906   elf_symfile_segments,         /* sym_segments: Get segment information from
 907                                    a file.  */
 908   NULL,                         /* sym_read_linetable */
 909   NULL                          /* next: pointer to next struct sym_fns */
 910 };
 911
 912 void
 913 _initialize_elfread (void)
 914 {
 915   add_symtab_fns (&elf_sym_fns);
 916 }