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 labels in .o files after assembling.  At
 186                  least labels starting with "LS$", "LBB$", "LBE$",
 187                  "LC$", and "L$" can happen.  This should be fixed in
 188                  the assembler and/or compiler, to save space in the
 189                  executable (and because having GDB make gross
 190                  distinctions based on the name is kind of ugly), but
 191                  until then, just ignore them.  */
 192               if (*symname == 'L'
 193                   && (symname[1] == '$' || symname[2] == '$'
 194                       || symname[3] == '$'))
 195                 continue;
 196               break;
 197
 198             case ST_PRI_PROG:
 199             case ST_SEC_PROG:
 200             case ST_ENTRY:
 201             case ST_MILLICODE:
 202               symname = bufp->name.n_strx + stringtab;
 203               ms_type = mst_file_text;
 204               bufp->symbol_value &= ~0x3; /* clear out permission bits */
 205               break;
 206
 207             case ST_DATA:
 208               symname = bufp->name.n_strx + stringtab;
 209               ms_type = mst_file_data;
 210               goto check_strange_names;
 211
 212             default:
 213               continue;
 214             }
 215           break;
 216
 217         default:
 218           continue;
 219         }
 220
 221       if (bufp->name.n_strx > obj_som_stringtab_size (abfd))
 222         error ("Invalid symbol data; bad HP string table offset: %d",
 223                bufp->name.n_strx);
 224
 225       record_minimal_symbol (symname,
 226                              bufp->symbol_value, ms_type,
 227                              objfile);
 228     }
 229
 230   install_minimal_symbols (objfile);
 231 }
 232
 233 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
 234    the object file.  This info is used mainly by find_unwind_entry() to find
 235    out the stack frame size and frame pointer used by procedures.  We put
 236    everything on the psymbol obstack in the objfile so that it automatically
 237    gets freed when the objfile is destroyed.  */
 238
 239 static void
 240 read_unwind_info (objfile)
 241      struct objfile *objfile;
 242 {
 243   asection *unwind_sec;
 244   struct obj_unwind_info *ui;
 245
 246   ui = obstack_alloc (&objfile->psymbol_obstack,
 247                       sizeof (struct obj_unwind_info));
 248
 249   ui->table = NULL;
 250   ui->cache = NULL;
 251   ui->last = -1;
 252
 253   unwind_sec = bfd_get_section_by_name (objfile->obfd,
 254                                         "$UNWIND_START$");
 255   if (unwind_sec)
 256     {
 257       int size;
 258       int i, *ip;
 259
 260       size = bfd_section_size (objfile->obfd, unwind_sec);
 261       ui->table = obstack_alloc (&objfile->psymbol_obstack, size);
 262       ui->last = size / sizeof (struct unwind_table_entry) - 1;
 263
 264       bfd_get_section_contents (objfile->obfd, unwind_sec, ui->table,
 265                                 0, size);
 266
 267       OBJ_UNWIND_INFO (objfile) = ui;
 268     }
 269 }
 270
 271 /* Scan and build partial symbols for a symbol file.
 272    We have been initialized by a call to pa_symfile_init, which
 273    currently does nothing.
 274
 275    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
 276    in each section.  This is ignored, as it isn't needed for the PA.
 277
 278    MAINLINE is true if we are reading the main symbol
 279    table (as opposed to a shared lib or dynamically loaded file).
 280
 281    This function only does the minimum work necessary for letting the
 282    user "name" things symbolically; it does not read the entire symtab.
 283    Instead, it reads the external and static symbols and puts them in partial
 284    symbol tables.  When more extensive information is requested of a
 285    file, the corresponding partial symbol table is mutated into a full
 286    fledged symbol table by going back and reading the symbols
 287    for real.
 288
 289    We look for sections with specific names, to tell us what debug
 290    format to look for:  FIXME!!!
 291
 292    pastab_build_psymtabs() handles STABS symbols.
 293
 294    Note that PA files have a "minimal" symbol table, which is vaguely
 295    reminiscent of a COFF symbol table, but has only the minimal information
 296    necessary for linking.  We process this also, and use the information to
 297    build gdb's minimal symbol table.  This gives us some minimal debugging
 298    capability even for files compiled without -g.  */
 299
 300 static void
 301 pa_symfile_read (objfile, section_offsets, mainline)
 302      struct objfile *objfile;
 303      struct section_offsets *section_offsets;
 304      int mainline;
 305 {
 306   bfd *abfd = objfile->obfd;
 307   struct cleanup *back_to;
 308   CORE_ADDR offset;
 309
 310   init_minimal_symbol_collection ();
 311   back_to = make_cleanup (discard_minimal_symbols, 0);
 312
 313   make_cleanup (free_painfo, (PTR) objfile);
 314
 315   /* Process the normal PA symbol table first. */
 316
 317   /* FIXME, should take a section_offsets param, not just an offset.  */
 318
 319   offset = ANOFFSET (section_offsets, 0);
 320   pa_symtab_read (abfd, offset, objfile);
 321
 322   /* Now process debugging information, which is contained in
 323      special PA sections.  */
 324
 325   pastab_build_psymtabs (objfile, section_offsets, mainline);
 326
 327   read_unwind_info(objfile);
 328
 329   do_cleanups (back_to);
 330 }
 331
 332 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
 333    stab_section_info's, that might be dangling from it.  */
 334
 335 static void
 336 free_painfo (objp)
 337      PTR objp;
 338 {
 339   struct objfile *objfile = (struct objfile *)objp;
 340   struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
 341                                      objfile->sym_stab_info;
 342   struct stab_section_info *ssi, *nssi;
 343
 344   ssi = dbxinfo->stab_section_info;
 345   while (ssi)
 346     {
 347       nssi = ssi->next;
 348       mfree (objfile->md, ssi);
 349       ssi = nssi;
 350     }
 351
 352   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
 353 }
 354
 355 /* Initialize anything that needs initializing when a completely new symbol
 356    file is specified (not just adding some symbols from another file, e.g. a
 357    shared library).
 358
 359    We reinitialize buildsym, since we may be reading stabs from a PA file.  */
 360
 361 static void
 362 pa_new_init (ignore)
 363      struct objfile *ignore;
 364 {
 365   stabsread_new_init ();
 366   buildsym_new_init ();
 367 }
 368
 369 /* Perform any local cleanups required when we are done with a particular
 370    objfile.  I.E, we are in the process of discarding all symbol information
 371    for an objfile, freeing up all memory held for it, and unlinking the
 372    objfile struct from the global list of known objfiles. */
 373
 374 static void
 375 pa_symfile_finish (objfile)
 376      struct objfile *objfile;
 377 {
 378   if (objfile -> sym_stab_info != NULL)
 379     {
 380       mfree (objfile -> md, objfile -> sym_stab_info);
 381     }
 382 }
 383
 384 /* PA specific initialization routine for reading symbols.
 385
 386    It is passed a pointer to a struct sym_fns which contains, among other
 387    things, the BFD for the file whose symbols are being read, and a slot for
 388    a pointer to "private data" which we can fill with goodies.
 389
 390    This routine is almost a complete ripoff of dbx_symfile_init.  The
 391    common parts of these routines should be extracted and used instead of
 392    duplicating this code.  FIXME. */
 393
 394 static void
 395 pa_symfile_init (objfile)
 396      struct objfile *objfile;
 397 {
 398   int val;
 399   bfd *sym_bfd = objfile->obfd;
 400   char *name = bfd_get_filename (sym_bfd);
 401   asection *stabsect;           /* Section containing symbol table entries */
 402   asection *stringsect;         /* Section containing symbol name strings */
 403
 404   stabsect = bfd_get_section_by_name (sym_bfd, "$GDB_SYMBOLS$");
 405   stringsect = bfd_get_section_by_name (sym_bfd, "$GDB_STRINGS$");
 406
 407   /* Allocate struct to keep track of the symfile */
 408   objfile->sym_stab_info = (PTR)
 409     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
 410
 411   memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
 412
 413   if (!stabsect)
 414     return;
 415
 416   if (!stringsect)
 417     error ("Found stabs, but not string section");
 418
 419   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 420 #define STRING_TABLE_OFFSET     (stringsect->filepos)
 421 #define SYMBOL_TABLE_OFFSET     (stabsect->filepos)
 422
 423   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 424
 425   DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
 426   DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
 427   if (!DBX_TEXT_SECT (objfile))
 428     error ("Can't find .text section in symbol file");
 429
 430   /* FIXME: I suspect this should be external_nlist.  The size of host
 431      types like long and bfd_vma should not affect how we read the
 432      file.  */
 433   DBX_SYMBOL_SIZE (objfile) = sizeof (struct internal_nlist);
 434   DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
 435     / DBX_SYMBOL_SIZE (objfile);
 436   DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
 437
 438   /* Read the string table and stash it away in the psymbol_obstack.  It is
 439      only needed as long as we need to expand psymbols into full symbols,
 440      so when we blow away the psymbol the string table goes away as well.
 441      Note that gdb used to use the results of attempting to malloc the
 442      string table, based on the size it read, as a form of sanity check
 443      for botched byte swapping, on the theory that a byte swapped string
 444      table size would be so totally bogus that the malloc would fail.  Now
 445      that we put in on the psymbol_obstack, we can't do this since gdb gets
 446      a fatal error (out of virtual memory) if the size is bogus.  We can
 447      however at least check to see if the size is zero or some negative
 448      value. */
 449
 450   DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stringsect);
 451
 452   if (DBX_SYMCOUNT (objfile) == 0
 453       || DBX_STRINGTAB_SIZE (objfile) == 0)
 454     return;
 455
 456   if (DBX_STRINGTAB_SIZE (objfile) <= 0
 457       || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
 458     error ("ridiculous string table size (%d bytes).",
 459            DBX_STRINGTAB_SIZE (objfile));
 460
 461   DBX_STRINGTAB (objfile) =
 462     (char *) obstack_alloc (&objfile -> psymbol_obstack,
 463                             DBX_STRINGTAB_SIZE (objfile));
 464
 465   /* Now read in the string table in one big gulp.  */
 466
 467   val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
 468   if (val < 0)
 469     perror_with_name (name);
 470   val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
 471                   sym_bfd);
 472   if (val == 0)
 473     error ("End of file reading string table");
 474   else if (val < 0)
 475     /* It's possible bfd_read should be setting bfd_error, and we should be
 476        checking that.  But currently it doesn't set bfd_error.  */
 477     perror_with_name (name);
 478   else if (val != DBX_STRINGTAB_SIZE (objfile))
 479     error ("Short read reading string table");
 480 }
 481
 482 /* PA specific parsing routine for section offsets.
 483
 484    Plain and simple for now.  */
 485
 486 static struct section_offsets *
 487 pa_symfile_offsets (objfile, addr)
 488      struct objfile *objfile;
 489      CORE_ADDR addr;
 490 {
 491   struct section_offsets *section_offsets;
 492   int i;
 493
 494   objfile->num_sections = SECT_OFF_MAX;
 495   section_offsets = (struct section_offsets *)
 496     obstack_alloc (&objfile -> psymbol_obstack,
 497                    sizeof (struct section_offsets)
 498                    + sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
 499
 500   for (i = 0; i < SECT_OFF_MAX; i++)
 501     ANOFFSET (section_offsets, i) = addr;
 502
 503   return section_offsets;
 504 }
 505 \f
 506 /* Register that we are able to handle SOM object file formats.  */
 507
 508 static struct sym_fns pa_sym_fns =
 509 {
 510   bfd_target_som_flavour,
 511   pa_new_init,          /* sym_new_init: init anything gbl to entire symtab */
 512   pa_symfile_init,      /* sym_init: read initial info, setup for sym_read() */
 513   pa_symfile_read,      /* sym_read: read a symbol file into symtab */
 514   pa_symfile_finish,    /* sym_finish: finished with file, cleanup */
 515   pa_symfile_offsets,   /* sym_offsets:  Translate ext. to int. relocation */
 516   NULL                  /* next: pointer to next struct sym_fns */
 517 };
 518
 519 void
 520 _initialize_paread ()
 521 {
 522   add_symtab_fns (&pa_sym_fns);
 523 }