gdb/elfread.c

   1 /* Read ELF (Executable and Linking Format) object files for GDB.
   2    Copyright 1991, 1992 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /************************************************************************
  22  *                                                                      *
  23  *                              NOTICE                                  *
  24  *                                                                      *
  25  * This file is still under construction.  When it is complete, this    *
  26  * notice will be removed.  Until then, direct any questions or changes *
  27  * to Fred Fish at Cygnus Support (fnf@cygnus.com)                      *
  28  *                                                                      *
  29  * FIXME        Still needs support for shared libraries.               *
  30  * FIXME        Still needs support for core files.                     *
  31  * FIXME        The ".debug" and ".line" section names are hardwired.   *
  32  *                                                                      *
  33  ************************************************************************/
  34
  35 #include "defs.h"
  36 #include "elf/common.h"
  37 #include "elf/external.h"
  38 #include "elf/internal.h"
  39 #include "bfd.h"
  40 #include "libbfd.h"             /* For bfd_elf_find_section */
  41 #include "symtab.h"
  42 #include "symfile.h"
  43 #include "objfiles.h"
  44 #include "buildsym.h"
  45 #include "gdb-stabs.h"
  46 #include "complaints.h"
  47 #include <string.h>
  48 #include "demangle.h"
  49
  50 /* The struct elfinfo is available only during ELF symbol table and
  51    psymtab reading.  It is destroyed at the complation of psymtab-reading.
  52    It's local to elf_symfile_read.  */
  53
  54 struct elfinfo {
  55   file_ptr dboffset;            /* Offset to dwarf debug section */
  56   unsigned int dbsize;          /* Size of dwarf debug section */
  57   file_ptr lnoffset;            /* Offset to dwarf line number section */
  58   unsigned int lnsize;          /* Size of dwarf line number section */
  59   asection *stabsect;           /* Section pointer for .stab section */
  60   asection *stabindexsect;      /* Section pointer for .stab.index section */
  61 };
  62
  63 /* Various things we might complain about... */
  64
  65 struct complaint section_info_complaint =
  66   {"elf/stab section information %s without a preceding file symbol", 0, 0};
  67
  68 struct complaint section_info_dup_complaint =
  69   {"duplicated elf/stab section information for %s", 0, 0};
  70
  71 struct complaint stab_info_mismatch_complaint =
  72   {"elf/stab section information missing for %s", 0, 0};
  73
  74 struct complaint stab_info_questionable_complaint =
  75   {"elf/stab section information questionable for %s", 0, 0};
  76
  77 static void
  78 elf_symfile_init PARAMS ((struct objfile *));
  79
  80 static void
  81 elf_new_init PARAMS ((struct objfile *));
  82
  83 static void
  84 elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  85
  86 static void
  87 elf_symfile_finish PARAMS ((struct objfile *));
  88
  89 static void
  90 elf_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *));
  91
  92 static void
  93 free_elfinfo PARAMS ((PTR));
  94
  95 static struct section_offsets *
  96 elf_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
  97
  98 static void
  99 record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR,
 100                                         enum minimal_symbol_type, char *,
 101                                         struct objfile *));
 102
 103 static void
 104 elf_locate_sections PARAMS ((bfd *, asection *, PTR));
 105
 106 /* We are called once per section from elf_symfile_read.  We
 107    need to examine each section we are passed, check to see
 108    if it is something we are interested in processing, and
 109    if so, stash away some access information for the section.
 110
 111    For now we recognize the dwarf debug information sections and
 112    line number sections from matching their section names.  The
 113    ELF definition is no real help here since it has no direct
 114    knowledge of DWARF (by design, so any debugging format can be
 115    used).
 116
 117    We also recognize the ".stab" sections used by the Sun compilers
 118    released with Solaris 2.
 119
 120    FIXME:  The section names should not be hardwired strings. */
 121
 122 static void
 123 elf_locate_sections (ignore_abfd, sectp, eip)
 124      bfd *ignore_abfd;
 125      asection *sectp;
 126      PTR eip;
 127 {
 128   register struct elfinfo *ei;
 129
 130   ei = (struct elfinfo *) eip;
 131   if (STREQ (sectp -> name, ".debug"))
 132     {
 133       ei -> dboffset = sectp -> filepos;
 134       ei -> dbsize = bfd_get_section_size_before_reloc (sectp);
 135     }
 136   else if (STREQ (sectp -> name, ".line"))
 137     {
 138       ei -> lnoffset = sectp -> filepos;
 139       ei -> lnsize = bfd_get_section_size_before_reloc (sectp);
 140     }
 141   else if (STREQ (sectp -> name, ".stab"))
 142     {
 143       ei -> stabsect = sectp;
 144     }
 145   else if (STREQ (sectp -> name, ".stab.index"))
 146     {
 147       ei -> stabindexsect = sectp;
 148     }
 149 }
 150
 151 #if 0   /* Currently unused */
 152
 153 char *
 154 elf_interpreter (abfd)
 155      bfd *abfd;
 156 {
 157   sec_ptr interp_sec;
 158   unsigned size;
 159   char *interp = NULL;
 160
 161   interp_sec = bfd_get_section_by_name (abfd, ".interp");
 162   if (interp_sec)
 163     {
 164       size = bfd_section_size (abfd, interp_sec);
 165       interp = alloca (size);
 166       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
 167                                     size))
 168         {
 169           interp = savestring (interp, size - 1);
 170         }
 171       else
 172         {
 173           interp = NULL;
 174         }
 175     }
 176   return (interp);
 177 }
 178
 179 #endif
 180
 181 static void
 182 record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
 183      char *name;
 184      CORE_ADDR address;
 185      enum minimal_symbol_type ms_type;
 186      char *info;                /* FIXME, is this really char *? */
 187      struct objfile *objfile;
 188 {
 189   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
 190   prim_record_minimal_symbol_and_info (name, address, ms_type, info, -1);
 191 }
 192
 193 /*
 194
 195 LOCAL FUNCTION
 196
 197         elf_symtab_read -- read the symbol table of an ELF file
 198
 199 SYNOPSIS
 200
 201         void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
 202                               struct objfile *objfile)
 203
 204 DESCRIPTION
 205
 206         Given an open bfd, a base address to relocate symbols to, and a
 207         flag that specifies whether or not this bfd is for an executable
 208         or not (may be shared library for example), add all the global
 209         function and data symbols to the minimal symbol table.
 210
 211         In stabs-in-ELF, as implemented by Sun, there are some local symbols
 212         defined in the ELF symbol table, which can be used to locate
 213         the beginnings of sections from each ".o" file that was linked to
 214         form the executable objfile.  We gather any such info and record it
 215         in data structures hung off the objfile's private data.
 216
 217 */
 218
 219 static void
 220 elf_symtab_read (abfd, addr, objfile)
 221      bfd *abfd;
 222      CORE_ADDR addr;
 223      struct objfile *objfile;
 224 {
 225   unsigned int storage_needed;
 226   asymbol *sym;
 227   asymbol **symbol_table;
 228   unsigned int number_of_symbols;
 229   unsigned int i;
 230   int index;
 231   struct cleanup *back_to;
 232   CORE_ADDR symaddr;
 233   enum minimal_symbol_type ms_type;
 234   /* If sectinfo is nonzero, it contains section info that should end up
 235      filed in the objfile.  */
 236   struct stab_section_info *sectinfo = 0;
 237   /* If filesym is nonzero, it points to a file symbol, but we haven't
 238      seen any section info for it yet.  */
 239   asymbol *filesym = 0;
 240   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
 241                                  objfile->sym_private;
 242
 243   storage_needed = get_symtab_upper_bound (abfd);
 244
 245   if (storage_needed > 0)
 246     {
 247       symbol_table = (asymbol **) xmalloc (storage_needed);
 248       back_to = make_cleanup (free, symbol_table);
 249       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 250
 251       for (i = 0; i < number_of_symbols; i++)
 252         {
 253           sym = symbol_table[i];
 254           /* Select global/weak symbols that are defined in a specific section.
 255              Note that bfd now puts abs symbols in their own section, so
 256              all symbols we are interested in will have a section. */
 257           if ((sym -> flags & (BSF_GLOBAL | BSF_WEAK))
 258               && (sym -> section != NULL))
 259             {
 260               symaddr = sym -> value;
 261               /* Relocate all non-absolute symbols by base address.  */
 262               if (sym -> section != &bfd_abs_section)
 263                 symaddr += addr;
 264
 265               /* For non-absolute symbols, use the type of the section
 266                  they are relative to, to intuit text/data.  Bfd provides
 267                  no way of figuring this out for absolute symbols. */
 268               if (sym -> section -> flags & SEC_CODE)
 269                 {
 270                   ms_type = mst_text;
 271                 }
 272               else if (sym -> section -> flags & SEC_DATA)
 273                 {
 274                   ms_type = mst_data;
 275                 }
 276               else
 277                 {
 278                   /* FIXME:  Solaris2 shared libraries include lots of
 279                      odd "absolute" and "undefined" symbols, that play
 280                      hob with actions like finding what function the PC
 281                      is in.  Ignore them if they aren't text or data.  */
 282                   /* ms_type = mst_unknown; */
 283                   continue;             /* Skip this symbol. */
 284                 }
 285               /* Pass symbol size field in via BFD.  FIXME!!!  */
 286               record_minimal_symbol_and_info ((char *) sym -> name,
 287                          symaddr, ms_type, sym->udata, objfile);
 288             }
 289
 290           /* See if this is a debugging symbol that helps Solaris
 291              stabs-in-elf debugging.  */
 292
 293           else if (sym->flags & BSF_FILE)
 294             {
 295               /* Chain any old one onto the objfile; remember new sym.  */
 296               if (sectinfo)
 297                 {
 298                     sectinfo->next = dbx->stab_section_info;
 299                     dbx->stab_section_info = sectinfo;
 300                     sectinfo = 0;
 301                 }
 302               filesym = sym;
 303             }
 304           else if ((sym->flags & BSF_LOCAL) &&
 305                    (sym->section) &&
 306                    (sym->section->flags & SEC_DATA) &&
 307                    (sym->name))
 308             {
 309               /* Named Local variable in a Data section.  Check its name.  */
 310               index = -1;
 311               switch (sym->name[1])
 312                 {
 313                   case 'b':
 314                         if (STREQ ("Bbss.bss", sym->name))
 315                           index = SECT_OFF_BSS;
 316                         break;
 317                   case 'd':
 318                         if (STREQ ("Ddata.data", sym->name))
 319                           index = SECT_OFF_DATA;
 320                         break;
 321                   case 'r':
 322                         if (STREQ ("Drodata.rodata", sym->name))
 323                           index = SECT_OFF_RODATA;
 324                         break;
 325                 }
 326               if (index > 0)
 327                 {
 328                   /* We have some new info.  Allocate a sectinfo, if
 329                      needed, and fill it in.  */
 330                   if (!sectinfo)
 331                     {
 332                       sectinfo = (struct stab_section_info *)
 333                                  xmmalloc (objfile -> md,
 334                                            sizeof (*sectinfo));
 335                       memset ((PTR) sectinfo, 0, sizeof (*sectinfo));
 336                       if (!filesym)
 337                         complain (&section_info_complaint, sym->name);
 338                       else
 339                         sectinfo->filename = (char *)filesym->name;
 340                     }
 341                   if (sectinfo->sections[index])
 342                     complain (&section_info_dup_complaint, sectinfo->filename);
 343
 344                   symaddr = sym -> value;
 345                   /* Relocate all non-absolute symbols by base address.  */
 346                   if (sym -> section != &bfd_abs_section)
 347                       symaddr += addr;
 348                   sectinfo->sections[index] = symaddr;
 349                 }
 350             }
 351         }
 352       do_cleanups (back_to);
 353     }
 354 }
 355
 356 /* Scan and build partial symbols for a symbol file.
 357    We have been initialized by a call to elf_symfile_init, which
 358    currently does nothing.
 359
 360    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 361    in each section.  We simplify it down to a single offset for all
 362    symbols.  FIXME.
 363
 364    MAINLINE is true if we are reading the main symbol
 365    table (as opposed to a shared lib or dynamically loaded file).
 366
 367    This function only does the minimum work necessary for letting the
 368    user "name" things symbolically; it does not read the entire symtab.
 369    Instead, it reads the external and static symbols and puts them in partial
 370    symbol tables.  When more extensive information is requested of a
 371    file, the corresponding partial symbol table is mutated into a full
 372    fledged symbol table by going back and reading the symbols
 373    for real.
 374
 375    We look for sections with specific names, to tell us what debug
 376    format to look for:  FIXME!!!
 377
 378    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 379    elfstab_build_psymtabs() handles STABS symbols.
 380
 381    Note that ELF files have a "minimal" symbol table, which looks a lot
 382    like a COFF symbol table, but has only the minimal information necessary
 383    for linking.  We process this also, and use the information to
 384    build gdb's minimal symbol table.  This gives us some minimal debugging
 385    capability even for files compiled without -g.  */
 386
 387 static void
 388 elf_symfile_read (objfile, section_offsets, mainline)
 389      struct objfile *objfile;
 390      struct section_offsets *section_offsets;
 391      int mainline;
 392 {
 393   bfd *abfd = objfile->obfd;
 394   struct elfinfo ei;
 395   struct cleanup *back_to;
 396   CORE_ADDR offset;
 397
 398   init_minimal_symbol_collection ();
 399   back_to = make_cleanup (discard_minimal_symbols, 0);
 400
 401   memset ((char *) &ei, 0, sizeof (ei));
 402
 403   /* Allocate struct to keep track of the symfile */
 404   objfile->sym_private = (PTR)
 405     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
 406   memset ((char *) objfile->sym_private, 0, sizeof (struct dbx_symfile_info));
 407   make_cleanup (free_elfinfo, (PTR) objfile);
 408
 409   /* Process the normal ELF symbol table first.  This may write some
 410      chain of info into the dbx_symfile_info in objfile->sym_private,
 411      which can later be used by elfstab_offset_sections.  */
 412
 413   /* FIXME, should take a section_offsets param, not just an offset.  */
 414   offset = ANOFFSET (section_offsets, 0);
 415   elf_symtab_read (abfd, offset, objfile);
 416
 417   /* Now process debugging information, which is contained in
 418      special ELF sections.  We first have to find them... */
 419
 420   bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei);
 421   if (ei.dboffset && ei.lnoffset)
 422     {
 423       /* DWARF sections */
 424       dwarf_build_psymtabs (objfile,
 425                             section_offsets, mainline,
 426                             ei.dboffset, ei.dbsize,
 427                             ei.lnoffset, ei.lnsize);
 428     }
 429   if (ei.stabsect)
 430     {
 431       /* STABS sections */
 432
 433       /* FIXME:  Sun didn't really know how to implement this well.
 434          They made .stab sections that don't point to the .stabstr
 435          section with the sh_link field.  BFD doesn't make string table
 436          sections visible to the caller.  So we have to search the
 437          ELF section table, not the BFD section table, for the string
 438          table.  */
 439       struct elf_internal_shdr *elf_sect;
 440
 441       elf_sect = bfd_elf_find_section (abfd, ".stabstr");
 442       if (elf_sect)
 443         elfstab_build_psymtabs (objfile,
 444           section_offsets,
 445           mainline,
 446           ei.stabsect->filepos,                         /* .stab offset */
 447           bfd_get_section_size_before_reloc (ei.stabsect),/* .stab size */
 448           (file_ptr) elf_sect->sh_offset,               /* .stabstr offset */
 449           elf_sect->sh_size);                           /* .stabstr size */
 450     }
 451
 452   if (!have_partial_symbols ())
 453     {
 454       wrap_here ("");
 455       printf_filtered ("(no debugging symbols found)...");
 456       wrap_here ("");
 457     }
 458
 459   /* Install any minimal symbols that have been collected as the current
 460      minimal symbols for this objfile. */
 461
 462   install_minimal_symbols (objfile);
 463
 464   do_cleanups (back_to);
 465 }
 466
 467 /* This cleans up the objfile's sym_private pointer, and the chain of
 468    stab_section_info's, that might be dangling from it.  */
 469
 470 static void
 471 free_elfinfo (objp)
 472      PTR objp;
 473 {
 474   struct objfile *objfile = (struct objfile *)objp;
 475   struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
 476                                      objfile->sym_private;
 477   struct stab_section_info *ssi, *nssi;
 478
 479   ssi = dbxinfo->stab_section_info;
 480   while (ssi)
 481     {
 482       nssi = ssi->next;
 483       mfree (objfile->md, ssi);
 484       ssi = nssi;
 485     }
 486
 487   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 488 }
 489
 490
 491 /* Initialize anything that needs initializing when a completely new symbol
 492    file is specified (not just adding some symbols from another file, e.g. a
 493    shared library).
 494
 495    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 496
 497 static void
 498 elf_new_init (ignore)
 499      struct objfile *ignore;
 500 {
 501   stabsread_new_init ();
 502   buildsym_new_init ();
 503 }
 504
 505 /* Perform any local cleanups required when we are done with a particular
 506    objfile.  I.E, we are in the process of discarding all symbol information
 507    for an objfile, freeing up all memory held for it, and unlinking the
 508    objfile struct from the global list of known objfiles. */
 509
 510 static void
 511 elf_symfile_finish (objfile)
 512      struct objfile *objfile;
 513 {
 514   if (objfile -> sym_private != NULL)
 515     {
 516       mfree (objfile -> md, objfile -> sym_private);
 517     }
 518 }
 519
 520 /* ELF specific initialization routine for reading symbols.
 521
 522    It is passed a pointer to a struct sym_fns which contains, among other
 523    things, the BFD for the file whose symbols are being read, and a slot for
 524    a pointer to "private data" which we can fill with goodies.
 525
 526    For now at least, we have nothing in particular to do, so this function is
 527    just a stub. */
 528
 529 static void
 530 elf_symfile_init (ignore)
 531      struct objfile *ignore;
 532 {
 533 }
 534
 535 /* ELF specific parsing routine for section offsets.
 536
 537    Plain and simple for now.  */
 538
 539 static
 540 struct section_offsets *
 541 elf_symfile_offsets (objfile, addr)
 542      struct objfile *objfile;
 543      CORE_ADDR addr;
 544 {
 545   struct section_offsets *section_offsets;
 546   int i;
 547
 548   section_offsets = (struct section_offsets *)
 549     obstack_alloc (&objfile -> psymbol_obstack,
 550                    sizeof (struct section_offsets) +
 551                           sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 552
 553   for (i = 0; i < SECT_OFF_MAX; i++)
 554     ANOFFSET (section_offsets, i) = addr;
 555
 556   return section_offsets;
 557 }
 558 \f
 559 /* When handling an ELF file that contains Sun STABS debug info,
 560    some of the debug info is relative to the particular chunk of the
 561    section that was generated in its individual .o file.  E.g.
 562    offsets to static variables are relative to the start of the data
 563    segment *for that module before linking*.  This information is
 564    painfully squirreled away in the ELF symbol table as local symbols
 565    with wierd names.  Go get 'em when needed.  */
 566
 567 void
 568 elfstab_offset_sections (objfile, pst)
 569      struct objfile *objfile;
 570      struct partial_symtab *pst;
 571 {
 572   char *filename = pst->filename;
 573   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
 574                                  objfile->sym_private;
 575   struct stab_section_info *maybe = dbx->stab_section_info;
 576   struct stab_section_info *questionable = 0;
 577   int i;
 578   char *p;
 579
 580   /* The ELF symbol info doesn't include path names, so strip the path
 581      (if any) from the psymtab filename.  */
 582   while (0 != (p = strchr (filename, '/')))
 583     filename = p+1;
 584
 585   /* FIXME:  This linear search could speed up significantly
 586      if it was chained in the right order to match how we search it,
 587      and if we unchained when we found a match. */
 588   for (; maybe; maybe = maybe->next)
 589     {
 590       if (filename[0] == maybe->filename[0]
 591           && STREQ (filename, maybe->filename))
 592         {
 593           /* We found a match.  But there might be several source files
 594              (from different directories) with the same name.  */
 595           if (0 == maybe->found)
 596             break;
 597           questionable = maybe;         /* Might use it later.  */
 598         }
 599     }
 600
 601   if (maybe == 0 && questionable != 0)
 602     {
 603       complain (&stab_info_questionable_complaint, filename);
 604       maybe = questionable;
 605     }
 606
 607   if (maybe)
 608     {
 609       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
 610       maybe->found++;
 611       pst->section_offsets = (struct section_offsets *)
 612         obstack_alloc (&objfile -> psymbol_obstack,
 613                        sizeof (struct section_offsets) +
 614                sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1));
 615
 616       for (i = 0; i < SECT_OFF_MAX; i++)
 617         ANOFFSET (pst->section_offsets, i) = maybe->sections[i];
 618       return;
 619     }
 620
 621   /* We were unable to find any offsets for this file.  Complain.  */
 622   if (dbx->stab_section_info)           /* If there *is* any info, */
 623     complain (&stab_info_mismatch_complaint, filename);
 624 }
 625 \f
 626 /*  Register that we are able to handle ELF object file formats and DWARF
 627     debugging formats.
 628
 629     Unlike other object file formats, where the debugging information format
 630     is implied by the object file format, the ELF object file format and the
 631     DWARF debugging information format are two distinct, and potentially
 632     separate entities.  I.E. it is perfectly possible to have ELF objects
 633     with debugging formats other than DWARF.  And it is conceivable that the
 634     DWARF debugging format might be used with another object file format,
 635     like COFF, by simply using COFF's custom section feature.
 636
 637     GDB, and to a lesser extent BFD, should support the notion of separate
 638     object file formats and debugging information formats.  For now, we just
 639     use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
 640     object file format and the DWARF debugging format. */
 641
 642 static struct sym_fns elf_sym_fns =
 643 {
 644   "elf",                /* sym_name: name or name prefix of BFD target type */
 645   3,                    /* sym_namelen: number of significant sym_name chars */
 646   elf_new_init,         /* sym_new_init: init anything gbl to entire symtab */
 647   elf_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
 648   elf_symfile_read,     /* sym_read: read a symbol file into symtab */
 649   elf_symfile_finish,   /* sym_finish: finished with file, cleanup */
 650   elf_symfile_offsets,  /* sym_offsets:  Translate ext. to int. relocation */
 651   NULL                  /* next: pointer to next struct sym_fns */
 652 };
 653
 654 void
 655 _initialize_elfread ()
 656 {
 657   add_symtab_fns (&elf_sym_fns);
 658 }