gdb/nlmread.c

   1 /* Read NLM (NetWare Loadable Module) format executable files for GDB.
   2    Copyright 1993, 1994 Free Software Foundation, Inc.
   3    Written by Fred Fish at Cygnus Support ([email protected]).
   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 #include "defs.h"
  22 #include <string.h>
  23 #include "bfd.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "gdb-stabs.h"
  28 #include "buildsym.h"
  29 #include "stabsread.h"
  30
  31 static void
  32 nlm_new_init PARAMS ((struct objfile *));
  33
  34 static void
  35 nlm_symfile_init PARAMS ((struct objfile *));
  36
  37 static void
  38 nlm_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  39
  40 static void
  41 nlm_symfile_finish PARAMS ((struct objfile *));
  42
  43 static void
  44 nlm_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *));
  45
  46 static struct section_offsets *
  47 nlm_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
  48
  49 static void
  50 record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type,
  51                                struct objfile *));
  52
  53
  54 /* Initialize anything that needs initializing when a completely new symbol
  55    file is specified (not just adding some symbols from another file, e.g. a
  56    shared library).
  57
  58    We reinitialize buildsym, since gdb will be able to read stabs from an NLM
  59    file at some point in the near future.  */
  60
  61 static void
  62 nlm_new_init (ignore)
  63      struct objfile *ignore;
  64 {
  65   stabsread_new_init ();
  66   buildsym_new_init ();
  67 }
  68
  69
  70 /* NLM specific initialization routine for reading symbols.
  71
  72    It is passed a pointer to a struct sym_fns which contains, among other
  73    things, the BFD for the file whose symbols are being read, and a slot for
  74    a pointer to "private data" which we can fill with goodies.
  75
  76    For now at least, we have nothing in particular to do, so this function is
  77    just a stub. */
  78
  79 static void
  80 nlm_symfile_init (ignore)
  81      struct objfile *ignore;
  82 {
  83 }
  84
  85 static void
  86 record_minimal_symbol (name, address, ms_type, objfile)
  87      char *name;
  88      CORE_ADDR address;
  89      enum minimal_symbol_type ms_type;
  90      struct objfile *objfile;
  91 {
  92   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
  93   prim_record_minimal_symbol (name, address, ms_type, objfile);
  94 }
  95
  96
  97 /*
  98
  99 LOCAL FUNCTION
 100
 101         nlm_symtab_read -- read the symbol table of an NLM file
 102
 103 SYNOPSIS
 104
 105         void nlm_symtab_read (bfd *abfd, CORE_ADDR addr,
 106                               struct objfile *objfile)
 107
 108 DESCRIPTION
 109
 110         Given an open bfd, a base address to relocate symbols to, and a
 111         flag that specifies whether or not this bfd is for an executable
 112         or not (may be shared library for example), add all the global
 113         function and data symbols to the minimal symbol table.
 114 */
 115
 116 static void
 117 nlm_symtab_read (abfd, addr, objfile)
 118      bfd *abfd;
 119      CORE_ADDR addr;
 120      struct objfile *objfile;
 121 {
 122   long storage_needed;
 123   asymbol *sym;
 124   asymbol **symbol_table;
 125   long number_of_symbols;
 126   long i;
 127   struct cleanup *back_to;
 128   CORE_ADDR symaddr;
 129   enum minimal_symbol_type ms_type;
 130
 131   storage_needed = bfd_get_symtab_upper_bound (abfd);
 132   if (storage_needed < 0)
 133     error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
 134            bfd_errmsg (bfd_get_error ()));
 135   if (storage_needed > 0)
 136     {
 137       symbol_table = (asymbol **) xmalloc (storage_needed);
 138       back_to = make_cleanup (free, symbol_table);
 139       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 140       if (number_of_symbols < 0)
 141         error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
 142                bfd_errmsg (bfd_get_error ()));
 143
 144       for (i = 0; i < number_of_symbols; i++)
 145         {
 146           sym = symbol_table[i];
 147           if (/*sym -> flags & BSF_GLOBAL*/ 1)
 148             {
 149               /* Bfd symbols are section relative. */
 150               symaddr = sym -> value + sym -> section -> vma;
 151               /* Relocate all non-absolute symbols by base address.  */
 152               if (sym -> section != &bfd_abs_section)
 153                 {
 154                   symaddr += addr;
 155                 }
 156
 157               /* For non-absolute symbols, use the type of the section
 158                  they are relative to, to intuit text/data.  Bfd provides
 159                  no way of figuring this out for absolute symbols. */
 160               if (sym -> section -> flags & SEC_CODE)
 161                 {
 162                   ms_type = mst_text;
 163                 }
 164               else if (sym -> section -> flags & SEC_DATA)
 165                 {
 166                   ms_type = mst_data;
 167                 }
 168               else
 169                 {
 170                   ms_type = mst_unknown;
 171                 }
 172               record_minimal_symbol ((char *) sym -> name, symaddr, ms_type,
 173                                      objfile);
 174             }
 175         }
 176       do_cleanups (back_to);
 177     }
 178 }
 179
 180
 181 /* Scan and build partial symbols for a symbol file.
 182    We have been initialized by a call to nlm_symfile_init, which
 183    currently does nothing.
 184
 185    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 186    in each section.  We simplify it down to a single offset for all
 187    symbols.  FIXME.
 188
 189    MAINLINE is true if we are reading the main symbol
 190    table (as opposed to a shared lib or dynamically loaded file).
 191
 192    This function only does the minimum work necessary for letting the
 193    user "name" things symbolically; it does not read the entire symtab.
 194    Instead, it reads the external and static symbols and puts them in partial
 195    symbol tables.  When more extensive information is requested of a
 196    file, the corresponding partial symbol table is mutated into a full
 197    fledged symbol table by going back and reading the symbols
 198    for real.
 199
 200    Note that NLM files have two sets of information that is potentially
 201    useful for building gdb's minimal symbol table.  The first is a list
 202    of the publically exported symbols, and is currently used to build
 203    bfd's canonical symbol table.  The second is an optional native debugging
 204    format which contains additional symbols (and possibly duplicates of
 205    the publically exported symbols).  The optional native debugging format
 206    is not currently used. */
 207
 208 static void
 209 nlm_symfile_read (objfile, section_offsets, mainline)
 210      struct objfile *objfile;
 211      struct section_offsets *section_offsets;
 212      int mainline;
 213 {
 214   bfd *abfd = objfile -> obfd;
 215   struct cleanup *back_to;
 216   CORE_ADDR offset;
 217
 218   init_minimal_symbol_collection ();
 219   back_to = make_cleanup (discard_minimal_symbols, 0);
 220
 221   /* FIXME, should take a section_offsets param, not just an offset.  */
 222
 223   offset = ANOFFSET (section_offsets, 0);
 224
 225   /* Process the NLM export records, which become the bfd's canonical symbol
 226      table. */
 227
 228   nlm_symtab_read (abfd, offset, objfile);
 229
 230   stabsect_build_psymtabs (objfile, section_offsets, mainline, ".stab",
 231                            ".stabstr");
 232
 233   /* FIXME:  We could locate and read the optional native debugging format
 234      here and add the symbols to the minimal symbol table. */
 235
 236   if (!have_partial_symbols ())
 237     {
 238       wrap_here ("");
 239       printf_filtered ("(no debugging symbols found)...");
 240       wrap_here ("");
 241     }
 242
 243   /* Install any minimal symbols that have been collected as the current
 244      minimal symbols for this objfile. */
 245
 246   install_minimal_symbols (objfile);
 247
 248   do_cleanups (back_to);
 249 }
 250
 251
 252 /* Perform any local cleanups required when we are done with a particular
 253    objfile.  I.E, we are in the process of discarding all symbol information
 254    for an objfile, freeing up all memory held for it, and unlinking the
 255    objfile struct from the global list of known objfiles. */
 256
 257 static void
 258 nlm_symfile_finish (objfile)
 259      struct objfile *objfile;
 260 {
 261   if (objfile -> sym_private != NULL)
 262     {
 263       mfree (objfile -> md, objfile -> sym_private);
 264     }
 265 }
 266
 267 /* NLM specific parsing routine for section offsets.
 268    FIXME:  This may or may not be necessary.  All the symbol readers seem
 269    to have similar code.  See if it can be generalized and moved elsewhere. */
 270
 271 static
 272 struct section_offsets *
 273 nlm_symfile_offsets (objfile, addr)
 274      struct objfile *objfile;
 275      CORE_ADDR addr;
 276 {
 277   struct section_offsets *section_offsets;
 278   int i;
 279
 280   objfile->num_sections = SECT_OFF_MAX;
 281   section_offsets = (struct section_offsets *)
 282     obstack_alloc (&objfile -> psymbol_obstack,
 283                    sizeof (struct section_offsets) +
 284                    sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 285
 286   for (i = 0; i < SECT_OFF_MAX; i++)
 287     {
 288       ANOFFSET (section_offsets, i) = addr;
 289     }
 290
 291   return (section_offsets);
 292 }
 293
 294 \f
 295 /* Register that we are able to handle NLM file format. */
 296
 297 static struct sym_fns nlm_sym_fns =
 298 {
 299   bfd_target_nlm_flavour,
 300   nlm_new_init,         /* sym_new_init: init anything gbl to entire symtab */
 301   nlm_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
 302   nlm_symfile_read,     /* sym_read: read a symbol file into symtab */
 303   nlm_symfile_finish,   /* sym_finish: finished with file, cleanup */
 304   nlm_symfile_offsets,  /* sym_offsets:  Translate ext. to int. relocation */
 305   NULL                  /* next: pointer to next struct sym_fns */
 306 };
 307
 308 void
 309 _initialize_nlmread ()
 310 {
 311   add_symtab_fns (&nlm_sym_fns);
 312 }