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 "symtab.h"
  41 #include "symfile.h"
  42 #include "objfiles.h"
  43 #include "buildsym.h"
  44
  45 #define STREQ(a,b) (strcmp((a),(b))==0)
  46
  47 struct elfinfo {
  48   unsigned int dboffset;        /* Offset to dwarf debug section */
  49   unsigned int dbsize;          /* Size of dwarf debug section */
  50   unsigned int lnoffset;        /* Offset to dwarf line number section */
  51   unsigned int lnsize;          /* Size of dwarf line number section */
  52   asection *stabsect;           /* Section pointer for .stab section */
  53   asection *stabindexsect;      /* Section pointer for .stab.index section */
  54 };
  55
  56 static void
  57 elf_symfile_init PARAMS ((struct objfile *));
  58
  59 static void
  60 elf_new_init PARAMS ((struct objfile *));
  61
  62 static void
  63 elf_symfile_read PARAMS ((struct objfile *, CORE_ADDR, int));
  64
  65 static void
  66 elf_symfile_finish PARAMS ((struct objfile *));
  67
  68 static void
  69 elf_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *));
  70
  71 static void
  72 record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type,
  73                                struct objfile *));
  74
  75 static void
  76 elf_locate_sections PARAMS ((bfd *, asection *, PTR));
  77
  78 /* We are called once per section from elf_symfile_read.  We
  79    need to examine each section we are passed, check to see
  80    if it is something we are interested in processing, and
  81    if so, stash away some access information for the section.
  82
  83    For now we recognize the dwarf debug information sections and
  84    line number sections from matching their section names.  The
  85    ELF definition is no real help here since it has no direct
  86    knowledge of DWARF (by design, so any debugging format can be
  87    used).
  88
  89    We also recognize the ".stab" sections used by the Sun compilers
  90    released with Solaris 2.
  91
  92    FIXME:  The section names should not be hardwired strings. */
  93
  94 static void
  95 elf_locate_sections (ignore_abfd, sectp, eip)
  96      bfd *ignore_abfd;
  97      asection *sectp;
  98      PTR eip;
  99 {
 100   register struct elfinfo *ei;
 101
 102   ei = (struct elfinfo *) eip;
 103   if (STREQ (sectp -> name, ".debug"))
 104     {
 105       ei -> dboffset = sectp -> filepos;
 106       ei -> dbsize = bfd_get_section_size_before_reloc (sectp);
 107     }
 108   else if (STREQ (sectp -> name, ".line"))
 109     {
 110       ei -> lnoffset = sectp -> filepos;
 111       ei -> lnsize = bfd_get_section_size_before_reloc (sectp);
 112     }
 113   else if (STREQ (sectp -> name, ".stab"))
 114     {
 115       ei -> stabsect = sectp;
 116     }
 117   else if (STREQ (sectp -> name, ".stab.index"))
 118     {
 119       ei -> stabindexsect = sectp;
 120     }
 121 }
 122
 123 #if 0   /* Currently unused */
 124
 125 char *
 126 elf_interpreter (abfd)
 127      bfd *abfd;
 128 {
 129   sec_ptr interp_sec;
 130   unsigned size;
 131   char *interp = NULL;
 132
 133   interp_sec = bfd_get_section_by_name (abfd, ".interp");
 134   if (interp_sec)
 135     {
 136       size = bfd_section_size (abfd, interp_sec);
 137       interp = alloca (size);
 138       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
 139                                     size))
 140         {
 141           interp = savestring (interp, size - 1);
 142         }
 143       else
 144         {
 145           interp = NULL;
 146         }
 147     }
 148   return (interp);
 149 }
 150
 151 #endif
 152
 153 /*
 154
 155 LOCAL FUNCTION
 156
 157         record_minimal_symbol -- add entry to minimal symbol table
 158
 159 SYNOPSIS
 160
 161         static void record_minimal_symbol (char *name, CORE_ADDR address)
 162
 163 DESCRIPTION
 164
 165         Given a pointer to the name of a symbol that should be added to the
 166         minimal symbol table and the address associated with that symbol, records
 167         this information for later use in building the minimal symbol table.
 168
 169  */
 170
 171 static void
 172 record_minimal_symbol (name, address, ms_type, objfile)
 173      char *name;
 174      CORE_ADDR address;
 175      enum minimal_symbol_type ms_type;
 176      struct objfile *objfile;
 177 {
 178   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
 179   prim_record_minimal_symbol (name, address, ms_type);
 180 }
 181
 182 static void
 183 record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
 184      char *name;
 185      CORE_ADDR address;
 186      enum minimal_symbol_type ms_type;
 187      char *info;                /* FIXME, is this really char *? */
 188      struct objfile *objfile;
 189 {
 190   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
 191   prim_record_minimal_symbol_and_info (name, address, ms_type, info);
 192 }
 193
 194 /*
 195
 196 LOCAL FUNCTION
 197
 198         elf_symtab_read -- read the symbol table of an ELF file
 199
 200 SYNOPSIS
 201
 202         void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
 203                               struct objfile *objfile)
 204
 205 DESCRIPTION
 206
 207         Given an open bfd, a base address to relocate symbols to, and a
 208         flag that specifies whether or not this bfd is for an executable
 209         or not (may be shared library for example), add all the global
 210         function and data symbols to the minimal symbol table.
 211
 212 */
 213
 214 static void
 215 elf_symtab_read (abfd, addr, objfile)
 216      bfd *abfd;
 217      CORE_ADDR addr;
 218      struct objfile *objfile;
 219 {
 220   unsigned int storage_needed;
 221   asymbol *sym;
 222   asymbol **symbol_table;
 223   unsigned int number_of_symbols;
 224   unsigned int i;
 225   struct cleanup *back_to;
 226   CORE_ADDR symaddr;
 227   enum minimal_symbol_type ms_type;
 228
 229   storage_needed = get_symtab_upper_bound (abfd);
 230
 231   if (storage_needed > 0)
 232     {
 233       symbol_table = (asymbol **) xmalloc (storage_needed);
 234       back_to = make_cleanup (free, symbol_table);
 235       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 236
 237       for (i = 0; i < number_of_symbols; i++)
 238         {
 239           sym = *symbol_table++;
 240           /* Select global/weak symbols that are defined in a specific section.
 241              Note that bfd now puts abs symbols in their own section, so
 242              all symbols we are interested in will have a section. */
 243           if ((sym -> flags & (BSF_GLOBAL | BSF_WEAK))
 244               && (sym -> section != NULL))
 245             {
 246               symaddr = sym -> value;
 247               /* Relocate all non-absolute symbols by base address.  */
 248               if (sym -> section != &bfd_abs_section)
 249                 {
 250                   symaddr += addr;
 251                 }
 252               /* For non-absolute symbols, use the type of the section
 253                  they are relative to, to intuit text/data.  Bfd provides
 254                  no way of figuring this out for absolute symbols. */
 255               if (sym -> section -> flags & SEC_CODE)
 256                 {
 257                   ms_type = mst_text;
 258                 }
 259               else if (sym -> section -> flags & SEC_DATA)
 260                 {
 261                   ms_type = mst_data;
 262                 }
 263               else
 264                 {
 265                   ms_type = mst_unknown;
 266                 }
 267               /* Pass symbol size field in via BFD.  FIXME!!!  */
 268               record_minimal_symbol_and_info ((char *) sym -> name,
 269                          symaddr, ms_type, sym->udata, objfile);
 270             }
 271         }
 272       do_cleanups (back_to);
 273     }
 274 }
 275
 276 /* Scan and build partial symbols for a symbol file.
 277    We have been initialized by a call to elf_symfile_init, which
 278    currently does nothing.
 279
 280    ADDR is the address relative to which the symbols in it are (e.g.
 281    the base address of the text segment).
 282
 283    MAINLINE is true if we are reading the main symbol
 284    table (as opposed to a shared lib or dynamically loaded file).
 285
 286    This function only does the minimum work necessary for letting the
 287    user "name" things symbolically; it does not read the entire symtab.
 288    Instead, it reads the external and static symbols and puts them in partial
 289    symbol tables.  When more extensive information is requested of a
 290    file, the corresponding partial symbol table is mutated into a full
 291    fledged symbol table by going back and reading the symbols
 292    for real.
 293
 294    We look for sections with specific names, to tell us what debug
 295    format to look for:  FIXME!!!
 296
 297    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
 298    elfstab_build_psymtabs() handles STABS symbols.
 299
 300    Note that ELF files have a "minimal" symbol table, which looks a lot
 301    like a COFF symbol table, but has only the minimal information necessary
 302    for linking.  We process this also, and use the information to
 303    build gdb's minimal symbol table.  This gives us some minimal debugging
 304    capability even for files compiled without -g.  */
 305
 306 static void
 307 elf_symfile_read (objfile, addr, mainline)
 308      struct objfile *objfile;
 309      CORE_ADDR addr;
 310      int mainline;
 311 {
 312   bfd *abfd = objfile->obfd;
 313   struct elfinfo ei;
 314   struct cleanup *back_to;
 315   asection *text_sect;
 316   CORE_ADDR offset;
 317
 318   init_minimal_symbol_collection ();
 319   back_to = make_cleanup (discard_minimal_symbols, 0);
 320
 321   /* Compute the amount to relocate all symbols by.  The value passed in
 322      as ADDR is typically either the actual address of the text section,
 323      or a user specified address.  By subtracting off the actual address
 324      of the text section, we can compute the relocation amount. */
 325
 326   text_sect = bfd_get_section_by_name (objfile -> obfd, ".text");
 327   offset = addr - bfd_section_vma (objfile -> obfd, text_sect);
 328
 329   /* Process the normal ELF symbol table first. */
 330
 331   elf_symtab_read (abfd, offset, objfile);
 332
 333   /* Now process debugging information, which is contained in
 334      special ELF sections.  We first have to find them... */
 335
 336   (void) memset ((char *) &ei, 0, sizeof (ei));
 337   bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei);
 338   if (ei.dboffset && ei.lnoffset)
 339     {
 340       /* DWARF sections */
 341       dwarf_build_psymtabs (fileno ((FILE *)(abfd -> iostream)),
 342                             bfd_get_filename (abfd),
 343                             offset, mainline,
 344                             ei.dboffset, ei.dbsize,
 345                             ei.lnoffset, ei.lnsize, objfile);
 346     }
 347   if (ei.stabsect)
 348     {
 349       /* STABS sections */
 350
 351       /* FIXME:  Sun didn't really know how to implement this well.
 352          They made .stab sections that don't point to the .stabstr
 353          section with the sh_link field.  BFD doesn't make string table
 354          sections visible to the caller.  So we have to search the
 355          ELF section table, not the BFD section table, for the string
 356          table.  */
 357       Elf_Internal_Shdr *elf_sect = bfd_elf_find_section (abfd, ".stabstr");
 358
 359       if (elf_sect)
 360         elfstab_build_psymtabs (objfile,
 361           addr, /* We really pass the text seg addr, not the offset, here. */
 362           mainline,
 363           ei.stabsect->filepos,                         /* .stab offset */
 364           bfd_get_section_size_before_reloc (ei.stabsect),/* .stab size */
 365           elf_sect->sh_offset,                          /* .stabstr offset */
 366           elf_sect->sh_size);                           /* .stabstr size */
 367     }
 368
 369   if (!have_partial_symbols ())
 370     {
 371       wrap_here ("");
 372       printf_filtered ("(no debugging symbols found)...");
 373       wrap_here ("");
 374     }
 375
 376   /* Install any minimal symbols that have been collected as the current
 377      minimal symbols for this objfile. */
 378
 379   install_minimal_symbols (objfile);
 380
 381   do_cleanups (back_to);
 382 }
 383
 384 /* Initialize anything that needs initializing when a completely new symbol
 385    file is specified (not just adding some symbols from another file, e.g. a
 386    shared library).
 387
 388    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
 389
 390 static void
 391 elf_new_init (ignore)
 392      struct objfile *ignore;
 393 {
 394   buildsym_new_init ();
 395 }
 396
 397 /* Perform any local cleanups required when we are done with a particular
 398    objfile.  I.E, we are in the process of discarding all symbol information
 399    for an objfile, freeing up all memory held for it, and unlinking the
 400    objfile struct from the global list of known objfiles. */
 401
 402 static void
 403 elf_symfile_finish (objfile)
 404      struct objfile *objfile;
 405 {
 406   if (objfile -> sym_private != NULL)
 407     {
 408       mfree (objfile -> md, objfile -> sym_private);
 409     }
 410 }
 411
 412 /* ELF specific initialization routine for reading symbols.
 413
 414    It is passed a pointer to a struct sym_fns which contains, among other
 415    things, the BFD for the file whose symbols are being read, and a slot for
 416    a pointer to "private data" which we can fill with goodies.
 417
 418    For now at least, we have nothing in particular to do, so this function is
 419    just a stub. */
 420
 421 static void
 422 elf_symfile_init (ignore)
 423      struct objfile *ignore;
 424 {
 425 }
 426
 427 \f
 428 /*  Register that we are able to handle ELF object file formats and DWARF
 429     debugging formats.
 430
 431     Unlike other object file formats, where the debugging information format
 432     is implied by the object file format, the ELF object file format and the
 433     DWARF debugging information format are two distinct, and potentially
 434     separate entities.  I.E. it is perfectly possible to have ELF objects
 435     with debugging formats other than DWARF.  And it is conceivable that the
 436     DWARF debugging format might be used with another object file format,
 437     like COFF, by simply using COFF's custom section feature.
 438
 439     GDB, and to a lesser extent BFD, should support the notion of separate
 440     object file formats and debugging information formats.  For now, we just
 441     use "elf" in the same sense as "a.out" or "coff", to imply both the ELF
 442     object file format and the DWARF debugging format. */
 443
 444 static struct sym_fns elf_sym_fns =
 445 {
 446   "elf",                /* sym_name: name or name prefix of BFD target type */
 447   3,                    /* sym_namelen: number of significant sym_name chars */
 448   elf_new_init,         /* sym_new_init: init anything gbl to entire symtab */
 449   elf_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
 450   elf_symfile_read,     /* sym_read: read a symbol file into symtab */
 451   elf_symfile_finish,   /* sym_finish: finished with file, cleanup */
 452   NULL                  /* next: pointer to next struct sym_fns */
 453 };
 454
 455 void
 456 _initialize_elfread ()
 457 {
 458   add_symtab_fns (&elf_sym_fns);
 459 }