gdb/paread.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 <time.h> /* For time_t in libbfd.h.  */
  24 #include <sys/types.h> /* For time_t, if not in time.h.  */
  25 #include "libbfd.h"
  26 #include "som.h"
  27 #include "libhppa.h"
  28 #include <syms.h>
  29 #include "symtab.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "buildsym.h"
  33 #include "stabsread.h"
  34 #include "gdb-stabs.h"
  35 #include "complaints.h"
  36 #include <string.h>
  37 #include "demangle.h"
  38 #include <sys/file.h>
  39
  40 /* Size of n_value and n_strx fields in a stab symbol.  */
  41 #define BYTES_IN_WORD 4
  42
  43 #include "aout/aout64.h"
  44
  45 /* Various things we might complain about... */
  46
  47 static void
  48 pa_symfile_init PARAMS ((struct objfile *));
  49
  50 static void
  51 pa_new_init PARAMS ((struct objfile *));
  52
  53 static void
  54 read_unwind_info PARAMS ((struct objfile *));
  55
  56 static void
  57 pa_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  58
  59 static void
  60 pa_symfile_finish PARAMS ((struct objfile *));
  61
  62 static void
  63 pa_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *));
  64
  65 static void
  66 free_painfo PARAMS ((PTR));
  67
  68 static struct section_offsets *
  69 pa_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
  70
  71 static void
  72 record_minimal_symbol PARAMS ((char *, CORE_ADDR,
  73                                enum minimal_symbol_type,
  74                                struct objfile *));
  75
  76 static void
  77 record_minimal_symbol (name, address, ms_type, objfile)
  78      char *name;
  79      CORE_ADDR address;
  80      enum minimal_symbol_type ms_type;
  81      struct objfile *objfile;
  82 {
  83   name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
  84   prim_record_minimal_symbol (name, address, ms_type);
  85 }
  86
  87 /*
  88
  89 LOCAL FUNCTION
  90
  91         pa_symtab_read -- read the symbol table of a PA file
  92
  93 SYNOPSIS
  94
  95         void pa_symtab_read (bfd *abfd, CORE_ADDR addr,
  96                               struct objfile *objfile)
  97
  98 DESCRIPTION
  99
 100         Given an open bfd, a base address to relocate symbols to, and a
 101         flag that specifies whether or not this bfd is for an executable
 102         or not (may be shared library for example), add all the global
 103         function and data symbols to the minimal symbol table.
 104 */
 105
 106 static void
 107 pa_symtab_read (abfd, addr, objfile)
 108      bfd *abfd;
 109      CORE_ADDR addr;
 110      struct objfile *objfile;
 111 {
 112   unsigned int number_of_symbols;
 113   unsigned int i;
 114   int val;
 115   char *stringtab;
 116   struct symbol_dictionary_record *buf, *bufp, *endbufp;
 117   char *symname;
 118   CONST int symsize = sizeof (struct symbol_dictionary_record);
 119
 120   number_of_symbols = bfd_get_symcount (abfd);
 121
 122   buf = alloca (symsize * number_of_symbols);
 123   bfd_seek (abfd, obj_som_sym_filepos (abfd), L_SET);
 124   val = bfd_read (buf, symsize * number_of_symbols, 1, abfd);
 125   if (val != symsize * number_of_symbols)
 126     error ("Couldn't read symbol dictionary!");
 127
 128   stringtab = alloca (obj_som_stringtab_size (abfd));
 129   bfd_seek (abfd, obj_som_str_filepos (abfd), L_SET);
 130   val = bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd);
 131   if (val != obj_som_stringtab_size (abfd))
 132     error ("Can't read in HP string table.");
 133
 134   endbufp = buf + number_of_symbols;
 135   for (bufp = buf; bufp < endbufp; ++bufp)
 136     {
 137       enum minimal_symbol_type ms_type;
 138
 139       QUIT;
 140
 141       switch (bufp->symbol_scope)
 142         {
 143         case SS_UNIVERSAL:
 144           switch (bufp->symbol_type)
 145             {
 146             case ST_SYM_EXT:
 147             case ST_ARG_EXT:
 148               continue;
 149
 150             case ST_CODE:
 151             case ST_PRI_PROG:
 152             case ST_SEC_PROG:
 153             case ST_ENTRY:
 154             case ST_MILLICODE:
 155               symname = bufp->name.n_strx + stringtab;
 156               ms_type = mst_text;
 157               bufp->symbol_value &= ~0x3; /* clear out permission bits */
 158               break;
 159             case ST_DATA:
 160               symname = bufp->name.n_strx + stringtab;
 161               ms_type = mst_data;
 162               break;
 163             default:
 164               continue;
 165             }
 166           break;
 167
 168 #if 0
 169           /* SS_GLOBAL and SS_LOCAL are two names for the same thing (!).  */
 170         case SS_GLOBAL:
 171 #endif
 172         case SS_LOCAL:
 173           switch (bufp->symbol_type)
 174             {
 175             case ST_SYM_EXT:
 176             case ST_ARG_EXT:
 177               continue;
 178
 179             case ST_CODE:
 180               symname = bufp->name.n_strx + stringtab;
 181               ms_type = mst_file_text;
 182               bufp->symbol_value &= ~0x3; /* clear out permission bits */
 183
 184             check_strange_names:
 185               /* GAS leaves symbols with the prefixes "LS$", "LBB$",
 186                  and "LBE$" in .o files after assembling.  And thus
 187                  they appear in the final executable.  This can
 188                  cause problems if these special symbols have the
 189                  same value as real symbols.  So ignore them.  Also "LC$".  */
 190               if (*symname == 'L'
 191                   && (symname[1] == '$' || symname[2] == '$'
 192                       || symname[3] == '$'))
 193                 continue;
 194               break;
 195
 196             case ST_PRI_PROG:
 197             case ST_SEC_PROG:
 198             case ST_ENTRY:
 199             case ST_MILLICODE:
 200               symname = bufp->name.n_strx + stringtab;
 201               ms_type = mst_file_text;
 202               bufp->symbol_value &= ~0x3; /* clear out permission bits */
 203               break;
 204
 205             case ST_DATA:
 206               symname = bufp->name.n_strx + stringtab;
 207               ms_type = mst_file_data;
 208               goto check_strange_names;
 209
 210             default:
 211               continue;
 212             }
 213           break;
 214
 215         default:
 216           continue;
 217         }
 218
 219       if (bufp->name.n_strx > obj_som_stringtab_size (abfd))
 220         error ("Invalid symbol data; bad HP string table offset: %d",
 221                bufp->name.n_strx);
 222
 223       record_minimal_symbol (symname,
 224                              bufp->symbol_value, ms_type,
 225                              objfile);
 226     }
 227
 228   install_minimal_symbols (objfile);
 229 }
 230
 231 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
 232    the object file.  This info is used mainly by find_unwind_entry() to find
 233    out the stack frame size and frame pointer used by procedures.  We put
 234    everything on the psymbol obstack in the objfile so that it automatically
 235    gets freed when the objfile is destroyed.  */
 236
 237 static void
 238 read_unwind_info (objfile)
 239      struct objfile *objfile;
 240 {
 241   asection *unwind_sec;
 242   struct obj_unwind_info *ui;
 243
 244   ui = obstack_alloc (&objfile->psymbol_obstack,
 245                       sizeof (struct obj_unwind_info));
 246
 247   ui->table = NULL;
 248   ui->cache = NULL;
 249   ui->last = -1;
 250
 251   unwind_sec = bfd_get_section_by_name (objfile->obfd,
 252                                         "$UNWIND_START$");
 253   if (unwind_sec)
 254     {
 255       int size;
 256       int i, *ip;
 257
 258       size = bfd_section_size (objfile->obfd, unwind_sec);
 259       ui->table = obstack_alloc (&objfile->psymbol_obstack, size);
 260       ui->last = size / sizeof (struct unwind_table_entry) - 1;
 261
 262       bfd_get_section_contents (objfile->obfd, unwind_sec, ui->table,
 263                                 0, size);
 264
 265       OBJ_UNWIND_INFO (objfile) = ui;
 266     }
 267 }
 268
 269 /* Scan and build partial symbols for a symbol file.
 270    We have been initialized by a call to pa_symfile_init, which
 271    currently does nothing.
 272
 273    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 274    in each section.  This is ignored, as it isn't needed for the PA.
 275
 276    MAINLINE is true if we are reading the main symbol
 277    table (as opposed to a shared lib or dynamically loaded file).
 278
 279    This function only does the minimum work necessary for letting the
 280    user "name" things symbolically; it does not read the entire symtab.
 281    Instead, it reads the external and static symbols and puts them in partial
 282    symbol tables.  When more extensive information is requested of a
 283    file, the corresponding partial symbol table is mutated into a full
 284    fledged symbol table by going back and reading the symbols
 285    for real.
 286
 287    We look for sections with specific names, to tell us what debug
 288    format to look for:  FIXME!!!
 289
 290    pastab_build_psymtabs() handles STABS symbols.
 291
 292    Note that PA files have a "minimal" symbol table, which is vaguely
 293    reminiscent of a COFF symbol table, but has only the minimal information
 294    necessary for linking.  We process this also, and use the information to
 295    build gdb's minimal symbol table.  This gives us some minimal debugging
 296    capability even for files compiled without -g.  */
 297
 298 static void
 299 pa_symfile_read (objfile, section_offsets, mainline)
 300      struct objfile *objfile;
 301      struct section_offsets *section_offsets;
 302      int mainline;
 303 {
 304   bfd *abfd = objfile->obfd;
 305   struct cleanup *back_to;
 306   CORE_ADDR offset;
 307
 308   init_minimal_symbol_collection ();
 309   back_to = make_cleanup (discard_minimal_symbols, 0);
 310
 311   make_cleanup (free_painfo, (PTR) objfile);
 312
 313   /* Process the normal PA symbol table first. */
 314
 315   /* FIXME, should take a section_offsets param, not just an offset.  */
 316
 317   offset = ANOFFSET (section_offsets, 0);
 318   pa_symtab_read (abfd, offset, objfile);
 319
 320   /* Now process debugging information, which is contained in
 321      special PA sections.  */
 322
 323   pastab_build_psymtabs (objfile, section_offsets, mainline);
 324
 325   read_unwind_info(objfile);
 326
 327   do_cleanups (back_to);
 328 }
 329
 330 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 331    stab_section_info's, that might be dangling from it.  */
 332
 333 static void
 334 free_painfo (objp)
 335      PTR objp;
 336 {
 337   struct objfile *objfile = (struct objfile *)objp;
 338   struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
 339                                      objfile->sym_stab_info;
 340   struct stab_section_info *ssi, *nssi;
 341
 342   ssi = dbxinfo->stab_section_info;
 343   while (ssi)
 344     {
 345       nssi = ssi->next;
 346       mfree (objfile->md, ssi);
 347       ssi = nssi;
 348     }
 349
 350   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 351 }
 352
 353 /* Initialize anything that needs initializing when a completely new symbol
 354    file is specified (not just adding some symbols from another file, e.g. a
 355    shared library).
 356
 357    We reinitialize buildsym, since we may be reading stabs from a PA file.  */
 358
 359 static void
 360 pa_new_init (ignore)
 361      struct objfile *ignore;
 362 {
 363   stabsread_new_init ();
 364   buildsym_new_init ();
 365 }
 366
 367 /* Perform any local cleanups required when we are done with a particular
 368    objfile.  I.E, we are in the process of discarding all symbol information
 369    for an objfile, freeing up all memory held for it, and unlinking the
 370    objfile struct from the global list of known objfiles. */
 371
 372 static void
 373 pa_symfile_finish (objfile)
 374      struct objfile *objfile;
 375 {
 376   if (objfile -> sym_stab_info != NULL)
 377     {
 378       mfree (objfile -> md, objfile -> sym_stab_info);
 379     }
 380 }
 381
 382 /* PA specific initialization routine for reading symbols.
 383
 384    It is passed a pointer to a struct sym_fns which contains, among other
 385    things, the BFD for the file whose symbols are being read, and a slot for
 386    a pointer to "private data" which we can fill with goodies.
 387
 388    This routine is almost a complete ripoff of dbx_symfile_init.  The
 389    common parts of these routines should be extracted and used instead of
 390    duplicating this code.  FIXME. */
 391
 392 static void
 393 pa_symfile_init (objfile)
 394      struct objfile *objfile;
 395 {
 396   int val;
 397   bfd *sym_bfd = objfile->obfd;
 398   char *name = bfd_get_filename (sym_bfd);
 399   asection *stabsect;           /* Section containing symbol table entries */
 400   asection *stringsect;         /* Section containing symbol name strings */
 401
 402   stabsect = bfd_get_section_by_name (sym_bfd, "$GDB_SYMBOLS$");
 403   stringsect = bfd_get_section_by_name (sym_bfd, "$GDB_STRINGS$");
 404
 405   /* Allocate struct to keep track of the symfile */
 406   objfile->sym_stab_info = (PTR)
 407     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
 408
 409   memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 410
 411   if (!stabsect)
 412     return;
 413
 414   if (!stringsect)
 415     error ("Found stabs, but not string section");
 416
 417   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 418 #define STRING_TABLE_OFFSET     (stringsect->filepos)
 419 #define SYMBOL_TABLE_OFFSET     (stabsect->filepos)
 420
 421   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 422
 423   DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
 424   DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
 425   if (!DBX_TEXT_SECT (objfile))
 426     error ("Can't find .text section in symbol file");
 427
 428   /* FIXME: I suspect this should be external_nlist.  The size of host
 429      types like long and bfd_vma should not affect how we read the
 430      file.  */
 431   DBX_SYMBOL_SIZE (objfile) = sizeof (struct internal_nlist);
 432   DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
 433     / DBX_SYMBOL_SIZE (objfile);
 434   DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
 435
 436   /* Read the string table and stash it away in the psymbol_obstack.  It is
 437      only needed as long as we need to expand psymbols into full symbols,
 438      so when we blow away the psymbol the string table goes away as well.
 439      Note that gdb used to use the results of attempting to malloc the
 440      string table, based on the size it read, as a form of sanity check
 441      for botched byte swapping, on the theory that a byte swapped string
 442      table size would be so totally bogus that the malloc would fail.  Now
 443      that we put in on the psymbol_obstack, we can't do this since gdb gets
 444      a fatal error (out of virtual memory) if the size is bogus.  We can
 445      however at least check to see if the size is zero or some negative
 446      value. */
 447
 448   DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stringsect);
 449
 450   if (DBX_SYMCOUNT (objfile) == 0
 451       || DBX_STRINGTAB_SIZE (objfile) == 0)
 452     return;
 453
 454   if (DBX_STRINGTAB_SIZE (objfile) <= 0
 455       || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
 456     error ("ridiculous string table size (%d bytes).",
 457            DBX_STRINGTAB_SIZE (objfile));
 458
 459   DBX_STRINGTAB (objfile) =
 460     (char *) obstack_alloc (&objfile -> psymbol_obstack,
 461                             DBX_STRINGTAB_SIZE (objfile));
 462
 463   /* Now read in the string table in one big gulp.  */
 464
 465   val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
 466   if (val < 0)
 467     perror_with_name (name);
 468   val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
 469                   sym_bfd);
 470   if (val == 0)
 471     error ("End of file reading string table");
 472   else if (val < 0)
 473     /* It's possible bfd_read should be setting bfd_error, and we should be
 474        checking that.  But currently it doesn't set bfd_error.  */
 475     perror_with_name (name);
 476   else if (val != DBX_STRINGTAB_SIZE (objfile))
 477     error ("Short read reading string table");
 478 }
 479
 480 /* PA specific parsing routine for section offsets.
 481
 482    Plain and simple for now.  */
 483
 484 static struct section_offsets *
 485 pa_symfile_offsets (objfile, addr)
 486      struct objfile *objfile;
 487      CORE_ADDR addr;
 488 {
 489   struct section_offsets *section_offsets;
 490   int i;
 491
 492   objfile->num_sections = SECT_OFF_MAX;
 493   section_offsets = (struct section_offsets *)
 494     obstack_alloc (&objfile -> psymbol_obstack,
 495                    sizeof (struct section_offsets)
 496                    + sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 497
 498   for (i = 0; i < SECT_OFF_MAX; i++)
 499     ANOFFSET (section_offsets, i) = addr;
 500
 501   return section_offsets;
 502 }
 503 \f
 504 /* Register that we are able to handle SOM object file formats.  */
 505
 506 static struct sym_fns pa_sym_fns =
 507 {
 508   bfd_target_som_flavour,
 509   pa_new_init,          /* sym_new_init: init anything gbl to entire symtab */
 510   pa_symfile_init,      /* sym_init: read initial info, setup for sym_read() */
 511   pa_symfile_read,      /* sym_read: read a symbol file into symtab */
 512   pa_symfile_finish,    /* sym_finish: finished with file, cleanup */
 513   pa_symfile_offsets,   /* sym_offsets:  Translate ext. to int. relocation */
 514   NULL                  /* next: pointer to next struct sym_fns */
 515 };
 516
 517 void
 518 _initialize_paread ()
 519 {
 520   add_symtab_fns (&pa_sym_fns);
 521 }