gdb/somread.c

   1 /* Read HP PA/Risc 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 #include "defs.h"
  22 #include "bfd.h"
  23 #include "som.h"
  24 #include "libhppa.h"
  25 #include <syms.h>
  26 #include "symtab.h"
  27 #include "symfile.h"
  28 #include "objfiles.h"
  29 #include "buildsym.h"
  30 #include "stabsread.h"
  31 #include "gdb-stabs.h"
  32 #include "complaints.h"
  33 #include <string.h>
  34 #include "demangle.h"
  35 #include <sys/file.h>
  36
  37 /* Various things we might complain about... */
  38
  39 static void
  40 som_symfile_init PARAMS ((struct objfile *));
  41
  42 static void
  43 som_new_init PARAMS ((struct objfile *));
  44
  45 static void
  46 som_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  47
  48 static void
  49 som_symfile_finish PARAMS ((struct objfile *));
  50
  51 static void
  52 som_symtab_read PARAMS ((bfd *, struct objfile *,
  53                          struct section_offsets *));
  54
  55 static struct section_offsets *
  56 som_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
  57
  58 static void
  59 record_minimal_symbol PARAMS ((char *, CORE_ADDR,
  60                                enum minimal_symbol_type,
  61                                struct objfile *));
  62
  63 static void
  64 record_minimal_symbol (name, address, ms_type, objfile)
  65      char *name;
  66      CORE_ADDR address;
  67      enum minimal_symbol_type ms_type;
  68      struct objfile *objfile;
  69 {
  70   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
  71   prim_record_minimal_symbol (name, address, ms_type, objfile);
  72 }
  73
  74 /*
  75
  76 LOCAL FUNCTION
  77
  78         som_symtab_read -- read the symbol table of a SOM file
  79
  80 SYNOPSIS
  81
  82         void som_symtab_read (bfd *abfd, struct objfile *objfile,
  83                               struct section_offsets *section_offsets)
  84
  85 DESCRIPTION
  86
  87         Given an open bfd, a base address to relocate symbols to, and a
  88         flag that specifies whether or not this bfd is for an executable
  89         or not (may be shared library for example), add all the global
  90         function and data symbols to the minimal symbol table.
  91 */
  92
  93 static void
  94 som_symtab_read (abfd, objfile, section_offsets)
  95      bfd *abfd;
  96      struct objfile *objfile;
  97      struct section_offsets *section_offsets;
  98 {
  99   unsigned int number_of_symbols;
 100   int val, dynamic;
 101   char *stringtab;
 102   asection *shlib_info;
 103   struct symbol_dictionary_record *buf, *bufp, *endbufp;
 104   char *symname;
 105   CONST int symsize = sizeof (struct symbol_dictionary_record);
 106   CORE_ADDR text_offset, data_offset;
 107
 108
 109   text_offset = ANOFFSET (section_offsets, 0);
 110   data_offset = ANOFFSET (section_offsets, 1);
 111
 112   number_of_symbols = bfd_get_symcount (abfd);
 113
 114   buf = alloca (symsize * number_of_symbols);
 115   bfd_seek (abfd, obj_som_sym_filepos (abfd), L_SET);
 116   val = bfd_read (buf, symsize * number_of_symbols, 1, abfd);
 117   if (val != symsize * number_of_symbols)
 118     error ("Couldn't read symbol dictionary!");
 119
 120   stringtab = alloca (obj_som_stringtab_size (abfd));
 121   bfd_seek (abfd, obj_som_str_filepos (abfd), L_SET);
 122   val = bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd);
 123   if (val != obj_som_stringtab_size (abfd))
 124     error ("Can't read in HP string table.");
 125
 126   /* We need to determine if objfile is a dynamic executable (so we
 127      can do the right thing for ST_ENTRY vs ST_CODE symbols).
 128
 129      There's nothing in the header which easily allows us to do
 130      this.  The only reliable way I know of is to check for the
 131      existance of a $SHLIB_INFO$ section with a non-zero size.  */
 132   shlib_info = bfd_get_section_by_name (objfile->obfd, "$SHLIB_INFO$");
 133   if (shlib_info)
 134     dynamic = (bfd_section_size (objfile->obfd, shlib_info) != 0);
 135   else
 136     dynamic = 0;
 137
 138   endbufp = buf + number_of_symbols;
 139   for (bufp = buf; bufp < endbufp; ++bufp)
 140     {
 141       enum minimal_symbol_type ms_type;
 142
 143       QUIT;
 144
 145       switch (bufp->symbol_scope)
 146         {
 147         case SS_UNIVERSAL:
 148         case SS_EXTERNAL:
 149           switch (bufp->symbol_type)
 150             {
 151             case ST_SYM_EXT:
 152             case ST_ARG_EXT:
 153               continue;
 154
 155             case ST_CODE:
 156             case ST_PRI_PROG:
 157             case ST_SEC_PROG:
 158             case ST_MILLICODE:
 159               symname = bufp->name.n_strx + stringtab;
 160               ms_type = mst_text;
 161               bufp->symbol_value += text_offset;
 162 #ifdef SMASH_TEXT_ADDRESS
 163               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 164 #endif
 165               break;
 166
 167             case ST_ENTRY:
 168               symname = bufp->name.n_strx + stringtab;
 169               /* For a dynamic executable, ST_ENTRY symbols are
 170                  the stubs, while the ST_CODE symbol is the real
 171                  function.  */
 172               if (dynamic)
 173                 ms_type = mst_solib_trampoline;
 174               else
 175                 ms_type = mst_text;
 176               bufp->symbol_value += text_offset;
 177 #ifdef SMASH_TEXT_ADDRESS
 178               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 179 #endif
 180               break;
 181
 182             case ST_STUB:
 183               symname = bufp->name.n_strx + stringtab;
 184               ms_type = mst_solib_trampoline;
 185               bufp->symbol_value += text_offset;
 186 #ifdef SMASH_TEXT_ADDRESS
 187               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 188 #endif
 189               break;
 190
 191             case ST_DATA:
 192               symname = bufp->name.n_strx + stringtab;
 193               bufp->symbol_value += data_offset;
 194               ms_type = mst_data;
 195               break;
 196             default:
 197               continue;
 198             }
 199           break;
 200
 201 #if 0
 202           /* SS_GLOBAL and SS_LOCAL are two names for the same thing (!).  */
 203         case SS_GLOBAL:
 204 #endif
 205         case SS_LOCAL:
 206           switch (bufp->symbol_type)
 207             {
 208             case ST_SYM_EXT:
 209             case ST_ARG_EXT:
 210               continue;
 211
 212             case ST_CODE:
 213               symname = bufp->name.n_strx + stringtab;
 214               ms_type = mst_file_text;
 215               bufp->symbol_value += text_offset;
 216 #ifdef SMASH_TEXT_ADDRESS
 217               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 218 #endif
 219
 220             check_strange_names:
 221               /* Utah GCC 2.5, FSF GCC 2.6 and later generate correct local
 222                  label prefixes for stabs, constant data, etc.  So we need
 223                  only filter out L$ symbols which are left in due to
 224                  limitations in how GAS generates SOM relocations.
 225
 226                  When linking in the HPUX C-library the HP linker has
 227                  the nasty habit of placing section symbols from the literal
 228                  subspaces in the middle of the program's text.  Filter
 229                  those out as best we can.  Check for first and last character
 230                  being '$'.
 231
 232                  And finally, the newer HP compilers emit crud like $PIC_foo$N
 233                  in some circumstance (PIC code I guess).  It's also claimed
 234                  that they emit D$ symbols too.  What stupidity.  */
 235               if ((symname[0] == 'L' && symname[1] == '$')
 236                   || (symname[0] == '$' && symname[strlen(symname) - 1] == '$')
 237                   || (symname[0] == 'D' && symname[1] == '$')
 238                   || (strncmp (symname, "$PIC", 4) == 0))
 239                 continue;
 240               break;
 241
 242             case ST_PRI_PROG:
 243             case ST_SEC_PROG:
 244             case ST_MILLICODE:
 245               symname = bufp->name.n_strx + stringtab;
 246               ms_type = mst_file_text;
 247               bufp->symbol_value += text_offset;
 248 #ifdef SMASH_TEXT_ADDRESS
 249               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 250 #endif
 251               break;
 252
 253             case ST_ENTRY:
 254               symname = bufp->name.n_strx + stringtab;
 255               /* For a dynamic executable, ST_ENTRY symbols are
 256                  the stubs, while the ST_CODE symbol is the real
 257                  function.  */
 258               if (dynamic)
 259                 ms_type = mst_solib_trampoline;
 260               else
 261                 ms_type = mst_file_text;
 262               bufp->symbol_value += text_offset;
 263 #ifdef SMASH_TEXT_ADDRESS
 264               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 265 #endif
 266               break;
 267
 268             case ST_STUB:
 269               symname = bufp->name.n_strx + stringtab;
 270               ms_type = mst_solib_trampoline;
 271               bufp->symbol_value += text_offset;
 272 #ifdef SMASH_TEXT_ADDRESS
 273               SMASH_TEXT_ADDRESS (bufp->symbol_value);
 274 #endif
 275               break;
 276
 277
 278             case ST_DATA:
 279               symname = bufp->name.n_strx + stringtab;
 280               bufp->symbol_value += data_offset;
 281               ms_type = mst_file_data;
 282               goto check_strange_names;
 283
 284             default:
 285               continue;
 286             }
 287           break;
 288
 289         default:
 290           continue;
 291         }
 292
 293       if (bufp->name.n_strx > obj_som_stringtab_size (abfd))
 294         error ("Invalid symbol data; bad HP string table offset: %d",
 295                bufp->name.n_strx);
 296
 297       record_minimal_symbol (symname,
 298                              bufp->symbol_value, ms_type,
 299                              objfile);
 300     }
 301 }
 302
 303 /* Scan and build partial symbols for a symbol file.
 304    We have been initialized by a call to som_symfile_init, which
 305    currently does nothing.
 306
 307    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 308    in each section.  This is ignored, as it isn't needed for SOM.
 309
 310    MAINLINE is true if we are reading the main symbol
 311    table (as opposed to a shared lib or dynamically loaded file).
 312
 313    This function only does the minimum work necessary for letting the
 314    user "name" things symbolically; it does not read the entire symtab.
 315    Instead, it reads the external and static symbols and puts them in partial
 316    symbol tables.  When more extensive information is requested of a
 317    file, the corresponding partial symbol table is mutated into a full
 318    fledged symbol table by going back and reading the symbols
 319    for real.
 320
 321    We look for sections with specific names, to tell us what debug
 322    format to look for:  FIXME!!!
 323
 324    somstab_build_psymtabs() handles STABS symbols.
 325
 326    Note that SOM files have a "minimal" symbol table, which is vaguely
 327    reminiscent of a COFF symbol table, but has only the minimal information
 328    necessary for linking.  We process this also, and use the information to
 329    build gdb's minimal symbol table.  This gives us some minimal debugging
 330    capability even for files compiled without -g.  */
 331
 332 static void
 333 som_symfile_read (objfile, section_offsets, mainline)
 334      struct objfile *objfile;
 335      struct section_offsets *section_offsets;
 336      int mainline;
 337 {
 338   bfd *abfd = objfile->obfd;
 339   struct cleanup *back_to;
 340
 341   init_minimal_symbol_collection ();
 342   back_to = make_cleanup (discard_minimal_symbols, 0);
 343
 344   /* Process the normal SOM symbol table first. */
 345
 346   som_symtab_read (abfd, objfile, section_offsets);
 347
 348   /* Now read information from the stabs debug sections.  */
 349   stabsect_build_psymtabs (objfile, section_offsets, mainline,
 350                            "$GDB_SYMBOLS$", "$GDB_STRINGS$", "$TEXT$");
 351
 352   /* Now read the native debug information.  */
 353   hpread_build_psymtabs (objfile, section_offsets, mainline);
 354
 355   /* Install any minimal symbols that have been collected as the current
 356      minimal symbols for this objfile.  */
 357   install_minimal_symbols (objfile);
 358
 359   /* Force hppa-tdep.c to re-read the unwind descriptors.  */
 360   objfile->obj_private = NULL;
 361   do_cleanups (back_to);
 362 }
 363
 364 /* Initialize anything that needs initializing when a completely new symbol
 365    file is specified (not just adding some symbols from another file, e.g. a
 366    shared library).
 367
 368    We reinitialize buildsym, since we may be reading stabs from a SOM file.  */
 369
 370 static void
 371 som_new_init (ignore)
 372      struct objfile *ignore;
 373 {
 374   stabsread_new_init ();
 375   buildsym_new_init ();
 376 }
 377
 378 /* Perform any local cleanups required when we are done with a particular
 379    objfile.  I.E, we are in the process of discarding all symbol information
 380    for an objfile, freeing up all memory held for it, and unlinking the
 381    objfile struct from the global list of known objfiles. */
 382
 383 static void
 384 som_symfile_finish (objfile)
 385      struct objfile *objfile;
 386 {
 387   if (objfile -> sym_stab_info != NULL)
 388     {
 389       mfree (objfile -> md, objfile -> sym_stab_info);
 390     }
 391   hpread_symfile_finish (objfile);
 392 }
 393
 394 /* SOM specific initialization routine for reading symbols.
 395
 396    Nothing SOM specific left to do anymore.  */
 397 static void
 398 som_symfile_init (objfile)
 399      struct objfile *objfile;
 400 {
 401   hpread_symfile_init (objfile);
 402 }
 403
 404 /* SOM specific parsing routine for section offsets.
 405
 406    Plain and simple for now.  */
 407
 408 static struct section_offsets *
 409 som_symfile_offsets (objfile, addr)
 410      struct objfile *objfile;
 411      CORE_ADDR addr;
 412 {
 413   struct section_offsets *section_offsets;
 414   int i;
 415
 416   objfile->num_sections = SECT_OFF_MAX;
 417   section_offsets = (struct section_offsets *)
 418     obstack_alloc (&objfile -> psymbol_obstack,
 419                    sizeof (struct section_offsets)
 420                    + sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 421
 422   /* First see if we're a shared library.  If so, get the section
 423      offsets from the library, else get them from addr.  */
 424   if (!som_solib_section_offsets (objfile, section_offsets))
 425     {
 426       for (i = 0; i < SECT_OFF_MAX; i++)
 427         ANOFFSET (section_offsets, i) = addr;
 428     }
 429
 430   return section_offsets;
 431 }
 432 \f
 433 /* Register that we are able to handle SOM object file formats.  */
 434
 435 static struct sym_fns som_sym_fns =
 436 {
 437   bfd_target_som_flavour,
 438   som_new_init,         /* sym_new_init: init anything gbl to entire symtab */
 439   som_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
 440   som_symfile_read,     /* sym_read: read a symbol file into symtab */
 441   som_symfile_finish,   /* sym_finish: finished with file, cleanup */
 442   som_symfile_offsets,  /* sym_offsets:  Translate ext. to int. relocation */
 443   NULL                  /* next: pointer to next struct sym_fns */
 444 };
 445
 446 void
 447 _initialize_somread ()
 448 {
 449   add_symtab_fns (&som_sym_fns);
 450 }