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