gdb/elfread.c

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