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