gdb/hpread.c

   1 /* Read hp debug symbols and convert to internal format, for GDB.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004 Free Software Foundation, Inc.
   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., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.
  21
  22    Written by the Center for Software Science at the University of Utah
  23    and by Cygnus Support.  */
  24
  25 #include "defs.h"
  26 #include "bfd.h"
  27 #include "gdb_string.h"
  28 #include "hp-symtab.h"
  29 #include "syms.h"
  30 #include "symtab.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "buildsym.h"
  34 #include "complaints.h"
  35 #include "gdb-stabs.h"
  36 #include "gdbtypes.h"
  37 #include "demangle.h"
  38 #include "solib-som.h"
  39 #include "gdb_assert.h"
  40 #include "hppa-tdep.h"
  41
  42 /* Private information attached to an objfile which we use to find
  43    and internalize the HP C debug symbols within that objfile.  */
  44
  45 struct hpread_symfile_info
  46   {
  47     /* The contents of each of the debug sections (there are 4 of them).  */
  48     char *gntt;
  49     char *lntt;
  50     char *slt;
  51     char *vt;
  52
  53     /* We keep the size of the $VT$ section for range checking.  */
  54     unsigned int vt_size;
  55
  56     /* Some routines still need to know the number of symbols in the
  57        main debug sections ($LNTT$ and $GNTT$). */
  58     unsigned int lntt_symcount;
  59     unsigned int gntt_symcount;
  60
  61     /* To keep track of all the types we've processed.  */
  62     struct type **dntt_type_vector;
  63     int dntt_type_vector_length;
  64
  65     /* Keeps track of the beginning of a range of source lines.  */
  66     sltpointer sl_index;
  67
  68     /* Some state variables we'll need.  */
  69     int within_function;
  70
  71     /* Keep track of the current function's address.  We may need to look
  72        up something based on this address.  */
  73     unsigned int current_function_value;
  74   };
  75
  76 /* Accessor macros to get at the fields.  */
  77 #define HPUX_SYMFILE_INFO(o) \
  78   ((struct hpread_symfile_info *)((o)->deprecated_sym_private))
  79 #define GNTT(o)                 (HPUX_SYMFILE_INFO(o)->gntt)
  80 #define LNTT(o)                 (HPUX_SYMFILE_INFO(o)->lntt)
  81 #define SLT(o)                  (HPUX_SYMFILE_INFO(o)->slt)
  82 #define VT(o)                   (HPUX_SYMFILE_INFO(o)->vt)
  83 #define VT_SIZE(o)              (HPUX_SYMFILE_INFO(o)->vt_size)
  84 #define LNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->lntt_symcount)
  85 #define GNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->gntt_symcount)
  86 #define DNTT_TYPE_VECTOR(o)     (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
  87 #define DNTT_TYPE_VECTOR_LENGTH(o) \
  88   (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
  89 #define SL_INDEX(o)             (HPUX_SYMFILE_INFO(o)->sl_index)
  90 #define WITHIN_FUNCTION(o)      (HPUX_SYMFILE_INFO(o)->within_function)
  91 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
  92
  93 \f
  94 /* We put a pointer to this structure in the read_symtab_private field
  95    of the psymtab.  */
  96
  97 struct symloc
  98   {
  99     /* The offset within the file symbol table of first local symbol for
 100        this file.  */
 101
 102     int ldsymoff;
 103
 104     /* Length (in bytes) of the section of the symbol table devoted to
 105        this file's symbols (actually, the section bracketed may contain
 106        more than just this file's symbols).  If ldsymlen is 0, the only
 107        reason for this thing's existence is the dependency list.
 108        Nothing else will happen when it is read in.  */
 109
 110     int ldsymlen;
 111   };
 112
 113 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
 114 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
 115 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
 116 \f
 117 /* Complaints about the symbols we have encountered.  */
 118 static void
 119 lbrac_unmatched_complaint (int arg1)
 120 {
 121   complaint (&symfile_complaints, _("unmatched N_LBRAC before symtab pos %d"),
 122              arg1);
 123 }
 124
 125 static void
 126 lbrac_mismatch_complaint (int arg1)
 127 {
 128   complaint (&symfile_complaints,
 129              _("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1);
 130 }
 131
 132 /* To generate dumping code, uncomment this define.  The dumping
 133    itself is controlled by routine-local statics called "dumping". */
 134 /* #define DUMPING         1 */
 135
 136 /* To use the quick look-up tables, uncomment this define. */
 137 #define QUICK_LOOK_UP      1
 138
 139 /* To call PXDB to process un-processed files, uncomment this define. */
 140 #define USE_PXDB           1
 141
 142 /* Forward procedure declarations */
 143
 144 /* Used in somread.c.  */
 145 void hpread_symfile_init (struct objfile *);
 146
 147 void do_pxdb (bfd *);
 148
 149 void hpread_build_psymtabs (struct objfile *, int);
 150
 151 void hpread_symfile_finish (struct objfile *);
 152
 153 static void set_namestring (union dnttentry *sym, char **namep,
 154                             struct objfile *objfile);
 155
 156 static union dnttentry *hpread_get_gntt (int, struct objfile *);
 157
 158 static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile);
 159
 160
 161 static unsigned long hpread_get_textlow (int, int, struct objfile *, int);
 162
 163 static struct partial_symtab *hpread_start_psymtab
 164   (struct objfile *, char *, CORE_ADDR, int,
 165    struct partial_symbol **, struct partial_symbol **);
 166
 167 static struct partial_symtab *hpread_end_psymtab
 168   (struct partial_symtab *, char **, int, int, CORE_ADDR,
 169    struct partial_symtab **, int);
 170
 171 static unsigned long hpread_get_scope_start (sltpointer, struct objfile *);
 172
 173 static unsigned long hpread_get_line (sltpointer, struct objfile *);
 174
 175 static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);
 176
 177 static int hpread_has_name (enum dntt_entry_type kind);
 178
 179 static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);
 180
 181 static void hpread_psymtab_to_symtab (struct partial_symtab *);
 182
 183 static struct symtab *hpread_expand_symtab
 184   (struct objfile *, int, int, CORE_ADDR, int,
 185    struct section_offsets *, char *);
 186
 187 static int hpread_type_translate (dnttpointer);
 188
 189 static struct type **hpread_lookup_type (dnttpointer, struct objfile *);
 190
 191 static struct type *hpread_alloc_type (dnttpointer, struct objfile *);
 192
 193 static struct type *hpread_read_enum_type
 194   (dnttpointer, union dnttentry *, struct objfile *);
 195
 196 static struct type *hpread_read_function_type
 197   (dnttpointer, union dnttentry *, struct objfile *, int);
 198
 199 static struct type *hpread_read_doc_function_type
 200   (dnttpointer, union dnttentry *, struct objfile *, int);
 201
 202 static struct type *hpread_read_struct_type
 203   (dnttpointer, union dnttentry *, struct objfile *);
 204
 205 static struct type *hpread_get_nth_template_arg (struct objfile *, int);
 206
 207 static struct type *hpread_read_templ_arg_type
 208   (dnttpointer, union dnttentry *, struct objfile *, char *);
 209
 210 static struct type *hpread_read_set_type
 211   (dnttpointer, union dnttentry *, struct objfile *);
 212
 213 static struct type *hpread_read_array_type
 214   (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile);
 215
 216 static struct type *hpread_read_subrange_type
 217   (dnttpointer, union dnttentry *, struct objfile *);
 218
 219 static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
 220
 221 static sltpointer hpread_record_lines
 222   (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
 223
 224 static void hpread_process_one_debug_symbol
 225   (union dnttentry *, char *, struct section_offsets *,
 226    struct objfile *, CORE_ADDR, int, char *, int, int *);
 227
 228 static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int);
 229
 230 static void fix_static_member_physnames
 231   (struct type *, char *, struct objfile *);
 232
 233 static void fixup_class_method_type
 234   (struct type *, struct type *, struct objfile *);
 235
 236 static void hpread_adjust_bitoffsets (struct type *, int);
 237
 238 static int hpread_adjust_stack_address (CORE_ADDR func_addr);
 239
 240 static dnttpointer hpread_get_next_skip_over_anon_unions
 241   (int, dnttpointer, union dnttentry **, struct objfile *);
 242
 243 \f
 244 /* Static used to indicate a class type that requires a
 245    fix-up of one of its method types */
 246 static struct type *fixup_class = NULL;
 247
 248 /* Static used to indicate the method type that is to be
 249    used to fix-up the type for fixup_class */
 250 static struct type *fixup_method = NULL;
 251
 252 #ifdef USE_PXDB
 253
 254 /* NOTE use of system files!  May not be portable. */
 255
 256 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
 257 #define PXDB_BSD  "/usr/bin/pxdb"
 258
 259 #include <stdlib.h>
 260 #include "gdb_string.h"
 261
 262 /* check for the existence of a file, given its full pathname */
 263 static int
 264 file_exists (char *filename)
 265 {
 266   if (filename)
 267     return (access (filename, F_OK) == 0);
 268   return 0;
 269 }
 270
 271
 272 /* Translate from the "hp_language" enumeration in hp-symtab.h
 273    used in the debug info to gdb's generic enumeration in defs.h. */
 274 static enum language
 275 trans_lang (enum hp_language in_lang)
 276 {
 277   if (in_lang == HP_LANGUAGE_C)
 278     return language_c;
 279
 280   else if (in_lang == HP_LANGUAGE_CPLUSPLUS)
 281     return language_cplus;
 282
 283   else if (in_lang == HP_LANGUAGE_FORTRAN)
 284     return language_fortran;
 285
 286   else
 287     return language_unknown;
 288 }
 289
 290 static char main_string[] = "main";
 291 \f
 292
 293 /* Given the native debug symbol SYM, set NAMEP to the name associated
 294    with the debug symbol.  Note we may be called with a debug symbol which
 295    has no associated name, in that case we return an empty string.  */
 296
 297 static void
 298 set_namestring (union dnttentry *sym, char **namep, struct objfile *objfile)
 299 {
 300   /* Note that we "know" that the name for any symbol is always in the same
 301      place.  Hence we don't have to conditionalize on the symbol type.  */
 302   if (! hpread_has_name (sym->dblock.kind))
 303     *namep = "";
 304   else if ((unsigned) sym->dsfile.name >= VT_SIZE (objfile))
 305     {
 306       complaint (&symfile_complaints, _("bad string table offset in symbol %d"),
 307                  symnum);
 308       *namep = "";
 309     }
 310   else
 311     *namep = sym->dsfile.name + VT (objfile);
 312 }
 313
 314 /* Call PXDB to process our file.
 315
 316    Approach copied from DDE's "dbgk_run_pxdb".  Note: we
 317    don't check for BSD location of pxdb, nor for existence
 318    of pxdb itself, etc.
 319
 320    NOTE: uses system function and string functions directly.
 321
 322    Return value: 1 if ok, 0 if not */
 323 static int
 324 hpread_call_pxdb (const char *file_name)
 325 {
 326   char *p;
 327   int status;
 328   int retval;
 329
 330   if (file_exists (PXDB_SVR4))
 331     {
 332       p = xmalloc (strlen (PXDB_SVR4) + strlen (file_name) + 2);
 333       strcpy (p, PXDB_SVR4);
 334       strcat (p, " ");
 335       strcat (p, file_name);
 336
 337       warning (_("File not processed by pxdb--about to process now."));
 338       status = system (p);
 339
 340       retval = (status == 0);
 341     }
 342   else
 343     {
 344       warning (_("pxdb not found at standard location: /opt/langtools/bin\ngdb will not be able to debug %s.\nPlease install pxdb at the above location and then restart gdb.\nYou can also run pxdb on %s with the command\n\"pxdb %s\" and then restart gdb."), file_name, file_name, file_name);
 345
 346       retval = 0;
 347     }
 348   return retval;
 349 }                               /* hpread_call_pxdb */
 350 \f
 351
 352 /* Return 1 if the file turns out to need pre-processing
 353    by PXDB, and we have thus called PXDB to do this processing
 354    and the file therefore needs to be re-loaded.  Otherwise
 355    return 0. */
 356 static int
 357 hpread_pxdb_needed (bfd *sym_bfd)
 358 {
 359   asection *pinfo_section, *debug_section, *header_section;
 360   unsigned int do_pxdb;
 361   char *buf;
 362   bfd_size_type header_section_size;
 363
 364   unsigned long tmp;
 365   unsigned int pxdbed;
 366
 367   header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$");
 368   if (!header_section)
 369     {
 370       return 0;                 /* No header at all, can't recover... */
 371     }
 372
 373   debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$");
 374   pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$");
 375
 376   if (pinfo_section && !debug_section)
 377     {
 378       /* Debug info with DOC, has different header format.
 379          this only happens if the file was pxdbed and compiled optimized
 380          otherwise the PINFO section is not there. */
 381       header_section_size = bfd_section_size (objfile->obfd, header_section);
 382
 383       if (header_section_size == (bfd_size_type) sizeof (DOC_info_PXDB_header))
 384         {
 385           buf = alloca (sizeof (DOC_info_PXDB_header));
 386           memset (buf, 0, sizeof (DOC_info_PXDB_header));
 387
 388           if (!bfd_get_section_contents (sym_bfd,
 389                                          header_section,
 390                                          buf, 0,
 391                                          header_section_size))
 392             error (_("bfd_get_section_contents."));
 393
 394           tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 4));
 395           pxdbed = (tmp >> 31) & 0x1;
 396
 397           if (!pxdbed)
 398             error (_("file debug header info invalid."));
 399           do_pxdb = 0;
 400         }
 401
 402       else
 403         error (_("invalid $HEADER$ size in executable."));
 404     }
 405
 406   else
 407     {
 408
 409       /* this can be three different cases:
 410          1. pxdbed and not doc
 411          - DEBUG and HEADER sections are there
 412          - header is PXDB_header type
 413          - pxdbed flag is set to 1
 414
 415          2. not pxdbed and doc
 416          - DEBUG and HEADER  sections are there
 417          - header is DOC_info_header type
 418          - pxdbed flag is set to 0
 419
 420          3. not pxdbed and not doc
 421          - DEBUG and HEADER sections are there
 422          - header is XDB_header type
 423          - pxdbed flag is set to 0
 424
 425          NOTE: the pxdbed flag is meaningful also in the not
 426          already pxdb processed version of the header,
 427          because in case on non-already processed by pxdb files
 428          that same bit in the header would be always zero.
 429          Why? Because the bit is the leftmost bit of a word
 430          which contains a 'length' which is always a positive value
 431          so that bit is never set to 1 (otherwise it would be negative)
 432
 433          Given the above, we have two choices : either we ignore the
 434          size of the header itself and just look at the pxdbed field,
 435          or we check the size and then we (for safety and paranoia related
 436          issues) check the bit.
 437          The first solution is used by DDE, the second by PXDB itself.
 438          I am using the second one here, because I already wrote it,
 439          and it is the end of a long day.
 440          Also, using the first approach would still involve size issues
 441          because we need to read in the contents of the header section, and
 442          give the correct amount of stuff we want to read to the
 443          get_bfd_section_contents function.  */
 444
 445       /* decide which case depending on the size of the header section.
 446          The size is as defined in hp-symtab.h  */
 447
 448       header_section_size = bfd_section_size (objfile->obfd, header_section);
 449
 450       if (header_section_size == (bfd_size_type) sizeof (PXDB_header))  /* pxdb and not doc */
 451         {
 452
 453           buf = alloca (sizeof (PXDB_header));
 454           memset (buf, 0, sizeof (PXDB_header));
 455           if (!bfd_get_section_contents (sym_bfd,
 456                                          header_section,
 457                                          buf, 0,
 458                                          header_section_size))
 459             error (_("bfd_get_section_contents."));
 460
 461           tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 3));
 462           pxdbed = (tmp >> 31) & 0x1;
 463
 464           if (pxdbed)
 465             do_pxdb = 0;
 466           else
 467             error (_("file debug header invalid."));
 468         }
 469       else                      /*not pxdbed and doc OR not pxdbed and non doc */
 470         do_pxdb = 1;
 471     }
 472
 473   if (do_pxdb)
 474     {
 475       return 1;
 476     }
 477   else
 478     {
 479       return 0;
 480     }
 481 }                               /* hpread_pxdb_needed */
 482
 483 #endif
 484
 485 /* Check whether the file needs to be preprocessed by pxdb.
 486    If so, call pxdb. */
 487
 488 void
 489 do_pxdb (bfd *sym_bfd)
 490 {
 491   /* The following code is HP-specific.  The "right" way of
 492      doing this is unknown, but we bet would involve a target-
 493      specific pre-file-load check using a generic mechanism. */
 494
 495   /* This code will not be executed if the file is not in SOM
 496      format (i.e. if compiled with gcc) */
 497   if (hpread_pxdb_needed (sym_bfd))
 498     {
 499       /*This file has not been pre-processed. Preprocess now */
 500
 501       if (hpread_call_pxdb (sym_bfd->filename))
 502         {
 503           /* The call above has changed the on-disk file,
 504              we can close the file anyway, because the
 505              symbols will be reread in when the target is run */
 506           bfd_close (sym_bfd);
 507         }
 508     }
 509 }
 510 \f
 511
 512
 513 #ifdef QUICK_LOOK_UP
 514
 515 /* Code to handle quick lookup-tables follows. */
 516
 517
 518 /* Some useful macros */
 519 #define VALID_FILE(i)   ((i) < pxdb_header_p->fd_entries)
 520 #define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries)
 521 #define VALID_PROC(i)   ((i) < pxdb_header_p->pd_entries)
 522 #define VALID_CLASS(i)  ((i) < pxdb_header_p->cd_entries)
 523
 524 #define FILE_START(i)    (qFD[i].adrStart)
 525 #define MODULE_START(i) (qMD[i].adrStart)
 526 #define PROC_START(i)    (qPD[i].adrStart)
 527
 528 #define FILE_END(i)   (qFD[i].adrEnd)
 529 #define MODULE_END(i) (qMD[i].adrEnd)
 530 #define PROC_END(i)   (qPD[i].adrEnd)
 531
 532 #define FILE_ISYM(i)   (qFD[i].isym)
 533 #define MODULE_ISYM(i) (qMD[i].isym)
 534 #define PROC_ISYM(i)   (qPD[i].isym)
 535
 536 #define VALID_CURR_FILE    (curr_fd < pxdb_header_p->fd_entries)
 537 #define VALID_CURR_MODULE  (curr_md < pxdb_header_p->md_entries)
 538 #define VALID_CURR_PROC    (curr_pd < pxdb_header_p->pd_entries)
 539 #define VALID_CURR_CLASS   (curr_cd < pxdb_header_p->cd_entries)
 540
 541 #define CURR_FILE_START     (qFD[curr_fd].adrStart)
 542 #define CURR_MODULE_START   (qMD[curr_md].adrStart)
 543 #define CURR_PROC_START     (qPD[curr_pd].adrStart)
 544
 545 #define CURR_FILE_END    (qFD[curr_fd].adrEnd)
 546 #define CURR_MODULE_END  (qMD[curr_md].adrEnd)
 547 #define CURR_PROC_END    (qPD[curr_pd].adrEnd)
 548
 549 #define CURR_FILE_ISYM    (qFD[curr_fd].isym)
 550 #define CURR_MODULE_ISYM  (qMD[curr_md].isym)
 551 #define CURR_PROC_ISYM    (qPD[curr_pd].isym)
 552
 553 #define TELL_OBJFILE                                      \
 554             do {                                          \
 555                if( !told_objfile ) {                      \
 556                    told_objfile = 1;                      \
 557                    warning (_("\nIn object file \"%s\":"), \
 558                             objfile->name);               \
 559                }                                          \
 560             } while (0)
 561 \f
 562
 563
 564 /* Keeping track of the start/end symbol table (LNTT) indices of
 565    psymtabs created so far */
 566
 567 typedef struct
 568 {
 569   int start;
 570   int end;
 571 }
 572 pst_syms_struct;
 573
 574 static pst_syms_struct *pst_syms_array = 0;
 575
 576 static int pst_syms_count = 0;
 577 static int pst_syms_size = 0;
 578
 579 /* used by the TELL_OBJFILE macro */
 580 static int told_objfile = 0;
 581
 582 /* Set up psymtab symbol index stuff */
 583 static void
 584 init_pst_syms (void)
 585 {
 586   pst_syms_count = 0;
 587   pst_syms_size = 20;
 588   pst_syms_array = (pst_syms_struct *) xmalloc (20 * sizeof (pst_syms_struct));
 589 }
 590
 591 /* Clean up psymtab symbol index stuff */
 592 static void
 593 clear_pst_syms (void)
 594 {
 595   pst_syms_count = 0;
 596   pst_syms_size = 0;
 597   xfree (pst_syms_array);
 598   pst_syms_array = 0;
 599 }
 600
 601 /* Add information about latest psymtab to symbol index table */
 602 static void
 603 record_pst_syms (int start_sym, int end_sym)
 604 {
 605   if (++pst_syms_count > pst_syms_size)
 606     {
 607       pst_syms_array = (pst_syms_struct *) xrealloc (pst_syms_array,
 608                               2 * pst_syms_size * sizeof (pst_syms_struct));
 609       pst_syms_size *= 2;
 610     }
 611   pst_syms_array[pst_syms_count - 1].start = start_sym;
 612   pst_syms_array[pst_syms_count - 1].end = end_sym;
 613 }
 614
 615 /* Find a suitable symbol table index which can serve as the upper
 616    bound of a psymtab that starts at INDEX
 617
 618    This scans backwards in the psymtab symbol index table to find a
 619    "hole" in which the given index can fit.  This is a heuristic!!
 620    We don't search the entire table to check for multiple holes,
 621    we don't care about overlaps, etc.
 622
 623    Return 0 => not found */
 624 static int
 625 find_next_pst_start (int index)
 626 {
 627   int i;
 628
 629   for (i = pst_syms_count - 1; i >= 0; i--)
 630     if (pst_syms_array[i].end <= index)
 631       return (i == pst_syms_count - 1) ? 0 : pst_syms_array[i + 1].start - 1;
 632
 633   if (pst_syms_array[0].start > index)
 634     return pst_syms_array[0].start - 1;
 635
 636   return 0;
 637 }
 638 \f
 639
 640
 641 /* Utility functions to find the ending symbol index for a psymtab */
 642
 643 /* Find the next file entry that begins beyond INDEX, and return
 644    its starting symbol index - 1.
 645    QFD is the file table, CURR_FD is the file entry from where to start,
 646    PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
 647
 648    Return 0 => not found */
 649 static int
 650 find_next_file_isym (int index, quick_file_entry *qFD, int curr_fd,
 651                      PXDB_header_ptr pxdb_header_p)
 652 {
 653   while (VALID_CURR_FILE)
 654     {
 655       if (CURR_FILE_ISYM >= index)
 656         return CURR_FILE_ISYM - 1;
 657       curr_fd++;
 658     }
 659   return 0;
 660 }
 661
 662 /* Find the next procedure entry that begins beyond INDEX, and return
 663    its starting symbol index - 1.
 664    QPD is the procedure table, CURR_PD is the proc entry from where to start,
 665    PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
 666
 667    Return 0 => not found */
 668 static int
 669 find_next_proc_isym (int index, quick_procedure_entry *qPD, int curr_pd,
 670                      PXDB_header_ptr pxdb_header_p)
 671 {
 672   while (VALID_CURR_PROC)
 673     {
 674       if (CURR_PROC_ISYM >= index)
 675         return CURR_PROC_ISYM - 1;
 676       curr_pd++;
 677     }
 678   return 0;
 679 }
 680
 681 /* Find the next module entry that begins beyond INDEX, and return
 682    its starting symbol index - 1.
 683    QMD is the module table, CURR_MD is the modue entry from where to start,
 684    PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
 685
 686    Return 0 => not found */
 687 static int
 688 find_next_module_isym (int index, quick_module_entry *qMD, int curr_md,
 689                        PXDB_header_ptr pxdb_header_p)
 690 {
 691   while (VALID_CURR_MODULE)
 692     {
 693       if (CURR_MODULE_ISYM >= index)
 694         return CURR_MODULE_ISYM - 1;
 695       curr_md++;
 696     }
 697   return 0;
 698 }
 699
 700 /* Scan and record partial symbols for all functions starting from index
 701    pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR.
 702    Other parameters are explained in comments below. */
 703
 704 /* This used to be inline in hpread_quick_traverse, but now that we do
 705    essentially the same thing for two different cases (modules and
 706    module-less files), it's better organized in a separate routine,
 707    although it does take lots of arguments.  pai/1997-10-08
 708
 709    CURR_PD_P is the pointer to the current proc index. QPD is the
 710    procedure quick lookup table.  MAX_PROCS is the number of entries
 711    in the proc. table.  START_ADR is the beginning of the code range
 712    for the current psymtab.  end_adr is the end of the code range for
 713    the current psymtab.  PST is the current psymtab.  VT_bits is
 714    a pointer to the strings table of SOM debug space.  OBJFILE is
 715    the current object file. */
 716
 717 static int
 718 scan_procs (int *curr_pd_p, quick_procedure_entry *qPD, int max_procs,
 719             CORE_ADDR start_adr, CORE_ADDR end_adr, struct partial_symtab *pst,
 720             char *vt_bits, struct objfile *objfile)
 721 {
 722   union dnttentry *dn_bufp;
 723   int symbol_count = 0;         /* Total number of symbols in this psymtab */
 724   int curr_pd = *curr_pd_p;     /* Convenience variable -- avoid dereferencing pointer all the time */
 725
 726 #ifdef DUMPING
 727   /* Turn this on for lots of debugging information in this routine */
 728   static int dumping = 0;
 729 #endif
 730
 731 #ifdef DUMPING
 732   if (dumping)
 733     {
 734       printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr, end_adr, curr_pd);
 735     }
 736 #endif
 737
 738   while ((CURR_PROC_START <= end_adr) && (curr_pd < max_procs))
 739     {
 740
 741       char *rtn_name;           /* mangled name */
 742       char *rtn_dem_name;       /* qualified demangled name */
 743       char *class_name;
 744       int class;
 745
 746       if ((trans_lang ((enum hp_language) qPD[curr_pd].language) == language_cplus) &&
 747           vt_bits[(long) qPD[curr_pd].sbAlias])         /* not a null string */
 748         {
 749           /* Get mangled name for the procedure, and demangle it */
 750           rtn_name = &vt_bits[(long) qPD[curr_pd].sbAlias];
 751           rtn_dem_name = cplus_demangle (rtn_name, DMGL_ANSI | DMGL_PARAMS);
 752         }
 753       else
 754         {
 755           rtn_name = &vt_bits[(long) qPD[curr_pd].sbProc];
 756           rtn_dem_name = NULL;
 757         }
 758
 759       /* Hack to get around HP C/C++ compilers' insistence on providing
 760          "_MAIN_" as an alternate name for "main" */
 761       if ((strcmp (rtn_name, "_MAIN_") == 0) &&
 762           (strcmp (&vt_bits[(long) qPD[curr_pd].sbProc], "main") == 0))
 763         rtn_dem_name = rtn_name = main_string;
 764
 765 #ifdef DUMPING
 766       if (dumping)
 767         {
 768           printf ("..add %s (demangled %s), index %x to this psymtab\n", rtn_name, rtn_dem_name, curr_pd);
 769         }
 770 #endif
 771
 772       /* Check for module-spanning routines. */
 773       if (CURR_PROC_END > end_adr)
 774         {
 775           TELL_OBJFILE;
 776           warning (_("Procedure \"%s\" [0x%x] spans file or module boundaries."), rtn_name, curr_pd);
 777         }
 778
 779       /* Add this routine symbol to the list in the objfile.
 780          Unfortunately we have to go to the LNTT to determine the
 781          correct list to put it on. An alternative (which the
 782          code used to do) would be to not check and always throw
 783          it on the "static" list. But if we go that route, then
 784          symbol_lookup() needs to be tweaked a bit to account
 785          for the fact that the function might not be found on
 786          the correct list in the psymtab. - RT */
 787       dn_bufp = hpread_get_lntt (qPD[curr_pd].isym, objfile);
 788       if (dn_bufp->dfunc.global)
 789         add_psymbol_with_dem_name_to_list (rtn_name,
 790                                            strlen (rtn_name),
 791                                            rtn_dem_name,
 792                                            strlen (rtn_dem_name),
 793                                            VAR_DOMAIN,
 794                                            LOC_BLOCK,   /* "I am a routine"        */
 795                                            &objfile->global_psymbols,
 796                                            (qPD[curr_pd].adrStart +     /* Starting address of rtn */
 797                                  ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))),
 798                                            0,   /* core addr?? */
 799                       trans_lang ((enum hp_language) qPD[curr_pd].language),
 800                                            objfile);
 801       else
 802         add_psymbol_with_dem_name_to_list (rtn_name,
 803                                            strlen (rtn_name),
 804                                            rtn_dem_name,
 805                                            strlen (rtn_dem_name),
 806                                            VAR_DOMAIN,
 807                                            LOC_BLOCK,   /* "I am a routine"        */
 808                                            &objfile->static_psymbols,
 809                                            (qPD[curr_pd].adrStart +     /* Starting address of rtn */
 810                                  ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))),
 811                                            0,   /* core addr?? */
 812                       trans_lang ((enum hp_language) qPD[curr_pd].language),
 813                                            objfile);
 814
 815       symbol_count++;
 816       *curr_pd_p = ++curr_pd;   /* bump up count & reflect in caller */
 817     }                           /* loop over procedures */
 818
 819 #ifdef DUMPING
 820   if (dumping)
 821     {
 822       if (symbol_count == 0)
 823         printf ("Scan_procs: no symbols found!\n");
 824     }
 825 #endif
 826
 827   return symbol_count;
 828 }
 829
 830
 831 /* Traverse the quick look-up tables, building a set of psymtabs.
 832
 833    This constructs a psymtab for modules and files in the quick lookup
 834    tables.
 835
 836    Mostly, modules correspond to compilation units, so we try to
 837    create psymtabs that correspond to modules; however, in some cases
 838    a file can result in a compiled object which does not have a module
 839    entry for it, so in such cases we create a psymtab for the file.  */
 840
 841 static int
 842 hpread_quick_traverse (struct objfile *objfile, char *gntt_bits,
 843                        char *vt_bits, PXDB_header_ptr pxdb_header_p)
 844 {
 845   struct partial_symtab *pst;
 846
 847   char *addr;
 848
 849   quick_procedure_entry *qPD;
 850   quick_file_entry *qFD;
 851   quick_module_entry *qMD;
 852   quick_class_entry *qCD;
 853
 854   int idx;
 855   int i;
 856   CORE_ADDR start_adr;          /* current psymtab's starting code addr   */
 857   CORE_ADDR end_adr;            /* current psymtab's ending code addr     */
 858   CORE_ADDR next_mod_adr;       /* next module's starting code addr    */
 859   int curr_pd;                  /* current procedure */
 860   int curr_fd;                  /* current file      */
 861   int curr_md;                  /* current module    */
 862   int start_sym;                /* current psymtab's starting symbol index */
 863   int end_sym;                  /* current psymtab's ending symbol index   */
 864   int max_LNTT_sym_index;
 865   int syms_in_pst;
 866   B_TYPE *class_entered;
 867
 868   struct partial_symbol **global_syms;  /* We'll be filling in the "global"   */
 869   struct partial_symbol **static_syms;  /* and "static" tables in the objfile
 870                                            as we go, so we need a pair of
 871                                            current pointers. */
 872
 873 #ifdef DUMPING
 874   /* Turn this on for lots of debugging information in this routine.
 875      You get a blow-by-blow account of quick lookup table reading */
 876   static int dumping = 0;
 877 #endif
 878
 879   pst = (struct partial_symtab *) 0;
 880
 881   /* Clear out some globals */
 882   init_pst_syms ();
 883   told_objfile = 0;
 884
 885   /* Demangling style -- if EDG style already set, don't change it,
 886      as HP style causes some problems with the KAI EDG compiler */
 887   if (current_demangling_style != edg_demangling)
 888     {
 889       /* Otherwise, ensure that we are using HP style demangling */
 890       set_demangling_style (HP_DEMANGLING_STYLE_STRING);
 891     }
 892
 893   /* First we need to find the starting points of the quick
 894      look-up tables in the GNTT. */
 895
 896   addr = gntt_bits;
 897
 898   qPD = (quick_procedure_entry_ptr) addr;
 899   addr += pxdb_header_p->pd_entries * sizeof (quick_procedure_entry);
 900
 901 #ifdef DUMPING
 902   if (dumping)
 903     {
 904       printf ("\n Printing routines as we see them\n");
 905       for (i = 0; VALID_PROC (i); i++)
 906         {
 907           idx = (long) qPD[i].sbProc;
 908           printf ("%s %x..%x\n", &vt_bits[idx],
 909                   (int) PROC_START (i),
 910                   (int) PROC_END (i));
 911         }
 912     }
 913 #endif
 914
 915   qFD = (quick_file_entry_ptr) addr;
 916   addr += pxdb_header_p->fd_entries * sizeof (quick_file_entry);
 917
 918 #ifdef DUMPING
 919   if (dumping)
 920     {
 921       printf ("\n Printing files as we see them\n");
 922       for (i = 0; VALID_FILE (i); i++)
 923         {
 924           idx = (long) qFD[i].sbFile;
 925           printf ("%s %x..%x\n", &vt_bits[idx],
 926                   (int) FILE_START (i),
 927                   (int) FILE_END (i));
 928         }
 929     }
 930 #endif
 931
 932   qMD = (quick_module_entry_ptr) addr;
 933   addr += pxdb_header_p->md_entries * sizeof (quick_module_entry);
 934
 935 #ifdef DUMPING
 936   if (dumping)
 937     {
 938       printf ("\n Printing modules as we see them\n");
 939       for (i = 0; i < pxdb_header_p->md_entries; i++)
 940         {
 941           idx = (long) qMD[i].sbMod;
 942           printf ("%s\n", &vt_bits[idx]);
 943         }
 944     }
 945 #endif
 946
 947   qCD = (quick_class_entry_ptr) addr;
 948   addr += pxdb_header_p->cd_entries * sizeof (quick_class_entry);
 949
 950 #ifdef DUMPING
 951   if (dumping)
 952     {
 953       printf ("\n Printing classes as we see them\n");
 954       for (i = 0; VALID_CLASS (i); i++)
 955         {
 956           idx = (long) qCD[i].sbClass;
 957           printf ("%s\n", &vt_bits[idx]);
 958         }
 959
 960       printf ("\n Done with dump, on to build!\n");
 961     }
 962 #endif
 963
 964   /* We need this index only while hp-symtab-read.c expects
 965      a byte offset to the end of the LNTT entries for a given
 966      psymtab.  Thus the need for it should go away someday.
 967
 968      When it goes away, then we won't have any need to load the
 969      LNTT from the objfile at psymtab-time, and start-up will be
 970      faster.  To make that work, we'll need some way to create
 971      a null pst for the "globals" pseudo-module. */
 972   max_LNTT_sym_index = LNTT_SYMCOUNT (objfile);
 973
 974   /* Scan the module descriptors and make a psymtab for each.
 975
 976      We know the MDs, FDs and the PDs are in order by starting
 977      address.  We use that fact to traverse all three arrays in
 978      parallel, knowing when the next PD is in a new file
 979      and we need to create a new psymtab. */
 980   curr_pd = 0;                  /* Current procedure entry */
 981   curr_fd = 0;                  /* Current file entry */
 982   curr_md = 0;                  /* Current module entry */
 983
 984   start_adr = 0;                /* Current psymtab code range */
 985   end_adr = 0;
 986
 987   start_sym = 0;                /* Current psymtab symbol range */
 988   end_sym = 0;
 989
 990   syms_in_pst = 0;              /* Symbol count for psymtab */
 991
 992   /* Psts actually just have pointers into the objfile's
 993      symbol table, not their own symbol tables. */
 994   global_syms = objfile->global_psymbols.list;
 995   static_syms = objfile->static_psymbols.list;
 996
 997
 998   /* First skip over pseudo-entries with address 0.  These represent inlined
 999      routines and abstract (uninstantiated) template routines.
1000      FIXME: These should be read in and available -- even if we can't set
1001      breakpoints, etc., there's some information that can be presented
1002      to the user. pai/1997-10-08  */
1003
1004   while (VALID_CURR_PROC && (CURR_PROC_START == 0))
1005     curr_pd++;
1006
1007   /* Loop over files, modules, and procedures in code address order. Each
1008      time we enter an iteration of this loop, curr_pd points to the first
1009      unprocessed procedure, curr_fd points to the first unprocessed file, and
1010      curr_md to the first unprocessed module.  Each iteration of this loop
1011      updates these as required -- any or all of them may be bumpd up
1012      each time around.  When we exit this loop, we are done with all files
1013      and modules in the tables -- there may still be some procedures, however.
1014
1015      Note: This code used to loop only over module entries, under the assumption
1016      that files can occur via inclusions and are thus unreliable, while a
1017      compiled object always corresponds to a module.  With CTTI in the HP aCC
1018      compiler, it turns out that compiled objects may have only files and no
1019      modules; so we have to loop over files and modules, creating psymtabs for
1020      either as appropriate.  Unfortunately there are some problems (notably:
1021      1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers
1022      to the ending symbol indices of a module or a file) which make it quite hard
1023      to do this correctly.  Currently it uses a bunch of heuristics to start and
1024      end psymtabs; they seem to work well with most objects generated by aCC, but
1025      who knows when that will change...   */
1026
1027   while (VALID_CURR_FILE || VALID_CURR_MODULE)
1028     {
1029
1030       char *mod_name_string = NULL;
1031       char *full_name_string;
1032
1033       /* First check for modules like "version.c", which have no code
1034          in them but still have qMD entries.  They also have no qFD or
1035          qPD entries.  Their start address is -1 and their end address
1036          is 0.  */
1037       if (VALID_CURR_MODULE && (CURR_MODULE_START == -1) && (CURR_MODULE_END == 0))
1038         {
1039
1040           mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
1041
1042 #ifdef DUMPING
1043           if (dumping)
1044             printf ("Module with data only %s\n", mod_name_string);
1045 #endif
1046
1047           /* We'll skip the rest (it makes error-checking easier), and
1048              just make an empty pst.  Right now empty psts are not put
1049              in the pst chain, so all this is for naught, but later it
1050              might help.  */
1051
1052           pst = hpread_start_psymtab (objfile,
1053                                       mod_name_string,
1054                                       CURR_MODULE_START,        /* Low text address: bogus! */
1055                        (CURR_MODULE_ISYM * sizeof (struct dntt_type_block)),
1056           /* ldsymoff */
1057                                       global_syms,
1058                                       static_syms);
1059
1060           pst = hpread_end_psymtab (pst,
1061                                     NULL,       /* psymtab_include_list */
1062                                     0,  /* includes_used        */
1063                                   end_sym * sizeof (struct dntt_type_block),
1064           /* byte index in LNTT of end
1065              = capping symbol offset
1066              = LDSYMOFF of nextfile */
1067                                     0,  /* text high            */
1068                                     NULL,       /* dependency_list      */
1069                                     0);         /* dependencies_used    */
1070
1071           global_syms = objfile->global_psymbols.next;
1072           static_syms = objfile->static_psymbols.next;
1073
1074           curr_md++;
1075         }
1076       else if (VALID_CURR_MODULE &&
1077                ((CURR_MODULE_START == 0) || (CURR_MODULE_START == -1) ||
1078                 (CURR_MODULE_END == 0) || (CURR_MODULE_END == -1)))
1079         {
1080           TELL_OBJFILE;
1081           warning (_("Module \"%s\" [0x%s] has non-standard addresses.  It starts at 0x%s, ends at 0x%s, and will be skipped."),
1082                    mod_name_string, paddr_nz (curr_md), paddr_nz (start_adr), paddr_nz (end_adr));
1083           /* On to next module */
1084           curr_md++;
1085         }
1086       else
1087         {
1088           /* First check if we are looking at a file with code in it
1089              that does not overlap the current module's code range */
1090
1091           if (VALID_CURR_FILE ? (VALID_CURR_MODULE ? (CURR_FILE_END < CURR_MODULE_START) : 1) : 0)
1092             {
1093
1094               /* Looking at file not corresponding to any module,
1095                  create a psymtab for it */
1096               full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile];
1097               start_adr = CURR_FILE_START;
1098               end_adr = CURR_FILE_END;
1099               start_sym = CURR_FILE_ISYM;
1100
1101               /* Check if there are any procedures not handled until now, that
1102                  begin before the start address of this file, and if so, adjust
1103                  this module's start address to include them.  This handles routines that
1104                  are in between file or module ranges for some reason (probably
1105                  indicates a compiler bug */
1106
1107               if (CURR_PROC_START < start_adr)
1108                 {
1109                   TELL_OBJFILE;
1110                   warning (_("Found procedure \"%s\" [0x%x] that is not in any file or module."),
1111                            &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
1112                   start_adr = CURR_PROC_START;
1113                   if (CURR_PROC_ISYM < start_sym)
1114                     start_sym = CURR_PROC_ISYM;
1115                 }
1116
1117               /* Sometimes (compiler bug -- COBOL) the module end address is higher
1118                  than the start address of the next module, so check for that and
1119                  adjust accordingly */
1120
1121               if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr))
1122                 {
1123                   TELL_OBJFILE;
1124                   warning (_("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down."),
1125                            full_name_string, curr_fd);
1126                   end_adr = FILE_START (curr_fd + 1) - 1;       /* Is -4 (or -8 for 64-bit) better? */
1127                 }
1128               if (VALID_MODULE (curr_md) && (CURR_MODULE_START <= end_adr))
1129                 {
1130                   TELL_OBJFILE;
1131                   warning (_("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down."),
1132                            full_name_string, curr_fd);
1133                   end_adr = CURR_MODULE_START - 1;      /* Is -4 (or -8 for 64-bit) better? */
1134                 }
1135
1136
1137 #ifdef DUMPING
1138               if (dumping)
1139                 {
1140                   printf ("Make new psymtab for file %s (%x to %x).\n",
1141                           full_name_string, start_adr, end_adr);
1142                 }
1143 #endif
1144               /* Create the basic psymtab, connecting it in the list
1145                  for this objfile and pointing its symbol entries
1146                  to the current end of the symbol areas in the objfile.
1147
1148                  The "ldsymoff" parameter is the byte offset in the LNTT
1149                  of the first symbol in this file.  Some day we should
1150                  turn this into an index (fix in hp-symtab-read.c as well).
1151                  And it's not even the right byte offset, as we're using
1152                  the size of a union! FIXME!  */
1153               pst = hpread_start_psymtab (objfile,
1154                                           full_name_string,
1155                                           start_adr,    /* Low text address */
1156                               (start_sym * sizeof (struct dntt_type_block)),
1157               /* ldsymoff */
1158                                           global_syms,
1159                                           static_syms);
1160
1161               /* Set up to only enter each class referenced in this module once.  */
1162               class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries));
1163               B_CLRALL (class_entered, pxdb_header_p->cd_entries);
1164
1165               /* Scan the procedure descriptors for procedures in the current
1166                  file, based on the starting addresses. */
1167
1168               syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1169                                         start_adr, end_adr, pst, vt_bits, objfile);
1170
1171               /* Get ending symbol offset */
1172
1173               end_sym = 0;
1174               /* First check for starting index before previous psymtab */
1175               if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end)
1176                 {
1177                   end_sym = find_next_pst_start (start_sym);
1178                 }
1179               /* Look for next start index of a file or module, or procedure */
1180               if (!end_sym)
1181                 {
1182                   int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
1183                   int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md, pxdb_header_p);
1184                   int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
1185
1186                   if (next_file_isym && next_module_isym)
1187                     {
1188                       /* pick lower of next file or module start index */
1189                       end_sym = min (next_file_isym, next_module_isym);
1190                     }
1191                   else
1192                     {
1193                       /* one of them is zero, pick the other */
1194                       end_sym = max (next_file_isym, next_module_isym);
1195                     }
1196
1197                   /* As a precaution, check next procedure index too */
1198                   if (!end_sym)
1199                     end_sym = next_proc_isym;
1200                   else
1201                     end_sym = min (end_sym, next_proc_isym);
1202                 }
1203
1204               /* Couldn't find procedure, file, or module, use globals as default */
1205               if (!end_sym)
1206                 end_sym = pxdb_header_p->globals;
1207
1208 #ifdef DUMPING
1209               if (dumping)
1210                 {
1211                   printf ("File psymtab indices: %x to %x\n", start_sym, end_sym);
1212                 }
1213 #endif
1214
1215               pst = hpread_end_psymtab (pst,
1216                                         NULL,   /* psymtab_include_list */
1217                                         0,      /* includes_used        */
1218                                   end_sym * sizeof (struct dntt_type_block),
1219               /* byte index in LNTT of end
1220                  = capping symbol offset
1221                  = LDSYMOFF of nextfile */
1222                                         end_adr,        /* text high */
1223                                         NULL,   /* dependency_list */
1224                                         0);     /* dependencies_used */
1225
1226               record_pst_syms (start_sym, end_sym);
1227
1228               if (NULL == pst)
1229                 warning (_("No symbols in psymtab for file \"%s\" [0x%x]."), full_name_string, curr_fd);
1230
1231 #ifdef DUMPING
1232               if (dumping)
1233                 {
1234                   printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n",
1235                           full_name_string, start_adr, end_adr, CURR_FILE_ISYM, end_sym);
1236                 }
1237 #endif
1238               /* Prepare for the next psymtab. */
1239               global_syms = objfile->global_psymbols.next;
1240               static_syms = objfile->static_psymbols.next;
1241               xfree (class_entered);
1242
1243               curr_fd++;
1244             }                   /* Psymtab for file */
1245           else
1246             {
1247               /* We have a module for which we create a psymtab */
1248
1249               mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
1250
1251               /* We will include the code ranges of any files that happen to
1252                  overlap with this module */
1253
1254               /* So, first pick the lower of the file's and module's start addresses */
1255               start_adr = CURR_MODULE_START;
1256               if (VALID_CURR_FILE)
1257                 {
1258                   if (CURR_FILE_START < CURR_MODULE_START)
1259                     {
1260                       TELL_OBJFILE;
1261                       warning (_("File \"%s\" [0x%x] crosses beginning of module \"%s\"."),
1262                                &vt_bits[(long) qFD[curr_fd].sbFile],
1263                                curr_fd, mod_name_string);
1264
1265                       start_adr = CURR_FILE_START;
1266                     }
1267                 }
1268
1269               /* Also pick the lower of the file's and the module's start symbol indices */
1270               start_sym = CURR_MODULE_ISYM;
1271               if (VALID_CURR_FILE && (CURR_FILE_ISYM < CURR_MODULE_ISYM))
1272                 start_sym = CURR_FILE_ISYM;
1273
1274               /* For the end address, we scan through the files till we find one
1275                  that overlaps the current module but ends beyond it; if no such file exists we
1276                  simply use the module's start address.
1277                  (Note, if file entries themselves overlap
1278                  we take the longest overlapping extension beyond the end of the module...)
1279                  We assume that modules never overlap. */
1280
1281               end_adr = CURR_MODULE_END;
1282
1283               if (VALID_CURR_FILE)
1284                 {
1285                   while (VALID_CURR_FILE && (CURR_FILE_START < end_adr))
1286                     {
1287
1288 #ifdef DUMPING
1289                       if (dumping)
1290                         printf ("Maybe skipping file %s which overlaps with module %s\n",
1291                                 &vt_bits[(long) qFD[curr_fd].sbFile], mod_name_string);
1292 #endif
1293                       if (CURR_FILE_END > end_adr)
1294                         {
1295                           TELL_OBJFILE;
1296                           warning (_("File \"%s\" [0x%x] crosses end of module \"%s\"."),
1297                                    &vt_bits[(long) qFD[curr_fd].sbFile],
1298                                    curr_fd, mod_name_string);
1299                           end_adr = CURR_FILE_END;
1300                         }
1301                       curr_fd++;
1302                     }
1303                   curr_fd--;    /* back up after going too far */
1304                 }
1305
1306               /* Sometimes (compiler bug -- COBOL) the module end address is higher
1307                  than the start address of the next module, so check for that and
1308                  adjust accordingly */
1309
1310               if (VALID_MODULE (curr_md + 1) && (MODULE_START (curr_md + 1) <= end_adr))
1311                 {
1312                   TELL_OBJFILE;
1313                   warning (_("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down."),
1314                            mod_name_string, curr_md);
1315                   end_adr = MODULE_START (curr_md + 1) - 1;     /* Is -4 (or -8 for 64-bit) better? */
1316                 }
1317               if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr))
1318                 {
1319                   TELL_OBJFILE;
1320                   warning (_("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down."),
1321                            mod_name_string, curr_md);
1322                   end_adr = FILE_START (curr_fd + 1) - 1;       /* Is -4 (or -8 for 64-bit) better? */
1323                 }
1324
1325               /* Use one file to get the full name for the module.  This
1326                  situation can arise if there is executable code in a #include
1327                  file.  Each file with code in it gets a qFD.  Files which don't
1328                  contribute code don't get a qFD, even if they include files
1329                  which do, e.g.:
1330
1331                  body.c:                    rtn.h:
1332                  int x;                     int main() {
1333                  #include "rtn.h"               return x;
1334                  }
1335
1336                  There will a qFD for "rtn.h",and a qMD for "body.c",
1337                  but no qMD for "rtn.h" or qFD for "body.c"!
1338
1339                  We pick the name of the last file to overlap with this
1340                  module.  C convention is to put include files first.  In a
1341                  perfect world, we could check names and use the file whose full
1342                  path name ends with the module name. */
1343
1344               if (VALID_CURR_FILE)
1345                 full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile];
1346               else
1347                 full_name_string = mod_name_string;
1348
1349               /* Check if there are any procedures not handled until now, that
1350                  begin before the start address we have now, and if so, adjust
1351                  this psymtab's start address to include them.  This handles routines that
1352                  are in between file or module ranges for some reason (probably
1353                  indicates a compiler bug */
1354
1355               if (CURR_PROC_START < start_adr)
1356                 {
1357                   TELL_OBJFILE;
1358                   warning (_("Found procedure \"%s\" [0x%x] that is not in any file or module."),
1359                            &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
1360                   start_adr = CURR_PROC_START;
1361                   if (CURR_PROC_ISYM < start_sym)
1362                     start_sym = CURR_PROC_ISYM;
1363                 }
1364
1365 #ifdef DUMPING
1366               if (dumping)
1367                 {
1368                   printf ("Make new psymtab for module %s (%x to %x), using file %s\n",
1369                      mod_name_string, start_adr, end_adr, full_name_string);
1370                 }
1371 #endif
1372               /* Create the basic psymtab, connecting it in the list
1373                  for this objfile and pointing its symbol entries
1374                  to the current end of the symbol areas in the objfile.
1375
1376                  The "ldsymoff" parameter is the byte offset in the LNTT
1377                  of the first symbol in this file.  Some day we should
1378                  turn this into an index (fix in hp-symtab-read.c as well).
1379                  And it's not even the right byte offset, as we're using
1380                  the size of a union! FIXME!  */
1381               pst = hpread_start_psymtab (objfile,
1382                                           full_name_string,
1383                                           start_adr,    /* Low text address */
1384                               (start_sym * sizeof (struct dntt_type_block)),
1385               /* ldsymoff */
1386                                           global_syms,
1387                                           static_syms);
1388
1389               /* Set up to only enter each class referenced in this module once.  */
1390               class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries));
1391               B_CLRALL (class_entered, pxdb_header_p->cd_entries);
1392
1393               /* Scan the procedure descriptors for procedures in the current
1394                  module, based on the starting addresses. */
1395
1396               syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1397                                         start_adr, end_adr, pst, vt_bits, objfile);
1398
1399               /* Get ending symbol offset */
1400
1401               end_sym = 0;
1402               /* First check for starting index before previous psymtab */
1403               if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end)
1404                 {
1405                   end_sym = find_next_pst_start (start_sym);
1406                 }
1407               /* Look for next start index of a file or module, or procedure */
1408               if (!end_sym)
1409                 {
1410                   int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
1411                   int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md + 1, pxdb_header_p);
1412                   int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
1413
1414                   if (next_file_isym && next_module_isym)
1415                     {
1416                       /* pick lower of next file or module start index */
1417                       end_sym = min (next_file_isym, next_module_isym);
1418                     }
1419                   else
1420                     {
1421                       /* one of them is zero, pick the other */
1422                       end_sym = max (next_file_isym, next_module_isym);
1423                     }
1424
1425                   /* As a precaution, check next procedure index too */
1426                   if (!end_sym)
1427                     end_sym = next_proc_isym;
1428                   else
1429                     end_sym = min (end_sym, next_proc_isym);
1430                 }
1431
1432               /* Couldn't find procedure, file, or module, use globals as default */
1433               if (!end_sym)
1434                 end_sym = pxdb_header_p->globals;
1435
1436 #ifdef DUMPING
1437               if (dumping)
1438                 {
1439                   printf ("Module psymtab indices: %x to %x\n", start_sym, end_sym);
1440                 }
1441 #endif
1442
1443               pst = hpread_end_psymtab (pst,
1444                                         NULL,   /* psymtab_include_list */
1445                                         0,      /* includes_used        */
1446                                   end_sym * sizeof (struct dntt_type_block),
1447               /* byte index in LNTT of end
1448                  = capping symbol offset
1449                  = LDSYMOFF of nextfile */
1450                                         end_adr,        /* text high */
1451                                         NULL,   /* dependency_list      */
1452                                         0);     /* dependencies_used    */
1453
1454               record_pst_syms (start_sym, end_sym);
1455
1456               if (NULL == pst)
1457                 warning (_("No symbols in psymtab for module \"%s\" [0x%x]."), mod_name_string, curr_md);
1458
1459 #ifdef DUMPING
1460               if (dumping)
1461                 {
1462                   printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n",
1463                           mod_name_string, start_adr, end_adr, CURR_MODULE_ISYM, end_sym);
1464                 }
1465 #endif
1466
1467               /* Prepare for the next psymtab. */
1468               global_syms = objfile->global_psymbols.next;
1469               static_syms = objfile->static_psymbols.next;
1470               xfree (class_entered);
1471
1472               curr_md++;
1473               curr_fd++;
1474             }                   /* psymtab for module */
1475         }                       /* psymtab for non-bogus file or module */
1476     }                           /* End of while loop over all files & modules */
1477
1478   /* There may be some routines after all files and modules -- these will get
1479      inserted in a separate new module of their own */
1480   if (VALID_CURR_PROC)
1481     {
1482       start_adr = CURR_PROC_START;
1483       end_adr = qPD[pxdb_header_p->pd_entries - 1].adrEnd;
1484       TELL_OBJFILE;
1485       warning (_("Found functions beyond end of all files and modules [0x%x]."), curr_pd);
1486 #ifdef DUMPING
1487       if (dumping)
1488         {
1489           printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n",
1490                   curr_pd, start_adr, end_adr);
1491         }
1492 #endif
1493       pst = hpread_start_psymtab (objfile,
1494                                   "orphans",
1495                                   start_adr,    /* Low text address */
1496                          (CURR_PROC_ISYM * sizeof (struct dntt_type_block)),
1497       /* ldsymoff */
1498                                   global_syms,
1499                                   static_syms);
1500
1501       scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1502                   start_adr, end_adr, pst, vt_bits, objfile);
1503
1504       pst = hpread_end_psymtab (pst,
1505                                 NULL,   /* psymtab_include_list */
1506                                 0,      /* includes_used */
1507                    pxdb_header_p->globals * sizeof (struct dntt_type_block),
1508       /* byte index in LNTT of end
1509          = capping symbol offset
1510          = LDSYMOFF of nextfile */
1511                                 end_adr,        /* text high  */
1512                                 NULL,   /* dependency_list */
1513                                 0);     /* dependencies_used */
1514     }
1515
1516
1517 #ifdef NEVER_NEVER
1518   /* Now build psts for non-module things (in the tail of
1519      the LNTT, after the last END MODULE entry).
1520
1521      If null psts were kept on the chain, this would be
1522      a solution.  FIXME */
1523   pst = hpread_start_psymtab (objfile,
1524                               "globals",
1525                               0,
1526                               (pxdb_header_p->globals
1527                                * sizeof (struct dntt_type_block)),
1528                               objfile->global_psymbols.next,
1529                               objfile->static_psymbols.next);
1530   hpread_end_psymtab (pst,
1531                       NULL, 0,
1532                       (max_LNTT_sym_index * sizeof (struct dntt_type_block)),
1533                       0,
1534                       NULL, 0);
1535 #endif
1536
1537   clear_pst_syms ();
1538
1539   return 1;
1540
1541 }                               /* End of hpread_quick_traverse. */
1542 \f
1543
1544 /* Get appropriate header, based on pxdb type.
1545    Return value: 1 if ok, 0 if not */
1546 static int
1547 hpread_get_header (struct objfile *objfile, PXDB_header_ptr pxdb_header_p)
1548 {
1549   asection *pinfo_section, *debug_section, *header_section;
1550
1551 #ifdef DUMPING
1552   /* Turn on for debugging information */
1553   static int dumping = 0;
1554 #endif
1555
1556   header_section = bfd_get_section_by_name (objfile->obfd, "$HEADER$");
1557   if (!header_section)
1558     {
1559       /* We don't have either PINFO or DEBUG sections.  But
1560          stuff like "libc.sl" has no debug info.  There's no
1561          need to warn the user of this, as it may be ok. The
1562          caller will figure it out and issue any needed
1563          messages. */
1564 #ifdef DUMPING
1565       if (dumping)
1566         printf ("==No debug info at all for %s.\n", objfile->name);
1567 #endif
1568
1569       return 0;
1570     }
1571
1572   /* We would like either a $DEBUG$ or $PINFO$ section.
1573      Once we know which, we can understand the header
1574      data (which we have defined to suit the more common
1575      $DEBUG$ case). */
1576   debug_section = bfd_get_section_by_name (objfile->obfd, "$DEBUG$");
1577   pinfo_section = bfd_get_section_by_name (objfile->obfd, "$PINFO$");
1578   if (debug_section)
1579     {
1580       /* The expected case: normal pxdb header. */
1581       bfd_get_section_contents (objfile->obfd, header_section,
1582                                 pxdb_header_p, 0, sizeof (PXDB_header));
1583
1584       if (!pxdb_header_p->pxdbed)
1585         {
1586           /* This shouldn't happen if we check in "symfile.c". */
1587           return 0;
1588         }                       /* DEBUG section */
1589     }
1590
1591   else if (pinfo_section)
1592     {
1593       /* The DOC case; we need to translate this into a
1594          regular header. */
1595       DOC_info_PXDB_header doc_header;
1596
1597 #ifdef DUMPING
1598       if (dumping)
1599         {
1600           printf ("==OOps, PINFO, let's try to handle this, %s.\n", objfile->name);
1601         }
1602 #endif
1603
1604       bfd_get_section_contents (objfile->obfd,
1605                                 header_section,
1606                                 &doc_header, 0,
1607                                 sizeof (DOC_info_PXDB_header));
1608
1609       if (!doc_header.pxdbed)
1610         {
1611           /* This shouldn't happen if we check in "symfile.c". */
1612           warning (_("File \"%s\" not processed by pxdb!"), objfile->name);
1613           return 0;
1614         }
1615
1616       /* Copy relevent fields to standard header passed in. */
1617       pxdb_header_p->pd_entries = doc_header.pd_entries;
1618       pxdb_header_p->fd_entries = doc_header.fd_entries;
1619       pxdb_header_p->md_entries = doc_header.md_entries;
1620       pxdb_header_p->pxdbed = doc_header.pxdbed;
1621       pxdb_header_p->bighdr = doc_header.bighdr;
1622       pxdb_header_p->sa_header = doc_header.sa_header;
1623       pxdb_header_p->inlined = doc_header.inlined;
1624       pxdb_header_p->globals = doc_header.globals;
1625       pxdb_header_p->time = doc_header.time;
1626       pxdb_header_p->pg_entries = doc_header.pg_entries;
1627       pxdb_header_p->functions = doc_header.functions;
1628       pxdb_header_p->files = doc_header.files;
1629       pxdb_header_p->cd_entries = doc_header.cd_entries;
1630       pxdb_header_p->aa_entries = doc_header.aa_entries;
1631       pxdb_header_p->oi_entries = doc_header.oi_entries;
1632       pxdb_header_p->version = doc_header.version;
1633     }                           /* PINFO section */
1634
1635   else
1636     {
1637 #ifdef DUMPING
1638       if (dumping)
1639         printf ("==No debug info at all for %s.\n", objfile->name);
1640 #endif
1641
1642       return 0;
1643
1644     }
1645
1646   return 1;
1647 }                               /* End of hpread_get_header */
1648 #endif /* QUICK_LOOK_UP */
1649 \f
1650
1651 /* Initialization for reading native HP C debug symbols from OBJFILE.
1652
1653    Its only purpose in life is to set up the symbol reader's private
1654    per-objfile data structures, and read in the raw contents of the debug
1655    sections (attaching pointers to the debug info into the private data
1656    structures).
1657
1658    Since BFD doesn't know how to read debug symbols in a format-independent
1659    way (and may never do so...), we have to do it ourselves.  Note we may
1660    be called on a file without native HP C debugging symbols.
1661
1662    FIXME, there should be a cleaner peephole into the BFD environment
1663    here. */
1664 void
1665 hpread_symfile_init (struct objfile *objfile)
1666 {
1667   asection *vt_section, *slt_section, *lntt_section, *gntt_section;
1668
1669   /* Allocate struct to keep track of the symfile */
1670   objfile->deprecated_sym_private =
1671     xmalloc (sizeof (struct hpread_symfile_info));
1672   memset (objfile->deprecated_sym_private, 0, sizeof (struct hpread_symfile_info));
1673
1674   /* We haven't read in any types yet.  */
1675   DNTT_TYPE_VECTOR (objfile) = 0;
1676
1677   /* Read in data from the $GNTT$ subspace.  */
1678   gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$");
1679   if (!gntt_section)
1680     return;
1681
1682   GNTT (objfile)
1683     = obstack_alloc (&objfile->objfile_obstack,
1684                      bfd_section_size (objfile->obfd, gntt_section));
1685
1686   bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile),
1687                          0, bfd_section_size (objfile->obfd, gntt_section));
1688
1689   GNTT_SYMCOUNT (objfile)
1690     = bfd_section_size (objfile->obfd, gntt_section)
1691     / sizeof (struct dntt_type_block);
1692
1693   /* Read in data from the $LNTT$ subspace.   Also keep track of the number
1694      of LNTT symbols.
1695
1696      FIXME: this could be moved into the psymtab-to-symtab expansion
1697      code, and save startup time.  At the moment this data is
1698      still used, though.  We'd need a way to tell hp-symtab-read.c
1699      whether or not to load the LNTT. */
1700   lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$");
1701   if (!lntt_section)
1702     return;
1703
1704   LNTT (objfile)
1705     = obstack_alloc (&objfile->objfile_obstack,
1706                      bfd_section_size (objfile->obfd, lntt_section));
1707
1708   bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile),
1709                          0, bfd_section_size (objfile->obfd, lntt_section));
1710
1711   LNTT_SYMCOUNT (objfile)
1712     = bfd_section_size (objfile->obfd, lntt_section)
1713     / sizeof (struct dntt_type_block);
1714
1715   /* Read in data from the $SLT$ subspace.  $SLT$ contains information
1716      on source line numbers.  */
1717   slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$");
1718   if (!slt_section)
1719     return;
1720
1721   SLT (objfile) =
1722     obstack_alloc (&objfile->objfile_obstack,
1723                    bfd_section_size (objfile->obfd, slt_section));
1724
1725   bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile),
1726                           0, bfd_section_size (objfile->obfd, slt_section));
1727
1728   /* Read in data from the $VT$ subspace.  $VT$ contains things like
1729      names and constants.  Keep track of the number of symbols in the VT.  */
1730   vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$");
1731   if (!vt_section)
1732     return;
1733
1734   VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section);
1735
1736   VT (objfile) =
1737     (char *) obstack_alloc (&objfile->objfile_obstack,
1738                             VT_SIZE (objfile));
1739
1740   bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile),
1741                             0, VT_SIZE (objfile));
1742 }
1743
1744 /* Scan and build partial symbols for a symbol file.
1745
1746    The minimal symbol table (either SOM or HP a.out) has already been
1747    read in; all we need to do is setup partial symbols based on the
1748    native debugging information.
1749
1750    Note that the minimal table is produced by the linker, and has
1751    only global routines in it; the psymtab is based on compiler-
1752    generated debug information and has non-global
1753    routines in it as well as files and class information.
1754
1755    We assume hpread_symfile_init has been called to initialize the
1756    symbol reader's private data structures.
1757
1758    MAINLINE is true if we are reading the main symbol table (as
1759    opposed to a shared lib or dynamically loaded file). */
1760
1761 void
1762 hpread_build_psymtabs (struct objfile *objfile, int mainline)
1763 {
1764
1765 #ifdef DUMPING
1766   /* Turn this on to get debugging output. */
1767   static int dumping = 0;
1768 #endif
1769
1770   char *namestring;
1771   int past_first_source_file = 0;
1772   struct cleanup *old_chain;
1773
1774   int hp_symnum, symcount, i;
1775   int scan_start = 0;
1776
1777   union dnttentry *dn_bufp;
1778   unsigned long valu;
1779   char *p;
1780   int texthigh = 0;
1781   int have_name = 0;
1782
1783   /* Current partial symtab */
1784   struct partial_symtab *pst;
1785
1786   /* List of current psymtab's include files */
1787   char **psymtab_include_list;
1788   int includes_allocated;
1789   int includes_used;
1790
1791   /* Index within current psymtab dependency list */
1792   struct partial_symtab **dependency_list;
1793   int dependencies_used, dependencies_allocated;
1794
1795   /* Just in case the stabs reader left turds lying around.  */
1796   free_pending_blocks ();
1797   make_cleanup (really_free_pendings, 0);
1798
1799   pst = (struct partial_symtab *) 0;
1800
1801   /* We shouldn't use alloca, instead use malloc/free.  Doing so avoids
1802      a number of problems with cross compilation and creating useless holes
1803      in the stack when we have to allocate new entries.  FIXME.  */
1804
1805   includes_allocated = 30;
1806   includes_used = 0;
1807   psymtab_include_list = (char **) alloca (includes_allocated *
1808                                            sizeof (char *));
1809
1810   dependencies_allocated = 30;
1811   dependencies_used = 0;
1812   dependency_list =
1813     (struct partial_symtab **) alloca (dependencies_allocated *
1814                                        sizeof (struct partial_symtab *));
1815
1816   old_chain = make_cleanup_free_objfile (objfile);
1817
1818   last_source_file = 0;
1819
1820 #ifdef QUICK_LOOK_UP
1821   {
1822     /* Begin code for new-style loading of quick look-up tables. */
1823
1824     /* elz: this checks whether the file has beeen processed by pxdb.
1825        If not we would like to try to read the psymbols in
1826        anyway, but it turns out to be not so easy. So this could
1827        actually be commented out, but I leave it in, just in case
1828        we decide to add support for non-pxdb-ed stuff in the future. */
1829     PXDB_header pxdb_header;
1830     int found_modules_in_program;
1831
1832     if (hpread_get_header (objfile, &pxdb_header))
1833       {
1834         /* Build a minimal table.  No types, no global variables,
1835            no include files.... */
1836 #ifdef DUMPING
1837         if (dumping)
1838           printf ("\nNew method for %s\n", objfile->name);
1839 #endif
1840
1841         /* elz: quick_traverse returns true if it found
1842            some modules in the main source file, other
1843            than those in end.c
1844            In C and C++, all the files have MODULES entries
1845            in the LNTT, and the quick table traverse is all
1846            based on finding these MODULES entries. Without
1847            those it cannot work.
1848            It happens that F77 programs don't have MODULES
1849            so the quick traverse gets confused. F90 programs
1850            have modules, and the quick method still works.
1851            So, if modules (other than those in end.c) are
1852            not found we give up on the quick table stuff,
1853            and fall back on the slower method  */
1854         found_modules_in_program = hpread_quick_traverse (objfile,
1855                                                           GNTT (objfile),
1856                                                           VT (objfile),
1857                                                           &pxdb_header);
1858
1859         discard_cleanups (old_chain);
1860
1861         /* Set up to scan the global section of the LNTT.
1862
1863            This field is not always correct: if there are
1864            no globals, it will point to the last record in
1865            the regular LNTT, which is usually an END MODULE.
1866
1867            Since it might happen that there could be a file
1868            with just one global record, there's no way to
1869            tell other than by looking at the record, so that's
1870            done below. */
1871         if (found_modules_in_program)
1872           scan_start = pxdb_header.globals;
1873       }
1874 #ifdef DUMPING
1875     else
1876       {
1877         if (dumping)
1878           printf ("\nGoing on to old method for %s\n", objfile->name);
1879       }
1880 #endif
1881   }
1882 #endif /* QUICK_LOOK_UP */
1883
1884   /* Make two passes, one over the GNTT symbols, the other for the
1885      LNTT symbols.
1886
1887      JB comment: above isn't true--they only make one pass, over
1888      the LNTT.  */
1889   for (i = 0; i < 1; i++)
1890     {
1891       int within_function = 0;
1892
1893       if (i)
1894         symcount = GNTT_SYMCOUNT (objfile);
1895       else
1896         symcount = LNTT_SYMCOUNT (objfile);
1897
1898
1899       for (hp_symnum = scan_start; hp_symnum < symcount; hp_symnum++)
1900         {
1901           QUIT;
1902           if (i)
1903             dn_bufp = hpread_get_gntt (hp_symnum, objfile);
1904           else
1905             dn_bufp = hpread_get_lntt (hp_symnum, objfile);
1906
1907           if (dn_bufp->dblock.extension)
1908             continue;
1909
1910           /* Only handle things which are necessary for minimal symbols.
1911              everything else is ignored.  */
1912           switch (dn_bufp->dblock.kind)
1913             {
1914             case DNTT_TYPE_SRCFILE:
1915               {
1916 #ifdef QUICK_LOOK_UP
1917                 if (scan_start == hp_symnum
1918                     && symcount == hp_symnum + 1)
1919                   {
1920                     /* If there are NO globals in an executable,
1921                        PXDB's index to the globals will point to
1922                        the last record in the file, which
1923                        could be this record. (this happened for F77 libraries)
1924                        ignore it and be done! */
1925                     continue;
1926                   }
1927 #endif /* QUICK_LOOK_UP */
1928
1929                 /* A source file of some kind.  Note this may simply
1930                    be an included file.  */
1931                 set_namestring (dn_bufp, &namestring, objfile);
1932
1933                 /* Check if this is the source file we are already working
1934                    with.  */
1935                 if (pst && !strcmp (namestring, pst->filename))
1936                   continue;
1937
1938                 /* Check if this is an include file, if so check if we have
1939                    already seen it.  Add it to the include list */
1940                 p = strrchr (namestring, '.');
1941                 if (!strcmp (p, ".h"))
1942                   {
1943                     int j, found;
1944
1945                     found = 0;
1946                     for (j = 0; j < includes_used; j++)
1947                       if (!strcmp (namestring, psymtab_include_list[j]))
1948                         {
1949                           found = 1;
1950                           break;
1951                         }
1952                     if (found)
1953                       continue;
1954
1955                     /* Add it to the list of includes seen so far and
1956                        allocate more include space if necessary.  */
1957                     psymtab_include_list[includes_used++] = namestring;
1958                     if (includes_used >= includes_allocated)
1959                       {
1960                         char **orig = psymtab_include_list;
1961
1962                         psymtab_include_list = (char **)
1963                           alloca ((includes_allocated *= 2) *
1964                                   sizeof (char *));
1965                         memcpy (psymtab_include_list, orig,
1966                                 includes_used * sizeof (char *));
1967                       }
1968                     continue;
1969                   }
1970
1971                 if (pst)
1972                   {
1973                     if (!have_name)
1974                       {
1975                         pst->filename = (char *)
1976                           obstack_alloc (&pst->objfile->objfile_obstack,
1977                                          strlen (namestring) + 1);
1978                         strcpy (pst->filename, namestring);
1979                         have_name = 1;
1980                         continue;
1981                       }
1982                     continue;
1983                   }
1984
1985                 /* This is a bonafide new source file.
1986                    End the current partial symtab and start a new one.  */
1987
1988                 if (pst && past_first_source_file)
1989                   {
1990                     hpread_end_psymtab (pst, psymtab_include_list,
1991                                         includes_used,
1992                                         (hp_symnum
1993                                          * sizeof (struct dntt_type_block)),
1994                                         texthigh,
1995                                         dependency_list, dependencies_used);
1996                     pst = (struct partial_symtab *) 0;
1997                     includes_used = 0;
1998                     dependencies_used = 0;
1999                   }
2000                 else
2001                   past_first_source_file = 1;
2002
2003                 valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
2004                 valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2005                 pst = hpread_start_psymtab (objfile,
2006                                             namestring, valu,
2007                                             (hp_symnum
2008                                          * sizeof (struct dntt_type_block)),
2009                                             objfile->global_psymbols.next,
2010                                             objfile->static_psymbols.next);
2011                 texthigh = valu;
2012                 have_name = 1;
2013                 continue;
2014               }
2015
2016             case DNTT_TYPE_MODULE:
2017               /* A source file.  It's still unclear to me what the
2018                  real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
2019                  is supposed to be.  */
2020
2021               /* First end the previous psymtab */
2022               if (pst)
2023                 {
2024                   hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2025                                       ((hp_symnum - 1)
2026                                        * sizeof (struct dntt_type_block)),
2027                                       texthigh,
2028                                       dependency_list, dependencies_used);
2029                   pst = (struct partial_symtab *) 0;
2030                   includes_used = 0;
2031                   dependencies_used = 0;
2032                   have_name = 0;
2033                 }
2034
2035               /* Now begin a new module and a new psymtab for it */
2036               set_namestring (dn_bufp, &namestring, objfile);
2037               valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
2038               valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2039               if (!pst)
2040                 {
2041                   pst = hpread_start_psymtab (objfile,
2042                                               namestring, valu,
2043                                               (hp_symnum
2044                                          * sizeof (struct dntt_type_block)),
2045                                               objfile->global_psymbols.next,
2046                                               objfile->static_psymbols.next);
2047                   texthigh = valu;
2048                   have_name = 0;
2049                 }
2050               continue;
2051
2052             case DNTT_TYPE_FUNCTION:
2053             case DNTT_TYPE_ENTRY:
2054               /* The beginning of a function.  DNTT_TYPE_ENTRY may also denote
2055                  a secondary entry point.  */
2056               valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2057                                                        SECT_OFF_TEXT (objfile));
2058               if (valu > texthigh)
2059                 texthigh = valu;
2060               valu = dn_bufp->dfunc.lowaddr +
2061                 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2062               set_namestring (dn_bufp, &namestring, objfile);
2063               if (dn_bufp->dfunc.global)
2064                 add_psymbol_to_list (namestring, strlen (namestring),
2065                                      VAR_DOMAIN, LOC_BLOCK,
2066                                      &objfile->global_psymbols, valu,
2067                                      0, language_unknown, objfile);
2068               else
2069                 add_psymbol_to_list (namestring, strlen (namestring),
2070                                      VAR_DOMAIN, LOC_BLOCK,
2071                                      &objfile->static_psymbols, valu,
2072                                      0, language_unknown, objfile);
2073               within_function = 1;
2074               continue;
2075
2076             case DNTT_TYPE_DOC_FUNCTION:
2077               valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2078                                                           SECT_OFF_TEXT (objfile));
2079               if (valu > texthigh)
2080                 texthigh = valu;
2081               valu = dn_bufp->ddocfunc.lowaddr +
2082                 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2083               set_namestring (dn_bufp, &namestring, objfile);
2084               if (dn_bufp->ddocfunc.global)
2085                 add_psymbol_to_list (namestring, strlen (namestring),
2086                                      VAR_DOMAIN, LOC_BLOCK,
2087                                      &objfile->global_psymbols, valu,
2088                                      0, language_unknown, objfile);
2089               else
2090                 add_psymbol_to_list (namestring, strlen (namestring),
2091                                      VAR_DOMAIN, LOC_BLOCK,
2092                                      &objfile->static_psymbols, valu,
2093                                      0, language_unknown, objfile);
2094               within_function = 1;
2095               continue;
2096
2097             case DNTT_TYPE_BEGIN:
2098             case DNTT_TYPE_END:
2099               /* We don't check MODULE end here, because there can be
2100                  symbols beyond the module end which properly belong to the
2101                  current psymtab -- so we wait till the next MODULE start */
2102
2103
2104 #ifdef QUICK_LOOK_UP
2105               if (scan_start == hp_symnum
2106                   && symcount == hp_symnum + 1)
2107                 {
2108                   /* If there are NO globals in an executable,
2109                      PXDB's index to the globals will point to
2110                      the last record in the file, which is
2111                      probably an END MODULE, i.e. this record.
2112                      ignore it and be done! */
2113                   continue;
2114                 }
2115 #endif /* QUICK_LOOK_UP */
2116
2117               /* Scope block begin/end.  We only care about function
2118                  and file blocks right now.  */
2119
2120               if ((dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) ||
2121                   (dn_bufp->dend.endkind == DNTT_TYPE_DOC_FUNCTION))
2122                 within_function = 0;
2123               continue;
2124
2125             case DNTT_TYPE_SVAR:
2126             case DNTT_TYPE_DVAR:
2127             case DNTT_TYPE_TYPEDEF:
2128             case DNTT_TYPE_TAGDEF:
2129               {
2130                 /* Variables, typedefs an the like.  */
2131                 enum address_class storage;
2132                 domain_enum domain;
2133
2134                 /* Don't add locals to the partial symbol table.  */
2135                 if (within_function
2136                     && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR
2137                         || dn_bufp->dblock.kind == DNTT_TYPE_DVAR))
2138                   continue;
2139
2140                 /* TAGDEFs go into the structure domain.  */
2141                 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF)
2142                   domain = STRUCT_DOMAIN;
2143                 else
2144                   domain = VAR_DOMAIN;
2145
2146                 /* What kind of "storage" does this use?  */
2147                 if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR)
2148                   storage = LOC_STATIC;
2149                 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR
2150                          && dn_bufp->ddvar.regvar)
2151                   storage = LOC_REGISTER;
2152                 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR)
2153                   storage = LOC_LOCAL;
2154                 else
2155                   storage = LOC_UNDEF;
2156
2157                 set_namestring (dn_bufp, &namestring, objfile);
2158                 if (!pst)
2159                   {
2160                     pst = hpread_start_psymtab (objfile,
2161                                                 "globals", 0,
2162                                                 (hp_symnum
2163                                          * sizeof (struct dntt_type_block)),
2164                                               objfile->global_psymbols.next,
2165                                              objfile->static_psymbols.next);
2166                   }
2167
2168                 /* Compute address of the data symbol */
2169                 valu = dn_bufp->dsvar.location;
2170                 /* Relocate in case it's in a shared library */
2171                 if (storage == LOC_STATIC)
2172                   valu += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2173
2174                 /* Luckily, dvar, svar, typedef, and tagdef all
2175                    have their "global" bit in the same place, so it works
2176                    (though it's bad programming practice) to reference
2177                    "dsvar.global" even though we may be looking at
2178                    any of the above four types. */
2179                 if (dn_bufp->dsvar.global)
2180                   {
2181                     add_psymbol_to_list (namestring, strlen (namestring),
2182                                          domain, storage,
2183                                          &objfile->global_psymbols,
2184                                          valu,
2185                                          0, language_unknown, objfile);
2186                   }
2187                 else
2188                   {
2189                     add_psymbol_to_list (namestring, strlen (namestring),
2190                                          domain, storage,
2191                                          &objfile->static_psymbols,
2192                                          valu,
2193                                          0, language_unknown, objfile);
2194                   }
2195
2196                 /* For TAGDEF's, the above code added the tagname to the
2197                    struct domain. This will cause tag "t" to be found
2198                    on a reference of the form "(struct t) x". But for
2199                    C++ classes, "t" will also be a typename, which we
2200                    want to find on a reference of the form "ptype t".
2201                    Therefore, we also add "t" to the var domain.
2202                    Do the same for enum's due to the way aCC generates
2203                    debug info for these (see more extended comment
2204                    in hp-symtab-read.c).
2205                    We do the same for templates, so that "ptype t"
2206                    where "t" is a template also works. */
2207                 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF &&
2208                   dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
2209                   {
2210                     int global = dn_bufp->dtag.global;
2211                     /* Look ahead to see if it's a C++ class */
2212                     dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
2213                     if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
2214                         dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
2215                         dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
2216                       {
2217                         if (global)
2218                           {
2219                             add_psymbol_to_list (namestring, strlen (namestring),
2220                                                  VAR_DOMAIN, storage,
2221                                                  &objfile->global_psymbols,
2222                                                  dn_bufp->dsvar.location,
2223                                               0, language_unknown, objfile);
2224                           }
2225                         else
2226                           {
2227                             add_psymbol_to_list (namestring, strlen (namestring),
2228                                                  VAR_DOMAIN, storage,
2229                                                  &objfile->static_psymbols,
2230                                                  dn_bufp->dsvar.location,
2231                                               0, language_unknown, objfile);
2232                           }
2233                       }
2234                   }
2235               }
2236               continue;
2237
2238             case DNTT_TYPE_MEMENUM:
2239             case DNTT_TYPE_CONST:
2240               /* Constants and members of enumerated types.  */
2241               set_namestring (dn_bufp, &namestring, objfile);
2242               if (!pst)
2243                 {
2244                   pst = hpread_start_psymtab (objfile,
2245                                               "globals", 0,
2246                                               (hp_symnum
2247                                          * sizeof (struct dntt_type_block)),
2248                                               objfile->global_psymbols.next,
2249                                               objfile->static_psymbols.next);
2250                 }
2251               if (dn_bufp->dconst.global)
2252                 add_psymbol_to_list (namestring, strlen (namestring),
2253                                      VAR_DOMAIN, LOC_CONST,
2254                                      &objfile->global_psymbols, 0,
2255                                      0, language_unknown, objfile);
2256               else
2257                 add_psymbol_to_list (namestring, strlen (namestring),
2258                                      VAR_DOMAIN, LOC_CONST,
2259                                      &objfile->static_psymbols, 0,
2260                                      0, language_unknown, objfile);
2261               continue;
2262             default:
2263               continue;
2264             }
2265         }
2266     }
2267
2268   /* End any pending partial symbol table. */
2269   if (pst)
2270     {
2271       hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2272                           hp_symnum * sizeof (struct dntt_type_block),
2273                           0, dependency_list, dependencies_used);
2274     }
2275
2276   discard_cleanups (old_chain);
2277 }
2278
2279 /* Perform any local cleanups required when we are done with a particular
2280    objfile.  I.E, we are in the process of discarding all symbol information
2281    for an objfile, freeing up all memory held for it, and unlinking the
2282    objfile struct from the global list of known objfiles. */
2283
2284 void
2285 hpread_symfile_finish (struct objfile *objfile)
2286 {
2287   if (objfile->deprecated_sym_private != NULL)
2288     {
2289       xfree (objfile->deprecated_sym_private);
2290     }
2291 }
2292 \f
2293
2294 /* The remaining functions are all for internal use only.  */
2295
2296 /* Various small functions to get entries in the debug symbol sections.  */
2297
2298 static union dnttentry *
2299 hpread_get_lntt (int index, struct objfile *objfile)
2300 {
2301   return (union dnttentry *)
2302     &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2303 }
2304
2305 static union dnttentry *
2306 hpread_get_gntt (int index, struct objfile *objfile)
2307 {
2308   return (union dnttentry *)
2309     &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2310 }
2311
2312 static union sltentry *
2313 hpread_get_slt (int index, struct objfile *objfile)
2314 {
2315   return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]);
2316 }
2317
2318 /* Get the low address associated with some symbol (typically the start
2319    of a particular source file or module).  Since that information is not
2320    stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we
2321    must infer it from the existence of DNTT_TYPE_FUNCTION symbols.  */
2322
2323 static unsigned long
2324 hpread_get_textlow (int global, int index, struct objfile *objfile,
2325                     int symcount)
2326 {
2327   union dnttentry *dn_bufp = NULL;
2328   struct minimal_symbol *msymbol;
2329
2330   /* Look for a DNTT_TYPE_FUNCTION symbol.  */
2331   if (index < symcount)         /* symcount is the number of symbols in */
2332     {                           /*   the dbinfo, LNTT table */
2333       do
2334         {
2335           if (global)
2336             dn_bufp = hpread_get_gntt (index++, objfile);
2337           else
2338             dn_bufp = hpread_get_lntt (index++, objfile);
2339         }
2340       while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION
2341              && dn_bufp->dblock.kind != DNTT_TYPE_DOC_FUNCTION
2342              && dn_bufp->dblock.kind != DNTT_TYPE_END
2343              && index < symcount);
2344     }
2345
2346   /* NOTE: cagney/2003-03-29: If !(index < symcount), dn_bufp is left
2347      undefined and that means that the test below is using a garbage
2348      pointer from the stack.  */
2349   gdb_assert (dn_bufp != NULL);
2350
2351   /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION.  This
2352      might happen when a sourcefile has no functions.  */
2353   if (dn_bufp->dblock.kind == DNTT_TYPE_END)
2354     return 0;
2355
2356   /* Avoid going past the end of the LNTT file */
2357   if (index == symcount)
2358     return 0;
2359
2360   /* The minimal symbols are typically more accurate for some reason.  */
2361   if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION)
2362     msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL,
2363                                      objfile);
2364   else                          /* must be a DNTT_TYPE_DOC_FUNCTION */
2365     msymbol = lookup_minimal_symbol (dn_bufp->ddocfunc.name + VT (objfile), NULL,
2366                                      objfile);
2367
2368   if (msymbol)
2369     return SYMBOL_VALUE_ADDRESS (msymbol);
2370   else
2371     return dn_bufp->dfunc.lowaddr;
2372 }
2373
2374 /* Allocate and partially fill a partial symtab.  It will be
2375    completely filled at the end of the symbol list.
2376
2377    SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2378    is the address relative to which its symbols are (incremental) or 0
2379    (normal). */
2380
2381 static struct partial_symtab *
2382 hpread_start_psymtab (struct objfile *objfile, char *filename,
2383                       CORE_ADDR textlow, int ldsymoff,
2384                       struct partial_symbol **global_syms,
2385                       struct partial_symbol **static_syms)
2386 {
2387   int offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2388   extern void hpread_psymtab_to_symtab ();
2389   struct partial_symtab *result =
2390   start_psymtab_common (objfile, objfile->section_offsets,
2391                         filename, textlow, global_syms, static_syms);
2392
2393   result->textlow += offset;
2394   result->read_symtab_private = (char *)
2395     obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc));
2396   LDSYMOFF (result) = ldsymoff;
2397   result->read_symtab = hpread_psymtab_to_symtab;
2398
2399   return result;
2400 }
2401 \f
2402
2403 /* Close off the current usage of PST.
2404    Returns PST or NULL if the partial symtab was empty and thrown away.
2405
2406    capping_symbol_offset  --Byte index in LNTT or GNTT of the
2407    last symbol processed during the build
2408    of the previous pst.
2409
2410    FIXME:  List variables and peculiarities of same.  */
2411
2412 static struct partial_symtab *
2413 hpread_end_psymtab (struct partial_symtab *pst, char **include_list,
2414                     int num_includes, int capping_symbol_offset,
2415                     CORE_ADDR capping_text,
2416                     struct partial_symtab **dependency_list,
2417                     int number_dependencies)
2418 {
2419   int i;
2420   struct objfile *objfile = pst->objfile;
2421   int offset = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile));
2422
2423 #ifdef DUMPING
2424   /* Turn on to see what kind of a psymtab we've built. */
2425   static int dumping = 0;
2426 #endif
2427
2428   if (capping_symbol_offset != -1)
2429     LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
2430   else
2431     LDSYMLEN (pst) = 0;
2432   pst->texthigh = capping_text + offset;
2433
2434   pst->n_global_syms =
2435     objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
2436   pst->n_static_syms =
2437     objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
2438
2439 #ifdef DUMPING
2440   if (dumping)
2441     {
2442       printf ("\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n",
2443               pst->filename,
2444               LDSYMOFF (pst),
2445               LDSYMOFF (pst) / sizeof (struct dntt_type_block),
2446               LDSYMLEN (pst),
2447               LDSYMLEN (pst) / sizeof (struct dntt_type_block),
2448               pst->n_global_syms, pst->n_static_syms);
2449     }
2450 #endif
2451
2452   pst->number_of_dependencies = number_dependencies;
2453   if (number_dependencies)
2454     {
2455       pst->dependencies = (struct partial_symtab **)
2456         obstack_alloc (&objfile->objfile_obstack,
2457                     number_dependencies * sizeof (struct partial_symtab *));
2458       memcpy (pst->dependencies, dependency_list,
2459               number_dependencies * sizeof (struct partial_symtab *));
2460     }
2461   else
2462     pst->dependencies = 0;
2463
2464   for (i = 0; i < num_includes; i++)
2465     {
2466       struct partial_symtab *subpst =
2467       allocate_psymtab (include_list[i], objfile);
2468
2469       subpst->section_offsets = pst->section_offsets;
2470       subpst->read_symtab_private =
2471         (char *) obstack_alloc (&objfile->objfile_obstack,
2472                                 sizeof (struct symloc));
2473       LDSYMOFF (subpst) =
2474         LDSYMLEN (subpst) =
2475         subpst->textlow =
2476         subpst->texthigh = 0;
2477
2478       /* We could save slight bits of space by only making one of these,
2479          shared by the entire set of include files.  FIXME-someday.  */
2480       subpst->dependencies = (struct partial_symtab **)
2481         obstack_alloc (&objfile->objfile_obstack,
2482                        sizeof (struct partial_symtab *));
2483       subpst->dependencies[0] = pst;
2484       subpst->number_of_dependencies = 1;
2485
2486       subpst->globals_offset =
2487         subpst->n_global_syms =
2488         subpst->statics_offset =
2489         subpst->n_static_syms = 0;
2490
2491       subpst->readin = 0;
2492       subpst->symtab = 0;
2493       subpst->read_symtab = pst->read_symtab;
2494     }
2495
2496   sort_pst_symbols (pst);
2497
2498   /* If there is already a psymtab or symtab for a file of this name, remove it.
2499      (If there is a symtab, more drastic things also happen.)
2500      This happens in VxWorks.  */
2501   free_named_symtabs (pst->filename);
2502
2503   if (num_includes == 0
2504       && number_dependencies == 0
2505       && pst->n_global_syms == 0
2506       && pst->n_static_syms == 0)
2507     {
2508       /* Throw away this psymtab, it's empty.  We can't deallocate it, since
2509          it is on the obstack, but we can forget to chain it on the list.
2510          Empty psymtabs happen as a result of header files which don't have
2511          any symbols in them.  There can be a lot of them.  But this check
2512          is wrong, in that a psymtab with N_SLINE entries but nothing else
2513          is not empty, but we don't realize that.  Fixing that without slowing
2514          things down might be tricky.
2515          It's also wrong if we're using the quick look-up tables, as
2516          we can get empty psymtabs from modules with no routines in
2517          them. */
2518
2519       discard_psymtab (pst);
2520
2521       /* Indicate that psymtab was thrown away.  */
2522       pst = (struct partial_symtab *) NULL;
2523
2524     }
2525   return pst;
2526 }
2527
2528 \f
2529 /* Get the nesting depth for the source line identified by INDEX.  */
2530
2531 static unsigned long
2532 hpread_get_scope_start (sltpointer index, struct objfile *objfile)
2533 {
2534   union sltentry *sl_bufp;
2535
2536   sl_bufp = hpread_get_slt (index, objfile);
2537   return sl_bufp->sspec.backptr.dnttp.index;
2538 }
2539
2540 /* Get the source line number the the line identified by INDEX.  */
2541
2542 static unsigned long
2543 hpread_get_line (sltpointer index, struct objfile *objfile)
2544 {
2545   union sltentry *sl_bufp;
2546
2547   sl_bufp = hpread_get_slt (index, objfile);
2548   return sl_bufp->snorm.line;
2549 }
2550
2551 /* Find the code address associated with a given sltpointer */
2552
2553 static CORE_ADDR
2554 hpread_get_location (sltpointer index, struct objfile *objfile)
2555 {
2556   union sltentry *sl_bufp;
2557   int i;
2558
2559   /* code location of special sltentrys is determined from context */
2560   sl_bufp = hpread_get_slt (index, objfile);
2561
2562   if (sl_bufp->snorm.sltdesc == SLT_END)
2563     {
2564       /* find previous normal sltentry and get address */
2565       for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
2566                    (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
2567                    (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
2568         sl_bufp = hpread_get_slt (index - i, objfile);
2569       if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
2570         return sl_bufp->snormoff.address;
2571       else
2572         return sl_bufp->snorm.address;
2573     }
2574
2575   /* find next normal sltentry and get address */
2576   for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
2577                (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
2578                (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
2579     sl_bufp = hpread_get_slt (index + i, objfile);
2580   if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
2581     return sl_bufp->snormoff.address;
2582   else
2583     return sl_bufp->snorm.address;
2584 }
2585 \f
2586
2587 /* Return 1 if an HP debug symbol of type KIND has a name associated with
2588  * it, else return 0. (This function is not currently used, but I'll
2589  * leave it here in case it proves useful later on. - RT).
2590  */
2591
2592 static int
2593 hpread_has_name (enum dntt_entry_type kind)
2594 {
2595   switch (kind)
2596     {
2597     case DNTT_TYPE_SRCFILE:
2598     case DNTT_TYPE_MODULE:
2599     case DNTT_TYPE_FUNCTION:
2600     case DNTT_TYPE_DOC_FUNCTION:
2601     case DNTT_TYPE_ENTRY:
2602     case DNTT_TYPE_IMPORT:
2603     case DNTT_TYPE_LABEL:
2604     case DNTT_TYPE_FPARAM:
2605     case DNTT_TYPE_SVAR:
2606     case DNTT_TYPE_DVAR:
2607     case DNTT_TYPE_CONST:
2608     case DNTT_TYPE_TYPEDEF:
2609     case DNTT_TYPE_TAGDEF:
2610     case DNTT_TYPE_MEMENUM:
2611     case DNTT_TYPE_FIELD:
2612     case DNTT_TYPE_SA:
2613     case DNTT_TYPE_BLOCKDATA:
2614     case DNTT_TYPE_MEMFUNC:
2615     case DNTT_TYPE_DOC_MEMFUNC:
2616       return 1;
2617
2618     case DNTT_TYPE_BEGIN:
2619     case DNTT_TYPE_END:
2620     case DNTT_TYPE_POINTER:
2621     case DNTT_TYPE_ENUM:
2622     case DNTT_TYPE_SET:
2623     case DNTT_TYPE_ARRAY:
2624     case DNTT_TYPE_STRUCT:
2625     case DNTT_TYPE_UNION:
2626     case DNTT_TYPE_VARIANT:
2627     case DNTT_TYPE_FILE:
2628     case DNTT_TYPE_FUNCTYPE:
2629     case DNTT_TYPE_SUBRANGE:
2630     case DNTT_TYPE_WITH:
2631     case DNTT_TYPE_COMMON:
2632     case DNTT_TYPE_COBSTRUCT:
2633     case DNTT_TYPE_XREF:
2634     case DNTT_TYPE_MACRO:
2635     case DNTT_TYPE_CLASS_SCOPE:
2636     case DNTT_TYPE_REFERENCE:
2637     case DNTT_TYPE_PTRMEM:
2638     case DNTT_TYPE_PTRMEMFUNC:
2639     case DNTT_TYPE_CLASS:
2640     case DNTT_TYPE_GENFIELD:
2641     case DNTT_TYPE_VFUNC:
2642     case DNTT_TYPE_MEMACCESS:
2643     case DNTT_TYPE_INHERITANCE:
2644     case DNTT_TYPE_FRIEND_CLASS:
2645     case DNTT_TYPE_FRIEND_FUNC:
2646     case DNTT_TYPE_MODIFIER:
2647     case DNTT_TYPE_OBJECT_ID:
2648     case DNTT_TYPE_TEMPLATE:
2649     case DNTT_TYPE_TEMPLATE_ARG:
2650     case DNTT_TYPE_FUNC_TEMPLATE:
2651     case DNTT_TYPE_LINK:
2652       /* DNTT_TYPE_DYN_ARRAY_DESC ? */
2653       /* DNTT_TYPE_DESC_SUBRANGE ? */
2654       /* DNTT_TYPE_BEGIN_EXT ? */
2655       /* DNTT_TYPE_INLN ? */
2656       /* DNTT_TYPE_INLN_LIST ? */
2657       /* DNTT_TYPE_ALIAS ? */
2658     default:
2659       return 0;
2660     }
2661 }
2662
2663 /* Do the dirty work of reading in the full symbol from a partial symbol
2664    table.  */
2665
2666 static void
2667 hpread_psymtab_to_symtab_1 (struct partial_symtab *pst)
2668 {
2669   struct cleanup *old_chain;
2670   int i;
2671
2672   /* Get out quick if passed junk.  */
2673   if (!pst)
2674     return;
2675
2676   /* Complain if we've already read in this symbol table.  */
2677   if (pst->readin)
2678     {
2679       fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in."
2680                           "  Shouldn't happen.\n",
2681                           pst->filename);
2682       return;
2683     }
2684
2685   /* Read in all partial symtabs on which this one is dependent */
2686   for (i = 0; i < pst->number_of_dependencies; i++)
2687     if (!pst->dependencies[i]->readin)
2688       {
2689         /* Inform about additional files that need to be read in.  */
2690         if (info_verbose)
2691           {
2692             fputs_filtered (" ", gdb_stdout);
2693             wrap_here ("");
2694             fputs_filtered ("and ", gdb_stdout);
2695             wrap_here ("");
2696             printf_filtered ("%s...", pst->dependencies[i]->filename);
2697             wrap_here ("");     /* Flush output */
2698             gdb_flush (gdb_stdout);
2699           }
2700         hpread_psymtab_to_symtab_1 (pst->dependencies[i]);
2701       }
2702
2703   /* If it's real...  */
2704   if (LDSYMLEN (pst))
2705     {
2706       /* Init stuff necessary for reading in symbols */
2707       buildsym_init ();
2708       old_chain = make_cleanup (really_free_pendings, 0);
2709
2710       pst->symtab =
2711         hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst),
2712                               pst->textlow, pst->texthigh - pst->textlow,
2713                               pst->section_offsets, pst->filename);
2714
2715       do_cleanups (old_chain);
2716     }
2717
2718   pst->readin = 1;
2719 }
2720
2721 /* Read in all of the symbols for a given psymtab for real.
2722    Be verbose about it if the user wants that.  */
2723
2724 static void
2725 hpread_psymtab_to_symtab (struct partial_symtab *pst)
2726 {
2727   /* Get out quick if given junk.  */
2728   if (!pst)
2729     return;
2730
2731   /* Sanity check.  */
2732   if (pst->readin)
2733     {
2734       fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in."
2735                           "  Shouldn't happen.\n",
2736                           pst->filename);
2737       return;
2738     }
2739
2740   /* elz: setting the flag to indicate that the code of the target
2741      was compiled using an HP compiler (aCC, cc)
2742      the processing_acc_compilation variable is declared in the
2743      file buildsym.h, the HP_COMPILED_TARGET is defined to be equal
2744      to 3 in the file tm_hppa.h */
2745
2746   processing_gcc_compilation = 0;
2747
2748   if (LDSYMLEN (pst) || pst->number_of_dependencies)
2749     {
2750       /* Print the message now, before reading the string table,
2751          to avoid disconcerting pauses.  */
2752       if (info_verbose)
2753         {
2754           printf_filtered ("Reading in symbols for %s...", pst->filename);
2755           gdb_flush (gdb_stdout);
2756         }
2757
2758       hpread_psymtab_to_symtab_1 (pst);
2759
2760       /* Match with global symbols.  This only needs to be done once,
2761          after all of the symtabs and dependencies have been read in.   */
2762       scan_file_globals (pst->objfile);
2763
2764       /* Finish up the debug error message.  */
2765       if (info_verbose)
2766         printf_filtered ("done.\n");
2767     }
2768 }
2769
2770 /* Read in a defined section of a specific object file's symbols.
2771
2772    DESC is the file descriptor for the file, positioned at the
2773    beginning of the symtab
2774    SYM_OFFSET is the offset within the file of
2775    the beginning of the symbols we want to read
2776    SYM_SIZE is the size of the symbol info to read in.
2777    TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2778    TEXT_SIZE is the size of the text segment read in.
2779    SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
2780
2781 static struct symtab *
2782 hpread_expand_symtab (struct objfile *objfile, int sym_offset, int sym_size,
2783                       CORE_ADDR text_offset, int text_size,
2784                       struct section_offsets *section_offsets, char *filename)
2785 {
2786   char *namestring;
2787   union dnttentry *dn_bufp;
2788   unsigned max_symnum;
2789   int at_module_boundary = 0;
2790   /* 1 => at end, -1 => at beginning */
2791
2792   int sym_index = sym_offset / sizeof (struct dntt_type_block);
2793
2794   current_objfile = objfile;
2795   subfile_stack = 0;
2796
2797   last_source_file = 0;
2798
2799   /* Demangling style -- if EDG style already set, don't change it,
2800      as HP style causes some problems with the KAI EDG compiler */
2801   if (current_demangling_style != edg_demangling)
2802     {
2803       /* Otherwise, ensure that we are using HP style demangling */
2804       set_demangling_style (HP_DEMANGLING_STYLE_STRING);
2805     }
2806
2807   dn_bufp = hpread_get_lntt (sym_index, objfile);
2808   if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) ||
2809         (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE)))
2810     {
2811       start_symtab ("globals", NULL, 0);
2812       record_debugformat ("HP");
2813     }
2814
2815   /* The psymtab builder (hp-psymtab-read.c) is the one that
2816    * determined the "sym_size" argument (i.e. how many DNTT symbols
2817    * are in this symtab), which we use to compute "max_symnum"
2818    * (point in DNTT to which we read).
2819    *
2820    * Perhaps this should be changed so that
2821    * process_one_debug_symbol() "knows" when
2822    * to stop reading (based on reading from the MODULE to the matching
2823    * END), and take out this reliance on a #-syms being passed in...
2824    * (I'm worried about the reliability of this number). But I'll
2825    * leave it as-is, for now. - RT
2826    *
2827    * The change above has been made. I've left the "for" loop control
2828    * in to prepare for backing this out again. -JB
2829    */
2830   max_symnum = sym_size / sizeof (struct dntt_type_block);
2831   /* No reason to multiply on pst side and divide on sym side... FIXME */
2832
2833   /* Read in and process each debug symbol within the specified range.
2834    */
2835   for (symnum = 0;
2836        symnum < max_symnum;
2837        symnum++)
2838     {
2839       QUIT;                     /* Allow this to be interruptable */
2840       dn_bufp = hpread_get_lntt (sym_index + symnum, objfile);
2841
2842       if (dn_bufp->dblock.extension)
2843         continue;
2844
2845       /* Yow!  We call set_namestring on things without names!  */
2846       set_namestring (dn_bufp, &namestring, objfile);
2847
2848       hpread_process_one_debug_symbol (dn_bufp, namestring, section_offsets,
2849                                        objfile, text_offset, text_size,
2850                                        filename, symnum + sym_index,
2851                                        &at_module_boundary
2852         );
2853
2854       /* OLD COMMENTS: This routine is only called for psts.  All psts
2855        * correspond to MODULES.  If we ever do lazy-reading of globals
2856        * from the LNTT, then there will be a pst which ends when the
2857        * LNTT ends, and not at an END MODULE entry.  Then we'll have
2858        * to re-visit this break.
2859
2860        if( at_end_of_module )
2861        break;
2862
2863        */
2864
2865       /* We no longer break out of the loop when we reach the end of a
2866          module. The reason is that with CTTI, the compiler can generate
2867          function symbols (for template function instantiations) which are not
2868          in any module; typically they show up beyond a module's end, and
2869          before the next module's start.  We include them in the current
2870          module.  However, we still don't trust the MAX_SYMNUM value from
2871          the psymtab, so we break out if we enter a new module. */
2872
2873       if (at_module_boundary == -1)
2874         break;
2875     }
2876
2877   current_objfile = NULL;
2878   deprecated_hp_som_som_object_present = 1;     /* Indicate we've processed an HP SOM SOM file */
2879
2880   return end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
2881 }
2882 \f
2883
2884
2885
2886 /* Convert basic types from HP debug format into GDB internal format.  */
2887
2888 static int
2889 hpread_type_translate (dnttpointer typep)
2890 {
2891   if (!typep.dntti.immediate)
2892     {
2893       error (_("error in hpread_type_translate\n."));
2894       return FT_VOID;
2895     }
2896
2897   switch (typep.dntti.type)
2898     {
2899     case HP_TYPE_BOOLEAN:
2900     case HP_TYPE_BOOLEAN_S300_COMPAT:
2901     case HP_TYPE_BOOLEAN_VAX_COMPAT:
2902       return FT_BOOLEAN;
2903     case HP_TYPE_CHAR:          /* C signed char, C++ plain char */
2904
2905     case HP_TYPE_WIDE_CHAR:
2906       return FT_CHAR;
2907     case HP_TYPE_INT:
2908       if (typep.dntti.bitlength <= 8)
2909         return FT_SIGNED_CHAR;  /* C++ signed char */
2910       if (typep.dntti.bitlength <= 16)
2911         return FT_SHORT;
2912       if (typep.dntti.bitlength <= 32)
2913         return FT_INTEGER;
2914       return FT_LONG_LONG;
2915     case HP_TYPE_LONG:
2916       if (typep.dntti.bitlength <= 8)
2917         return FT_SIGNED_CHAR;  /* C++ signed char. */
2918       return FT_LONG;
2919     case HP_TYPE_UNSIGNED_LONG:
2920       if (typep.dntti.bitlength <= 8)
2921         return FT_UNSIGNED_CHAR;        /* C/C++ unsigned char */
2922       if (typep.dntti.bitlength <= 16)
2923         return FT_UNSIGNED_SHORT;
2924       if (typep.dntti.bitlength <= 32)
2925         return FT_UNSIGNED_LONG;
2926       return FT_UNSIGNED_LONG_LONG;
2927     case HP_TYPE_UNSIGNED_INT:
2928       if (typep.dntti.bitlength <= 8)
2929         return FT_UNSIGNED_CHAR;
2930       if (typep.dntti.bitlength <= 16)
2931         return FT_UNSIGNED_SHORT;
2932       if (typep.dntti.bitlength <= 32)
2933         return FT_UNSIGNED_INTEGER;
2934       return FT_UNSIGNED_LONG_LONG;
2935     case HP_TYPE_REAL:
2936     case HP_TYPE_REAL_3000:
2937     case HP_TYPE_DOUBLE:
2938       if (typep.dntti.bitlength == 64)
2939         return FT_DBL_PREC_FLOAT;
2940       if (typep.dntti.bitlength == 128)
2941         return FT_EXT_PREC_FLOAT;
2942       return FT_FLOAT;
2943     case HP_TYPE_COMPLEX:
2944     case HP_TYPE_COMPLEXS3000:
2945       if (typep.dntti.bitlength == 128)
2946         return FT_DBL_PREC_COMPLEX;
2947       if (typep.dntti.bitlength == 192)
2948         return FT_EXT_PREC_COMPLEX;
2949       return FT_COMPLEX;
2950     case HP_TYPE_VOID:
2951       return FT_VOID;
2952     case HP_TYPE_STRING200:
2953     case HP_TYPE_LONGSTRING200:
2954     case HP_TYPE_FTN_STRING_SPEC:
2955     case HP_TYPE_MOD_STRING_SPEC:
2956     case HP_TYPE_MOD_STRING_3000:
2957     case HP_TYPE_FTN_STRING_S300_COMPAT:
2958     case HP_TYPE_FTN_STRING_VAX_COMPAT:
2959       return FT_STRING;
2960     case HP_TYPE_TEMPLATE_ARG:
2961       return FT_TEMPLATE_ARG;
2962     case HP_TYPE_TEXT:
2963     case HP_TYPE_FLABEL:
2964     case HP_TYPE_PACKED_DECIMAL:
2965     case HP_TYPE_ANYPOINTER:
2966     case HP_TYPE_GLOBAL_ANYPOINTER:
2967     case HP_TYPE_LOCAL_ANYPOINTER:
2968     default:
2969       warning (_("hpread_type_translate: unhandled type code."));
2970       return FT_VOID;
2971     }
2972 }
2973
2974 /* Given a position in the DNTT, return a pointer to the
2975  * already-built "struct type" (if any), for the type defined
2976  * at that position.
2977  */
2978
2979 static struct type **
2980 hpread_lookup_type (dnttpointer hp_type, struct objfile *objfile)
2981 {
2982   unsigned old_len;
2983   int index = hp_type.dnttp.index;
2984   int size_changed = 0;
2985
2986   /* The immediate flag indicates this doesn't actually point to
2987    * a type DNTT.
2988    */
2989   if (hp_type.dntti.immediate)
2990     return NULL;
2991
2992   /* For each objfile, we maintain a "type vector".
2993    * This an array of "struct type *"'s with one pointer per DNTT index.
2994    * Given a DNTT index, we look in this array to see if we have
2995    * already processed this DNTT and if it is a type definition.
2996    * If so, then we can locate a pointer to the already-built
2997    * "struct type", and not build it again.
2998    *
2999    * The need for this arises because our DNTT-walking code wanders
3000    * around. In particular, it will encounter the same type multiple
3001    * times (once for each object of that type). We don't want to
3002    * built multiple "struct type"'s for the same thing.
3003    *
3004    * Having said this, I should point out that this type-vector is
3005    * an expensive way to keep track of this. If most DNTT entries are
3006    * 3 words, the type-vector will be 1/3 the size of the DNTT itself.
3007    * Alternative solutions:
3008    * - Keep a compressed or hashed table. Less memory, but more expensive
3009    *   to search and update.
3010    * - (Suggested by JB): Overwrite the DNTT entry itself
3011    *   with the info. Create a new type code "ALREADY_BUILT", and modify
3012    *   the DNTT to have that type code and point to the already-built entry.
3013    * -RT
3014    */
3015
3016   if (index < LNTT_SYMCOUNT (objfile))
3017     {
3018       if (index >= DNTT_TYPE_VECTOR_LENGTH (objfile))
3019         {
3020           old_len = DNTT_TYPE_VECTOR_LENGTH (objfile);
3021
3022           /* See if we need to allocate a type-vector. */
3023           if (old_len == 0)
3024             {
3025               DNTT_TYPE_VECTOR_LENGTH (objfile) = LNTT_SYMCOUNT (objfile) + GNTT_SYMCOUNT (objfile);
3026               DNTT_TYPE_VECTOR (objfile) = (struct type **)
3027                 xmalloc (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *));
3028               memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0,
3029                       (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) *
3030                       sizeof (struct type *));
3031             }
3032
3033           /* See if we need to resize type-vector. With my change to
3034            * initially allocate a correct-size type-vector, this code
3035            * should no longer trigger.
3036            */
3037           while (index >= DNTT_TYPE_VECTOR_LENGTH (objfile))
3038             {
3039               DNTT_TYPE_VECTOR_LENGTH (objfile) *= 2;
3040               size_changed = 1;
3041             }
3042           if (size_changed)
3043             {
3044               DNTT_TYPE_VECTOR (objfile) = (struct type **)
3045                 xrealloc ((char *) DNTT_TYPE_VECTOR (objfile),
3046                    (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
3047
3048               memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0,
3049                       (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) *
3050                       sizeof (struct type *));
3051             }
3052
3053         }
3054       return &DNTT_TYPE_VECTOR (objfile)[index];
3055     }
3056   else
3057     return NULL;
3058 }
3059
3060 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
3061    Note we'll just return the address of a GDB internal type if we already
3062    have it lying around.  */
3063
3064 static struct type *
3065 hpread_alloc_type (dnttpointer hp_type, struct objfile *objfile)
3066 {
3067   struct type **type_addr;
3068
3069   type_addr = hpread_lookup_type (hp_type, objfile);
3070   if (*type_addr == 0)
3071     {
3072       *type_addr = alloc_type (objfile);
3073
3074       /* A hack - if we really are a C++ class symbol, then this default
3075        * will get overriden later on.
3076        */
3077       TYPE_CPLUS_SPECIFIC (*type_addr)
3078         = (struct cplus_struct_type *) &cplus_struct_default;
3079     }
3080
3081   return *type_addr;
3082 }
3083
3084 /* Read a native enumerated type and return it in GDB internal form.  */
3085
3086 static struct type *
3087 hpread_read_enum_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3088                        struct objfile *objfile)
3089 {
3090   struct type *type;
3091   struct pending **symlist, *osyms, *syms;
3092   struct pending *local_list = NULL;
3093   int o_nsyms, nsyms = 0;
3094   dnttpointer mem;
3095   union dnttentry *memp;
3096   char *name;
3097   long n;
3098   struct symbol *sym;
3099
3100   /* Allocate a GDB type. If we've already read in this enum type,
3101    * it'll return the already built GDB type, so stop here.
3102    * (Note: I added this check, to conform with what's done for
3103    *  struct, union, class.
3104    *  I assume this is OK. - RT)
3105    */
3106   type = hpread_alloc_type (hp_type, objfile);
3107   if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3108     return type;
3109
3110   /* HP C supports "sized enums", where a specifier such as "short" or
3111      "char" can be used to get enums of different sizes. So don't assume
3112      an enum is always 4 bytes long. pai/1997-08-21 */
3113   TYPE_LENGTH (type) = dn_bufp->denum.bitlength / 8;
3114
3115   symlist = &file_symbols;
3116   osyms = *symlist;
3117   o_nsyms = osyms ? osyms->nsyms : 0;
3118
3119   /* Get a name for each member and add it to our list of members.
3120    * The list of "mem" SOM records we are walking should all be
3121    * SOM type DNTT_TYPE_MEMENUM (not checked).
3122    */
3123   mem = dn_bufp->denum.firstmem;
3124   while (mem.word && mem.word != DNTTNIL)
3125     {
3126       memp = hpread_get_lntt (mem.dnttp.index, objfile);
3127
3128       name = VT (objfile) + memp->dmember.name;
3129       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
3130                                              sizeof (struct symbol));
3131       memset (sym, 0, sizeof (struct symbol));
3132       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3133                                         &objfile->objfile_obstack);
3134       SYMBOL_CLASS (sym) = LOC_CONST;
3135       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3136       SYMBOL_VALUE (sym) = memp->dmember.value;
3137       add_symbol_to_list (sym, symlist);
3138       nsyms++;
3139       mem = memp->dmember.nextmem;
3140     }
3141
3142   /* Now that we know more about the enum, fill in more info.  */
3143   TYPE_CODE (type) = TYPE_CODE_ENUM;
3144   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3145   TYPE_NFIELDS (type) = nsyms;
3146   TYPE_FIELDS (type) = (struct field *)
3147     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nsyms);
3148
3149   /* Find the symbols for the members and put them into the type.
3150      The symbols can be found in the symlist that we put them on
3151      to cause them to be defined.  osyms contains the old value
3152      of that symlist; everything up to there was defined by us.
3153
3154      Note that we preserve the order of the enum constants, so
3155      that in something like "enum {FOO, LAST_THING=FOO}" we print
3156      FOO, not LAST_THING.  */
3157   for (syms = *symlist, n = 0; syms; syms = syms->next)
3158     {
3159       int j = 0;
3160       if (syms == osyms)
3161         j = o_nsyms;
3162       for (; j < syms->nsyms; j++, n++)
3163         {
3164           struct symbol *xsym = syms->symbol[j];
3165           SYMBOL_TYPE (xsym) = type;
3166           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3167           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3168           TYPE_FIELD_BITSIZE (type, n) = 0;
3169           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3170         }
3171       if (syms == osyms)
3172         break;
3173     }
3174
3175   return type;
3176 }
3177
3178 /* Read and internalize a native function debug symbol.  */
3179
3180 static struct type *
3181 hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3182                            struct objfile *objfile, int newblock)
3183 {
3184   struct type *type, *type1;
3185   struct pending *syms;
3186   struct pending *local_list = NULL;
3187   int nsyms = 0;
3188   dnttpointer param;
3189   union dnttentry *paramp;
3190   char *name;
3191   long n;
3192   struct symbol *sym;
3193   int record_args = 1;
3194
3195   /* See if we've already read in this type.  */
3196   type = hpread_alloc_type (hp_type, objfile);
3197   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3198     {
3199       record_args = 0;          /* already read in, don't modify type */
3200     }
3201   else
3202     {
3203       /* Nope, so read it in and store it away.  */
3204       if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3205           dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3206         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval,
3207                                                           objfile));
3208       else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3209         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval,
3210                                                           objfile));
3211       else                      /* expect DNTT_TYPE_FUNC_TEMPLATE */
3212         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval,
3213                                                           objfile));
3214       replace_type (type, type1);
3215
3216       /* Mark it -- in the middle of processing */
3217       TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3218     }
3219
3220   /* Now examine each parameter noting its type, location, and a
3221      wealth of other information.  */
3222   if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3223       dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3224     param = dn_bufp->dfunc.firstparam;
3225   else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3226     param = dn_bufp->dfunctype.firstparam;
3227   else                          /* expect DNTT_TYPE_FUNC_TEMPLATE */
3228     param = dn_bufp->dfunc_template.firstparam;
3229   while (param.word && param.word != DNTTNIL)
3230     {
3231       paramp = hpread_get_lntt (param.dnttp.index, objfile);
3232       nsyms++;
3233       param = paramp->dfparam.nextparam;
3234
3235       /* Get the name.  */
3236       name = VT (objfile) + paramp->dfparam.name;
3237       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
3238                                              sizeof (struct symbol));
3239       (void) memset (sym, 0, sizeof (struct symbol));
3240       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3241                                         &objfile->objfile_obstack);
3242
3243       /* Figure out where it lives.  */
3244       if (paramp->dfparam.regparam)
3245         SYMBOL_CLASS (sym) = LOC_REGPARM;
3246       else if (paramp->dfparam.indirect)
3247         SYMBOL_CLASS (sym) = LOC_REF_ARG;
3248       else
3249         SYMBOL_CLASS (sym) = LOC_ARG;
3250       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3251       if (paramp->dfparam.copyparam)
3252         {
3253           SYMBOL_VALUE (sym) = paramp->dfparam.location;
3254           SYMBOL_VALUE (sym)
3255             += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
3256
3257           /* This is likely a pass-by-invisible reference parameter,
3258              Hack on the symbol class to make GDB happy.  */
3259           /* ??rehrauer: This appears to be broken w/r/t to passing
3260              C values of type float and struct.  Perhaps this ought
3261              to be highighted as a special case, but for now, just
3262              allowing these to be LOC_ARGs seems to work fine.
3263            */
3264 #if 0
3265           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3266 #endif
3267         }
3268       else
3269         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3270
3271       /* Get its type.  */
3272       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3273       /* Add it to the symbol list.  */
3274       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3275        * called on FPARAM symbols from the process_one_debug_symbol()
3276        * level... so parameters are getting added twice! (this shows
3277        * up in the symbol dump you get from "maint print symbols ...").
3278        * Note 2 (RT) I took out the processing of FPARAM from the
3279        * process_one_debug_symbol() level, so at the moment parameters are only
3280        * being processed here. This seems to have no ill effect.
3281        */
3282       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3283          each fparam on the local_symbols list from here.  Now we use the
3284          local_list to which fparams are added below, and set the param_symbols
3285          global to point to that at the end of this routine. */
3286       /* elz: I added this new list of symbols which is local to the function.
3287          this list is the one which is actually used to build the type for the
3288          function rather than the gloabal list pointed to by symlist.
3289          Using a global list to keep track of the parameters is wrong, because
3290          this function is called recursively if one parameter happend to be
3291          a function itself with more parameters in it. Adding parameters to the
3292          same global symbol list would not work!
3293          Actually it did work in case of cc compiled programs where you do
3294          not check the parameter lists of the arguments. */
3295       add_symbol_to_list (sym, &local_list);
3296
3297     }
3298
3299   /* If type was read in earlier, don't bother with modifying
3300      the type struct */
3301   if (!record_args)
3302     goto finish;
3303
3304   /* Note how many parameters we found.  */
3305   TYPE_NFIELDS (type) = nsyms;
3306   TYPE_FIELDS (type) = (struct field *)
3307     obstack_alloc (&objfile->objfile_obstack,
3308                    sizeof (struct field) * nsyms);
3309
3310   /* Find the symbols for the parameters and
3311      use them to fill parameter-type information into the function-type.
3312      The parameter symbols can be found in the local_list that we just put them on. */
3313   /* Note that we preserve the order of the parameters, so
3314      that in something like "enum {FOO, LAST_THING=FOO}" we print
3315      FOO, not LAST_THING.  */
3316
3317   /* get the parameters types from the local list not the global list
3318      so that the type can be correctly constructed for functions which
3319      have function as parameters */
3320   for (syms = local_list, n = 0; syms; syms = syms->next)
3321     {
3322       int j = 0;
3323       for (j = 0; j < syms->nsyms; j++, n++)
3324         {
3325           struct symbol *xsym = syms->symbol[j];
3326           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3327           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3328           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3329           TYPE_FIELD_BITSIZE (type, n) = 0;
3330           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3331         }
3332     }
3333   /* Mark it as having been processed */
3334   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3335
3336   /* Check whether we need to fix-up a class type with this function's type */
3337   if (fixup_class && (fixup_method == type))
3338     {
3339       fixup_class_method_type (fixup_class, fixup_method, objfile);
3340       fixup_class = NULL;
3341       fixup_method = NULL;
3342     }
3343
3344   /* Set the param list of this level of the context stack
3345      to our local list.  Do this only if this function was
3346      called for creating a new block, and not if it was called
3347      simply to get the function type. This prevents recursive
3348      invocations from trashing param_symbols. */
3349 finish:
3350   if (newblock)
3351     param_symbols = local_list;
3352
3353   return type;
3354 }
3355
3356
3357 /* Read and internalize a native DOC function debug symbol.  */
3358 /* This is almost identical to hpread_read_function_type(), except
3359  * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3360  * Since debug information for DOC functions is more likely to be
3361  * volatile, please leave it this way.
3362  */
3363 static struct type *
3364 hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3365                                struct objfile *objfile, int newblock)
3366 {
3367   struct pending *syms;
3368   struct pending *local_list = NULL;
3369   int nsyms = 0;
3370   struct type *type;
3371   dnttpointer param;
3372   union dnttentry *paramp;
3373   char *name;
3374   long n;
3375   struct symbol *sym;
3376   int record_args = 1;
3377
3378   /* See if we've already read in this type.  */
3379   type = hpread_alloc_type (hp_type, objfile);
3380   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3381     {
3382       record_args = 0;          /* already read in, don't modify type */
3383     }
3384   else
3385     {
3386       struct type *type1 = NULL;
3387       /* Nope, so read it in and store it away.  */
3388       if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3389           dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3390         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval,
3391                                                           objfile));
3392       /* NOTE: cagney/2003-03-29: Oh, no not again.  TYPE1 is
3393          potentially left undefined here.  Assert it isn't and hope
3394          the assert never fails ...  */
3395       gdb_assert (type1 != NULL);
3396
3397       replace_type (type, type1);
3398
3399       /* Mark it -- in the middle of processing */
3400       TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3401     }
3402
3403   /* Now examine each parameter noting its type, location, and a
3404      wealth of other information.  */
3405   if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3406       dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3407     param = dn_bufp->ddocfunc.firstparam;
3408   while (param.word && param.word != DNTTNIL)
3409     {
3410       paramp = hpread_get_lntt (param.dnttp.index, objfile);
3411       nsyms++;
3412       param = paramp->dfparam.nextparam;
3413
3414       /* Get the name.  */
3415       name = VT (objfile) + paramp->dfparam.name;
3416       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
3417                                              sizeof (struct symbol));
3418       (void) memset (sym, 0, sizeof (struct symbol));
3419       DEPRECATED_SYMBOL_NAME (sym) = name;
3420
3421       /* Figure out where it lives.  */
3422       if (paramp->dfparam.regparam)
3423         SYMBOL_CLASS (sym) = LOC_REGPARM;
3424       else if (paramp->dfparam.indirect)
3425         SYMBOL_CLASS (sym) = LOC_REF_ARG;
3426       else
3427         SYMBOL_CLASS (sym) = LOC_ARG;
3428       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3429       if (paramp->dfparam.copyparam)
3430         {
3431           SYMBOL_VALUE (sym) = paramp->dfparam.location;
3432           SYMBOL_VALUE (sym)
3433             += hpread_adjust_stack_address(CURRENT_FUNCTION_VALUE (objfile));
3434
3435           /* This is likely a pass-by-invisible reference parameter,
3436              Hack on the symbol class to make GDB happy.  */
3437           /* ??rehrauer: This appears to be broken w/r/t to passing
3438              C values of type float and struct.  Perhaps this ought
3439              to be highighted as a special case, but for now, just
3440              allowing these to be LOC_ARGs seems to work fine.
3441            */
3442 #if 0
3443           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3444 #endif
3445         }
3446       else
3447         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3448
3449       /* Get its type.  */
3450       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3451       /* Add it to the symbol list.  */
3452       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3453        * called on FPARAM symbols from the process_one_debug_symbol()
3454        * level... so parameters are getting added twice! (this shows
3455        * up in the symbol dump you get from "maint print symbols ...").
3456        * Note 2 (RT) I took out the processing of FPARAM from the
3457        * process_one_debug_symbol() level, so at the moment parameters are only
3458        * being processed here. This seems to have no ill effect.
3459        */
3460       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3461          each fparam on the local_symbols list from here.  Now we use the
3462          local_list to which fparams are added below, and set the param_symbols
3463          global to point to that at the end of this routine. */
3464
3465       /* elz: I added this new list of symbols which is local to the function.
3466          this list is the one which is actually used to build the type for the
3467          function rather than the gloabal list pointed to by symlist.
3468          Using a global list to keep track of the parameters is wrong, because
3469          this function is called recursively if one parameter happend to be
3470          a function itself with more parameters in it. Adding parameters to the
3471          same global symbol list would not work!
3472          Actually it did work in case of cc compiled programs where you do not check the
3473          parameter lists of the arguments.  */
3474       add_symbol_to_list (sym, &local_list);
3475     }
3476
3477   /* If type was read in earlier, don't bother with modifying
3478      the type struct */
3479   if (!record_args)
3480     goto finish;
3481
3482   /* Note how many parameters we found.  */
3483   TYPE_NFIELDS (type) = nsyms;
3484   TYPE_FIELDS (type) = (struct field *)
3485     obstack_alloc (&objfile->objfile_obstack,
3486                    sizeof (struct field) * nsyms);
3487
3488   /* Find the symbols for the parameters and
3489      use them to fill parameter-type information into the function-type.
3490      The parameter symbols can be found in the local_list that we just put them on. */
3491   /* Note that we preserve the order of the parameters, so
3492      that in something like "enum {FOO, LAST_THING=FOO}" we print
3493      FOO, not LAST_THING.  */
3494
3495   /* get the parameters types from the local list not the global list
3496      so that the type can be correctly constructed for functions which
3497      have function as parameters
3498    */
3499   for (syms = local_list, n = 0; syms; syms = syms->next)
3500     {
3501       int j = 0;
3502       for (j = 0; j < syms->nsyms; j++, n++)
3503         {
3504           struct symbol *xsym = syms->symbol[j];
3505           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3506           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3507           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3508           TYPE_FIELD_BITSIZE (type, n) = 0;
3509           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3510         }
3511     }
3512
3513   /* Mark it as having been processed */
3514   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3515
3516   /* Check whether we need to fix-up a class type with this function's type */
3517   if (fixup_class && (fixup_method == type))
3518     {
3519       fixup_class_method_type (fixup_class, fixup_method, objfile);
3520       fixup_class = NULL;
3521       fixup_method = NULL;
3522     }
3523
3524   /* Set the param list of this level of the context stack
3525      to our local list.  Do this only if this function was
3526      called for creating a new block, and not if it was called
3527      simply to get the function type. This prevents recursive
3528      invocations from trashing param_symbols. */
3529 finish:
3530   if (newblock)
3531     param_symbols = local_list;
3532
3533   return type;
3534 }
3535
3536
3537
3538 /* A file-level variable which keeps track of the current-template
3539  * being processed. Set in hpread_read_struct_type() while processing
3540  * a template type. Referred to in hpread_get_nth_templ_arg().
3541  * Yes, this is a kludge, but it arises from the kludge that already
3542  * exists in symtab.h, namely the fact that they encode
3543  * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3544  * bitlength n. This means that deep in processing fundamental types
3545  * I need to ask the question "what template am I in the middle of?".
3546  * The alternative to stuffing a global would be to pass an argument
3547  * down the chain of calls just for this purpose.
3548  *
3549  * There may be problems handling nested templates... tough.
3550  */
3551 static struct type *current_template = NULL;
3552
3553 /* Read in and internalize a structure definition.
3554  * This same routine is called for struct, union, and class types.
3555  * Also called for templates, since they build a very similar
3556  * type entry as for class types.
3557  */
3558
3559 static struct type *
3560 hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3561                          struct objfile *objfile)
3562 {
3563   /* The data members get linked together into a list of struct nextfield's */
3564   struct nextfield
3565     {
3566       struct nextfield *next;
3567       struct field field;
3568       unsigned char attributes; /* store visibility and virtuality info */
3569 #define ATTR_VIRTUAL 1
3570 #define ATTR_PRIVATE 2
3571 #define ATTR_PROTECT 3
3572     };
3573
3574
3575   /* The methods get linked together into a list of struct next_fn_field's */
3576   struct next_fn_field
3577     {
3578       struct next_fn_field *next;
3579       struct fn_fieldlist field;
3580       struct fn_field fn_field;
3581       int num_fn_fields;
3582     };
3583
3584   /* The template args get linked together into a list of struct next_template's */
3585   struct next_template
3586     {
3587       struct next_template *next;
3588       struct template_arg arg;
3589     };
3590
3591   /* The template instantiations get linked together into a list of these... */
3592   struct next_instantiation
3593     {
3594       struct next_instantiation *next;
3595       struct type *t;
3596     };
3597
3598   struct type *type;
3599   struct type *baseclass;
3600   struct type *memtype;
3601   struct nextfield *list = 0, *tmp_list = 0;
3602   struct next_fn_field *fn_list = 0;
3603   struct next_fn_field *fn_p;
3604   struct next_template *t_new, *t_list = 0;
3605   struct nextfield *new;
3606   struct next_fn_field *fn_new;
3607   struct next_instantiation *i_new, *i_list = 0;
3608   int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0;
3609   int n_base_classes = 0, n_templ_args = 0;
3610   int ninstantiations = 0;
3611   dnttpointer field, fn_field, parent;
3612   union dnttentry *fieldp, *fn_fieldp, *parentp;
3613   int i;
3614   int static_member = 0;
3615   int const_member = 0;
3616   int volatile_member = 0;
3617   unsigned long vtbl_offset;
3618   int need_bitvectors = 0;
3619   char *method_name = NULL;
3620   char *method_alias = NULL;
3621
3622
3623   /* Is it something we've already dealt with?  */
3624   type = hpread_alloc_type (hp_type, objfile);
3625   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
3626       (TYPE_CODE (type) == TYPE_CODE_UNION) ||
3627       (TYPE_CODE (type) == TYPE_CODE_CLASS) ||
3628       (TYPE_CODE (type) == TYPE_CODE_TEMPLATE))
3629     return type;
3630
3631   /* Get the basic type correct.  */
3632   if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3633     {
3634       TYPE_CODE (type) = TYPE_CODE_STRUCT;
3635       TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
3636     }
3637   else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3638     {
3639       TYPE_CODE (type) = TYPE_CODE_UNION;
3640       TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
3641     }
3642   else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3643     {
3644       TYPE_CODE (type) = TYPE_CODE_CLASS;
3645       TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8;
3646
3647       /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3648        * rather than &cplus_struct_default.
3649        */
3650       allocate_cplus_struct_type (type);
3651
3652       /* Fill in declared-type.
3653        * (The C++ compiler will emit TYPE_CODE_CLASS
3654        * for all 3 of "class", "struct"
3655        * "union", and we have to look at the "class_decl" field if we
3656        * want to know how it was really declared)
3657        */
3658       /* (0==class, 1==union, 2==struct) */
3659       TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl;
3660     }
3661   else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3662     {
3663       /* Get the basic type correct.  */
3664       TYPE_CODE (type) = TYPE_CODE_TEMPLATE;
3665       allocate_cplus_struct_type (type);
3666       TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE;
3667     }
3668   else
3669     return type;
3670
3671
3672   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3673
3674   /* For classes, read the parent list.
3675    * Question (RT): Do we need to do this for templates also?
3676    */
3677   if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3678     {
3679
3680       /* First read the parent-list (classes from which we derive fields) */
3681       parent = dn_bufp->dclass.parentlist;
3682       while (parent.word && parent.word != DNTTNIL)
3683         {
3684           parentp = hpread_get_lntt (parent.dnttp.index, objfile);
3685
3686           /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3687
3688           /* Get space to record the next field/data-member. */
3689           new = (struct nextfield *) alloca (sizeof (struct nextfield));
3690           memset (new, 0, sizeof (struct nextfield));
3691           new->next = list;
3692           list = new;
3693
3694           FIELD_BITSIZE (list->field) = 0;
3695           FIELD_STATIC_KIND (list->field) = 0;
3696
3697           /* The "classname" field is actually a DNTT pointer to the base class */
3698           baseclass = hpread_type_lookup (parentp->dinheritance.classname,
3699                                           objfile);
3700           FIELD_TYPE (list->field) = baseclass;
3701
3702           list->field.name = type_name_no_tag (FIELD_TYPE (list->field));
3703
3704           list->attributes = 0;
3705
3706           /* Check for virtuality of base, and set the
3707            * offset of the base subobject within the object.
3708            * (Offset set to -1 for virtual bases (for now).)
3709            */
3710           if (parentp->dinheritance.Virtual)
3711             {
3712               B_SET (&(list->attributes), ATTR_VIRTUAL);
3713               parentp->dinheritance.offset = -1;
3714             }
3715           else
3716             FIELD_BITPOS (list->field) = parentp->dinheritance.offset;
3717
3718           /* Check visibility */
3719           switch (parentp->dinheritance.visibility)
3720             {
3721             case 1:
3722               B_SET (&(list->attributes), ATTR_PROTECT);
3723               break;
3724             case 2:
3725               B_SET (&(list->attributes), ATTR_PRIVATE);
3726               break;
3727             }
3728
3729           n_base_classes++;
3730           nfields++;
3731
3732           parent = parentp->dinheritance.next;
3733         }
3734     }
3735
3736   /* For templates, read the template argument list.
3737    * This must be done before processing the member list, because
3738    * the member list may refer back to this. E.g.:
3739    *   template <class T1, class T2> class q2 {
3740    *     public:
3741    *     T1 a;
3742    *     T2 b;
3743    *   };
3744    * We need to read the argument list "T1", "T2" first.
3745    */
3746   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3747     {
3748       /* Kludge alert: This stuffs a global "current_template" which
3749        * is referred to by hpread_get_nth_templ_arg(). The global
3750        * is cleared at the end of this routine.
3751        */
3752       current_template = type;
3753
3754       /* Read in the argument list */
3755       field = dn_bufp->dtemplate.arglist;
3756       while (field.word && field.word != DNTTNIL)
3757         {
3758           /* Get this template argument */
3759           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3760           if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG)
3761             {
3762               warning (_("Invalid debug info: Template argument entry is of wrong kind"));
3763               break;
3764             }
3765           /* Bump the count */
3766           n_templ_args++;
3767           /* Allocate and fill in a struct next_template */
3768           t_new = (struct next_template *) alloca (sizeof (struct next_template));
3769           memset (t_new, 0, sizeof (struct next_template));
3770           t_new->next = t_list;
3771           t_list = t_new;
3772           t_list->arg.name = VT (objfile) + fieldp->dtempl_arg.name;
3773           t_list->arg.type = hpread_read_templ_arg_type (field, fieldp,
3774                                                  objfile, t_list->arg.name);
3775           /* Walk to the next template argument */
3776           field = fieldp->dtempl_arg.nextarg;
3777         }
3778     }
3779
3780   TYPE_NTEMPLATE_ARGS (type) = n_templ_args;
3781
3782   if (n_templ_args > 0)
3783     TYPE_TEMPLATE_ARGS (type) = (struct template_arg *)
3784       obstack_alloc (&objfile->objfile_obstack, sizeof (struct template_arg) * n_templ_args);
3785   for (n = n_templ_args; t_list; t_list = t_list->next)
3786     {
3787       n -= 1;
3788       TYPE_TEMPLATE_ARG (type, n) = t_list->arg;
3789     }
3790
3791   /* Next read in and internalize all the fields/members.  */
3792   if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3793     field = dn_bufp->dstruct.firstfield;
3794   else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3795     field = dn_bufp->dunion.firstfield;
3796   else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3797     field = dn_bufp->dclass.memberlist;
3798   else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3799     field = dn_bufp->dtemplate.memberlist;
3800   else
3801     field.word = DNTTNIL;
3802
3803   while (field.word && field.word != DNTTNIL)
3804     {
3805       fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3806
3807       /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
3808        * or a DNTT_TYPE_GENFIELD record.
3809        */
3810       vtbl_offset = 0;
3811       static_member = 0;
3812       const_member = 0;
3813       volatile_member = 0;
3814
3815       if (fieldp->dblock.kind == DNTT_TYPE_GENFIELD)
3816         {
3817
3818           /* The type will be GENFIELD if the field is a method or
3819            * a static member (or some other cases -- see below)
3820            */
3821
3822           /* Follow a link to get to the record for the field. */
3823           fn_field = fieldp->dgenfield.field;
3824           fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3825
3826           /* Virtual funcs are indicated by a VFUNC which points to the
3827            * real entry
3828            */
3829           if (fn_fieldp->dblock.kind == DNTT_TYPE_VFUNC)
3830             {
3831               vtbl_offset = fn_fieldp->dvfunc.vtbl_offset;
3832               fn_field = fn_fieldp->dvfunc.funcptr;
3833               fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3834             }
3835
3836           /* A function's entry may be preceded by a modifier which
3837            * labels it static/constant/volatile.
3838            */
3839           if (fn_fieldp->dblock.kind == DNTT_TYPE_MODIFIER)
3840             {
3841               static_member = fn_fieldp->dmodifier.m_static;
3842               const_member = fn_fieldp->dmodifier.m_const;
3843               volatile_member = fn_fieldp->dmodifier.m_volatile;
3844               fn_field = fn_fieldp->dmodifier.type;
3845               fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3846             }
3847
3848           /* Check whether we have a method */
3849           if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
3850               (fn_fieldp->dblock.kind == DNTT_TYPE_FUNCTION) ||
3851               (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) ||
3852               (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_FUNCTION))
3853             {
3854               /* Method found */
3855
3856               short ix = 0;
3857
3858               /* Look up function type of method */
3859               memtype = hpread_type_lookup (fn_field, objfile);
3860
3861               /* Methods can be seen before classes in the SOM records.
3862                  If we are processing this class because it's a parameter of a
3863                  method, at this point the method's type is actually incomplete;
3864                  we'll have to fix it up later; mark the class for this. */
3865
3866               if (TYPE_INCOMPLETE (memtype))
3867                 {
3868                   TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3869                   if (fixup_class)
3870                     warning (_("Two classes to fix up for method??  Type information may be incorrect for some classes."));
3871                   if (fixup_method)
3872                     warning (_("Two methods to be fixed up at once?? Type information may be incorrect for some classes."));
3873                   fixup_class = type;   /* remember this class has to be fixed up */
3874                   fixup_method = memtype;       /* remember the method type to be used in fixup */
3875                 }
3876
3877               /* HP aCC generates operator names without the "operator" keyword, and
3878                  generates null strings as names for operators that are
3879                  user-defined type conversions to basic types (e.g. operator int ()).
3880                  So try to reconstruct name as best as possible. */
3881
3882               method_name = (char *) (VT (objfile) + fn_fieldp->dfunc.name);
3883               method_alias = (char *) (VT (objfile) + fn_fieldp->dfunc.alias);
3884
3885               if (!method_name ||       /* no name */
3886                   !*method_name ||      /* or null name */
3887                   cplus_mangle_opname (method_name, DMGL_ANSI))         /* or name is an operator like "<" */
3888                 {
3889                   char *tmp_name = cplus_demangle (method_alias, DMGL_ANSI);
3890                   char *op_string = strstr (tmp_name, "operator");
3891                   method_name = xmalloc (strlen (op_string) + 1);       /* don't overwrite VT! */
3892                   strcpy (method_name, op_string);
3893                 }
3894
3895               /* First check if a method of the same name has already been seen. */
3896               fn_p = fn_list;
3897               while (fn_p)
3898                 {
3899                   if (DEPRECATED_STREQ (fn_p->field.name, method_name))
3900                     break;
3901                   fn_p = fn_p->next;
3902                 }
3903
3904               /* If no such method was found, allocate a new entry in the list */
3905               if (!fn_p)
3906                 {
3907                   /* Get space to record this member function */
3908                   /* Note: alloca used; this will disappear on routine exit */
3909                   fn_new = (struct next_fn_field *) alloca (sizeof (struct next_fn_field));
3910                   memset (fn_new, 0, sizeof (struct next_fn_field));
3911                   fn_new->next = fn_list;
3912                   fn_list = fn_new;
3913
3914                   /* Fill in the fields of the struct nextfield */
3915
3916                   /* Record the (unmangled) method name */
3917                   fn_list->field.name = method_name;
3918                   /* Initial space for overloaded methods */
3919                   /* Note: xmalloc is used; this will persist after this routine exits */
3920                   fn_list->field.fn_fields = (struct fn_field *) xmalloc (5 * (sizeof (struct fn_field)));
3921                   fn_list->field.length = 1;    /* Init # of overloaded instances */
3922                   fn_list->num_fn_fields = 5;   /* # of entries for which space allocated */
3923                   fn_p = fn_list;
3924                   ix = 0;       /* array index for fn_field */
3925                   /* Bump the total count of the distinctly named methods */
3926                   n_fn_fields++;
3927                 }
3928               else
3929                 /* Another overloaded instance of an already seen method name */
3930                 {
3931                   if (++(fn_p->field.length) > fn_p->num_fn_fields)
3932                     {
3933                       /* Increase space allocated for overloaded instances */
3934                       fn_p->field.fn_fields
3935                         = (struct fn_field *) xrealloc (fn_p->field.fn_fields,
3936                       (fn_p->num_fn_fields + 5) * sizeof (struct fn_field));
3937                       fn_p->num_fn_fields += 5;
3938                     }
3939                   ix = fn_p->field.length - 1;  /* array index for fn_field */
3940                 }
3941
3942               /* "physname" is intended to be the name of this overloaded instance. */
3943               if ((fn_fieldp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
3944                   method_alias &&
3945                   *method_alias)        /* not a null string */
3946                 fn_p->field.fn_fields[ix].physname = method_alias;
3947               else
3948                 fn_p->field.fn_fields[ix].physname = method_name;
3949               /* What's expected here is the function type */
3950               /* But mark it as NULL if the method was incompletely processed
3951                  We'll fix this up later when the method is fully processed */
3952               if (TYPE_INCOMPLETE (memtype))
3953                 fn_p->field.fn_fields[ix].type = NULL;
3954               else
3955                 fn_p->field.fn_fields[ix].type = memtype;
3956
3957               /* For virtual functions, fill in the voffset field with the
3958                * virtual table offset. (This is just copied over from the
3959                * SOM record; not sure if it is what GDB expects here...).
3960                * But if the function is a static method, set it to 1.
3961                *
3962                * Note that we have to add 1 because 1 indicates a static
3963                * method, and 0 indicates a non-static, non-virtual method */
3964
3965               if (static_member)
3966                 fn_p->field.fn_fields[ix].voffset = VOFFSET_STATIC;
3967               else
3968                 fn_p->field.fn_fields[ix].voffset = vtbl_offset ? vtbl_offset + 1 : 0;
3969
3970               /* Also fill in the fcontext field with the current
3971                * class. (The latter isn't quite right: should be the baseclass
3972                * that defines the virtual function... Note we do have
3973                * a variable "baseclass" that we could stuff into the fcontext
3974                * field, but "baseclass" isn't necessarily right either,
3975                * since the virtual function could have been defined more
3976                * than one level up).
3977                */
3978
3979               if (vtbl_offset != 0)
3980                 fn_p->field.fn_fields[ix].fcontext = type;
3981               else
3982                 fn_p->field.fn_fields[ix].fcontext = NULL;
3983
3984               /* Other random fields pertaining to this method */
3985               fn_p->field.fn_fields[ix].is_const = const_member;
3986               fn_p->field.fn_fields[ix].is_volatile = volatile_member;  /* ?? */
3987               switch (fieldp->dgenfield.visibility)
3988                 {
3989                 case 1:
3990                   fn_p->field.fn_fields[ix].is_protected = 1;
3991                   fn_p->field.fn_fields[ix].is_private = 0;
3992                   break;
3993                 case 2:
3994                   fn_p->field.fn_fields[ix].is_protected = 0;
3995                   fn_p->field.fn_fields[ix].is_private = 1;
3996                   break;
3997                 default:        /* public */
3998                   fn_p->field.fn_fields[ix].is_protected = 0;
3999                   fn_p->field.fn_fields[ix].is_private = 0;
4000                 }
4001               fn_p->field.fn_fields[ix].is_stub = 0;
4002
4003               /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
4004                  if the class points to the FUNCTION, there is usually separate
4005                  code for the method; but if we have a MEMFUNC, the method has
4006                  been inlined (and there is usually no FUNCTION entry)
4007                  FIXME Not sure if this test is accurate. pai/1997-08-22 */
4008               if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
4009                   (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC))
4010                 fn_p->field.fn_fields[ix].is_inlined = 1;
4011               else
4012                 fn_p->field.fn_fields[ix].is_inlined = 0;
4013
4014               fn_p->field.fn_fields[ix].dummy = 0;
4015
4016               /* Bump the total count of the member functions */
4017               n_fn_fields_total++;
4018
4019             }
4020           else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4021             {
4022               /* This case is for static data members of classes */
4023
4024               /* pai:: FIXME -- check that "staticmem" bit is set */
4025
4026               /* Get space to record this static member */
4027               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4028               memset (new, 0, sizeof (struct nextfield));
4029               new->next = list;
4030               list = new;
4031
4032               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4033               SET_FIELD_PHYSNAME (list->field, 0);      /* initialize to empty */
4034               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4035
4036               FIELD_TYPE (list->field) = memtype;
4037               list->attributes = 0;
4038               switch (fieldp->dgenfield.visibility)
4039                 {
4040                 case 1:
4041                   B_SET (&(list->attributes), ATTR_PROTECT);
4042                   break;
4043                 case 2:
4044                   B_SET (&(list->attributes), ATTR_PRIVATE);
4045                   break;
4046                 }
4047               nfields++;
4048             }
4049
4050           else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD)
4051             {
4052               /* FIELDs follow GENFIELDs for fields of anonymous unions.
4053                  Code below is replicated from the case for FIELDs further
4054                  below, except that fieldp is replaced by fn_fieldp */
4055               if (!fn_fieldp->dfield.a_union)
4056                 warning (_("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set"));
4057               /* Get space to record the next field/data-member. */
4058               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4059               memset (new, 0, sizeof (struct nextfield));
4060               new->next = list;
4061               list = new;
4062
4063               list->field.name = VT (objfile) + fn_fieldp->dfield.name;
4064               FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset;
4065               if (fn_fieldp->dfield.bitlength % 8)
4066                 list->field.bitsize = fn_fieldp->dfield.bitlength;
4067               else
4068                 list->field.bitsize = 0;
4069
4070               memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile);
4071               list->field.type = memtype;
4072               list->attributes = 0;
4073               switch (fn_fieldp->dfield.visibility)
4074                 {
4075                 case 1:
4076                   B_SET (&(list->attributes), ATTR_PROTECT);
4077                   break;
4078                 case 2:
4079                   B_SET (&(list->attributes), ATTR_PRIVATE);
4080                   break;
4081                 }
4082               nfields++;
4083             }
4084           else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4085             {
4086               /* Field of anonymous union; union is not inside a class */
4087               if (!fn_fieldp->dsvar.a_union)
4088                 warning (_("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set"));
4089               /* Get space to record the next field/data-member. */
4090               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4091               memset (new, 0, sizeof (struct nextfield));
4092               new->next = list;
4093               list = new;
4094
4095               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4096               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4097               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4098               FIELD_STATIC_KIND (list->field) = 0;
4099               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4100               list->field.type = memtype;
4101               list->attributes = 0;
4102               /* No info to set visibility -- always public */
4103               nfields++;
4104             }
4105           else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR)
4106             {
4107               /* Field of anonymous union; union is not inside a class */
4108               if (!fn_fieldp->ddvar.a_union)
4109                 warning (_("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set"));
4110               /* Get space to record the next field/data-member. */
4111               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4112               memset (new, 0, sizeof (struct nextfield));
4113               new->next = list;
4114               list = new;
4115
4116               list->field.name = VT (objfile) + fn_fieldp->ddvar.name;
4117               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4118               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4119               FIELD_STATIC_KIND (list->field) = 0;
4120               memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile);
4121               list->field.type = memtype;
4122               list->attributes = 0;
4123               /* No info to set visibility -- always public */
4124               nfields++;
4125             }
4126           else
4127             {                   /* Not a method, nor a static data member, nor an anon union field */
4128
4129               /* This case is for miscellaneous type entries (local enums,
4130                  local function templates, etc.) that can be present
4131                  inside a class. */
4132
4133               /* Enums -- will be handled by other code that takes care
4134                  of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4135                  it's not clear we could have handled them here at all. */
4136               /* FUNC_TEMPLATE: is handled by other code (?). */
4137               /* MEMACCESS: modified access for inherited member. Not
4138                  sure what to do with this, ignoriing it at present. */
4139
4140               /* What other entries can appear following a GENFIELD which
4141                  we do not handle above?  (MODIFIER, VFUNC handled above.) */
4142
4143               if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) &&
4144                   (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) &&
4145                   (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE))
4146                 warning (_("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD"),
4147                          fn_fieldp->dblock.kind);
4148             }
4149           /* walk to the next FIELD or GENFIELD */
4150           field = fieldp->dgenfield.nextfield;
4151
4152         }
4153       else if (fieldp->dblock.kind == DNTT_TYPE_FIELD)
4154         {
4155
4156           /* Ordinary structure/union/class field */
4157           struct type *anon_union_type;
4158
4159           /* Get space to record the next field/data-member. */
4160           new = (struct nextfield *) alloca (sizeof (struct nextfield));
4161           memset (new, 0, sizeof (struct nextfield));
4162           new->next = list;
4163           list = new;
4164
4165           list->field.name = VT (objfile) + fieldp->dfield.name;
4166
4167
4168           /* A FIELD by itself (without a GENFIELD) can also be a static
4169              member.  Mark it as static with a physname of NULL.
4170              fix_static_member_physnames will assign the physname later. */
4171           if (fieldp->dfield.staticmem)
4172             {
4173               SET_FIELD_PHYSNAME (list->field, NULL);
4174               FIELD_BITPOS (list->field) = 0;
4175               FIELD_BITSIZE (list->field) = 0;
4176             }
4177           else
4178             /* Non-static data member */
4179             {
4180               FIELD_STATIC_KIND (list->field) = 0;
4181               FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
4182               if (fieldp->dfield.bitlength % 8)
4183                 FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
4184               else
4185                 FIELD_BITSIZE (list->field) = 0;
4186             }
4187
4188           memtype = hpread_type_lookup (fieldp->dfield.type, objfile);
4189           FIELD_TYPE (list->field) = memtype;
4190           list->attributes = 0;
4191           switch (fieldp->dfield.visibility)
4192             {
4193             case 1:
4194               B_SET (&(list->attributes), ATTR_PROTECT);
4195               break;
4196             case 2:
4197               B_SET (&(list->attributes), ATTR_PRIVATE);
4198               break;
4199             }
4200           nfields++;
4201
4202
4203           /* Note 1: First, we have to check if the current field is an anonymous
4204              union. If it is, then *its* fields are threaded along in the
4205              nextfield chain. :-( This was supposed to help debuggers, but is
4206              really just a nuisance since we deal with anonymous unions anyway by
4207              checking that the name is null.  So anyway, we skip over the fields
4208              of the anonymous union. pai/1997-08-22 */
4209           /* Note 2: In addition, the bitoffsets for the fields of the anon union
4210              are relative to the enclosing struct, *NOT* relative to the anon
4211              union!  This is an even bigger nuisance -- we have to go in and munge
4212              the anon union's type information appropriately. pai/1997-08-22 */
4213
4214           /* Both tasks noted above are done by a separate function.  This takes us
4215              to the next FIELD or GENFIELD, skipping anon unions, and recursively
4216              processing intermediate types. */
4217           field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile);
4218
4219         }
4220       else
4221         {
4222           /* neither field nor genfield ?? is this possible?? */
4223           /* pai:: FIXME walk to the next -- how? */
4224           warning (_("Internal error: unexpected DNTT kind %d encountered as field of struct"),
4225                    fieldp->dblock.kind);
4226           warning (_("Skipping remaining fields of struct"));
4227           break;                /* get out of loop of fields */
4228         }
4229     }
4230
4231   /* If it's a template, read in the instantiation list */
4232   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4233     {
4234       ninstantiations = 0;
4235       field = dn_bufp->dtemplate.expansions;
4236       while (field.word && field.word != DNTTNIL)
4237         {
4238           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4239
4240           /* The expansions or nextexp should point to a tagdef */
4241           if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF)
4242             break;
4243
4244           i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation));
4245           memset (i_new, 0, sizeof (struct next_instantiation));
4246           i_new->next = i_list;
4247           i_list = i_new;
4248           i_list->t = hpread_type_lookup (field, objfile);
4249           ninstantiations++;
4250
4251           /* And the "type" field of that should point to a class */
4252           field = fieldp->dtag.type;
4253           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4254           if (fieldp->dblock.kind != DNTT_TYPE_CLASS)
4255             break;
4256
4257           /* Get the next expansion */
4258           field = fieldp->dclass.nextexp;
4259         }
4260     }
4261   TYPE_NINSTANTIATIONS (type) = ninstantiations;
4262   if (ninstantiations > 0)
4263     TYPE_INSTANTIATIONS (type) = (struct type **)
4264       obstack_alloc (&objfile->objfile_obstack, sizeof (struct type *) * ninstantiations);
4265   for (n = ninstantiations; i_list; i_list = i_list->next)
4266     {
4267       n -= 1;
4268       TYPE_INSTANTIATION (type, n) = i_list->t;
4269     }
4270
4271
4272   /* Copy the field-list to GDB's symbol table */
4273   TYPE_NFIELDS (type) = nfields;
4274   TYPE_N_BASECLASSES (type) = n_base_classes;
4275   TYPE_FIELDS (type) = (struct field *)
4276     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nfields);
4277   /* Copy the saved-up fields into the field vector.  */
4278   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4279     {
4280       n -= 1;
4281       TYPE_FIELD (type, n) = tmp_list->field;
4282     }
4283
4284   /* Copy the "function-field-list" (i.e., the list of member
4285    * functions in the class) to GDB's symbol table
4286    */
4287   TYPE_NFN_FIELDS (type) = n_fn_fields;
4288   TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total;
4289   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
4290     obstack_alloc (&objfile->objfile_obstack, sizeof (struct fn_fieldlist) * n_fn_fields);
4291   for (n = n_fn_fields; fn_list; fn_list = fn_list->next)
4292     {
4293       n -= 1;
4294       TYPE_FN_FIELDLIST (type, n) = fn_list->field;
4295     }
4296
4297   /* pai:: FIXME -- perhaps each bitvector should be created individually */
4298   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4299     {
4300       n -= 1;
4301       if (tmp_list->attributes)
4302         {
4303           need_bitvectors = 1;
4304           break;
4305         }
4306     }
4307
4308   if (need_bitvectors)
4309     {
4310       /* pai:: this step probably redundant */
4311       ALLOCATE_CPLUS_STRUCT_TYPE (type);
4312
4313       TYPE_FIELD_VIRTUAL_BITS (type) =
4314         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4315       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields);
4316
4317       TYPE_FIELD_PRIVATE_BITS (type) =
4318         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4319       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
4320
4321       TYPE_FIELD_PROTECTED_BITS (type) =
4322         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4323       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
4324
4325       /* this field vector isn't actually used with HP aCC */
4326       TYPE_FIELD_IGNORE_BITS (type) =
4327         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4328       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
4329
4330       while (nfields-- > 0)
4331         {
4332           if (B_TST (&(list->attributes), ATTR_VIRTUAL))
4333             SET_TYPE_FIELD_VIRTUAL (type, nfields);
4334           if (B_TST (&(list->attributes), ATTR_PRIVATE))
4335             SET_TYPE_FIELD_PRIVATE (type, nfields);
4336           if (B_TST (&(list->attributes), ATTR_PROTECT))
4337             SET_TYPE_FIELD_PROTECTED (type, nfields);
4338
4339           list = list->next;
4340         }
4341     }
4342   else
4343     {
4344       TYPE_FIELD_VIRTUAL_BITS (type) = NULL;
4345       TYPE_FIELD_PROTECTED_BITS (type) = NULL;
4346       TYPE_FIELD_PRIVATE_BITS (type) = NULL;
4347     }
4348
4349   if (has_vtable (type))
4350     {
4351       /* Allocate space for class runtime information */
4352       TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info));
4353       /* Set flag for vtable */
4354       TYPE_VTABLE (type) = 1;
4355       /* The first non-virtual base class with a vtable. */
4356       TYPE_PRIMARY_BASE (type) = primary_base_class (type);
4357       /* The virtual base list. */
4358       TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type);
4359     }
4360   else
4361     TYPE_RUNTIME_PTR (type) = NULL;
4362
4363   /* If this is a local type (C++ - declared inside a function), record file name & line # */
4364   if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ ))
4365     {
4366       TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info));
4367       TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1);
4368       strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name);
4369       if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0))
4370         TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line;
4371       else
4372         TYPE_LOCALTYPE_LINE (type) = 0;
4373     }
4374   else
4375     TYPE_LOCALTYPE_PTR (type) = NULL;
4376
4377   /* Clear the global saying what template we are in the middle of processing */
4378   current_template = NULL;
4379
4380   return type;
4381 }
4382
4383 /* Adjust the physnames for each static member of a struct
4384    or class type to be something like "A::x"; then various
4385    other pieces of code that do a lookup_symbol on the phyname
4386    work correctly.
4387    TYPE is a pointer to the struct/class type
4388    NAME is a char * (string) which is the class/struct name
4389    Void return */
4390
4391 static void
4392 fix_static_member_physnames (struct type *type, char *class_name,
4393                              struct objfile *objfile)
4394 {
4395   int i;
4396
4397   /* We fix the member names only for classes or structs */
4398   if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
4399     return;
4400
4401   for (i = 0; i < TYPE_NFIELDS (type); i++)
4402     if (TYPE_FIELD_STATIC (type, i))
4403       {
4404         if (TYPE_FIELD_STATIC_PHYSNAME (type, i))
4405           return;               /* physnames are already set */
4406
4407         SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i],
4408                             obstack_alloc (&objfile->objfile_obstack,
4409              strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3));
4410         strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name);
4411         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::");
4412         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i));
4413       }
4414 }
4415
4416 /* Fix-up the type structure for a CLASS so that the type entry
4417  * for a method (previously marked with a null type in hpread_read_struct_type()
4418  * is set correctly to METHOD.
4419  * OBJFILE is as for other such functions.
4420  * Void return. */
4421
4422 static void
4423 fixup_class_method_type (struct type *class, struct type *method,
4424                          struct objfile *objfile)
4425 {
4426   int i, j, k;
4427
4428   if (!class || !method || !objfile)
4429     return;
4430
4431   /* Only for types that have methods */
4432   if ((TYPE_CODE (class) != TYPE_CODE_CLASS) &&
4433       (TYPE_CODE (class) != TYPE_CODE_UNION))
4434     return;
4435
4436   /* Loop over all methods and find the one marked with a NULL type */
4437   for (i = 0; i < TYPE_NFN_FIELDS (class); i++)
4438     for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++)
4439       if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL)
4440         {
4441           /* Set the method type */
4442           TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method;
4443
4444           /* Break out of both loops -- only one method to fix up in a class */
4445           goto finish;
4446         }
4447
4448 finish:
4449   TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE;
4450 }
4451
4452
4453 /* If we're in the middle of processing a template, get a pointer
4454  * to the Nth template argument.
4455  * An example may make this clearer:
4456  *   template <class T1, class T2> class q2 {
4457  *     public:
4458  *     T1 a;
4459  *     T2 b;
4460  *   };
4461  * The type for "a" will be "first template arg" and
4462  * the type for "b" will be "second template arg".
4463  * We need to look these up in order to fill in "a" and "b"'s type.
4464  * This is called from hpread_type_lookup().
4465  */
4466 static struct type *
4467 hpread_get_nth_template_arg (struct objfile *objfile, int n)
4468 {
4469   if (current_template != NULL)
4470     return TYPE_TEMPLATE_ARG (current_template, n).type;
4471   else
4472     return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG);
4473 }
4474
4475 /* Read in and internalize a TEMPL_ARG (template arg) symbol.  */
4476
4477 static struct type *
4478 hpread_read_templ_arg_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4479                             struct objfile *objfile, char *name)
4480 {
4481   struct type *type;
4482
4483   /* See if it's something we've already deal with.  */
4484   type = hpread_alloc_type (hp_type, objfile);
4485   if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG)
4486     return type;
4487
4488   /* Nope.  Fill in the appropriate fields.  */
4489   TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG;
4490   TYPE_LENGTH (type) = 0;
4491   TYPE_NFIELDS (type) = 0;
4492   TYPE_NAME (type) = name;
4493   return type;
4494 }
4495
4496 /* Read in and internalize a set debug symbol.  */
4497
4498 static struct type *
4499 hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4500                       struct objfile *objfile)
4501 {
4502   struct type *type;
4503
4504   /* See if it's something we've already deal with.  */
4505   type = hpread_alloc_type (hp_type, objfile);
4506   if (TYPE_CODE (type) == TYPE_CODE_SET)
4507     return type;
4508
4509   /* Nope.  Fill in the appropriate fields.  */
4510   TYPE_CODE (type) = TYPE_CODE_SET;
4511   TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8;
4512   TYPE_NFIELDS (type) = 0;
4513   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype,
4514                                                 objfile);
4515   return type;
4516 }
4517
4518 /* Read in and internalize an array debug symbol.  */
4519
4520 static struct type *
4521 hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4522                         struct objfile *objfile)
4523 {
4524   struct type *type;
4525
4526   /* Allocate an array type symbol.
4527    * Why no check for already-read here, like in the other
4528    * hpread_read_xxx_type routines?  Because it kept us
4529    * from properly determining the size of the array!
4530    */
4531   type = hpread_alloc_type (hp_type, objfile);
4532
4533   TYPE_CODE (type) = TYPE_CODE_ARRAY;
4534
4535   /* Although the hp-symtab.h does not *require* this to be the case,
4536    * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4537    * I.e., express both array-length and element-length in bits,
4538    * or express both array-length and element-length in bytes.
4539    */
4540   if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) ||
4541         (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes)))
4542     {
4543       warning (_("error in hpread_array_type."));
4544       return NULL;
4545     }
4546   else if (dn_bufp->darray.arraylength == 0x7fffffff)
4547     {
4548       /* The HP debug format represents char foo[]; as an array with
4549        * length 0x7fffffff.  Internally GDB wants to represent this
4550        *  as an array of length zero.
4551        */
4552       TYPE_LENGTH (type) = 0;
4553     }
4554   else if (dn_bufp->darray.arrayisbytes)
4555     TYPE_LENGTH (type) = dn_bufp->darray.arraylength;
4556   else                          /* arraylength is in bits */
4557     TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
4558
4559   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype,
4560                                                 objfile);
4561
4562   /* The one "field" is used to store the subscript type */
4563   /* Since C and C++ multi-dimensional arrays are simply represented
4564    * as: array of array of ..., we only need one subscript-type
4565    * per array. This subscript type is typically a subrange of integer.
4566    * If this gets extended to support languages like Pascal, then
4567    * we need to fix this to represent multi-dimensional arrays properly.
4568    */
4569   TYPE_NFIELDS (type) = 1;
4570   TYPE_FIELDS (type) = (struct field *)
4571     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field));
4572   TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype,
4573                                                   objfile);
4574   return type;
4575 }
4576
4577 /* Read in and internalize a subrange debug symbol.  */
4578 static struct type *
4579 hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4580                            struct objfile *objfile)
4581 {
4582   struct type *type;
4583
4584   /* Is it something we've already dealt with.  */
4585   type = hpread_alloc_type (hp_type, objfile);
4586   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4587     return type;
4588
4589   /* Nope, internalize it.  */
4590   TYPE_CODE (type) = TYPE_CODE_RANGE;
4591   TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
4592   TYPE_NFIELDS (type) = 2;
4593   TYPE_FIELDS (type)
4594     = (struct field *) obstack_alloc (&objfile->objfile_obstack,
4595                                       2 * sizeof (struct field));
4596
4597   if (dn_bufp->dsubr.dyn_low)
4598     TYPE_FIELD_BITPOS (type, 0) = 0;
4599   else
4600     TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound;
4601
4602   if (dn_bufp->dsubr.dyn_high)
4603     TYPE_FIELD_BITPOS (type, 1) = -1;
4604   else
4605     TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound;
4606   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype,
4607                                                 objfile);
4608   return type;
4609 }
4610
4611 /* struct type * hpread_type_lookup(hp_type, objfile)
4612  *   Arguments:
4613  *     hp_type: A pointer into the DNTT specifying what type we
4614  *              are about to "look up"., or else [for fundamental types
4615  *              like int, float, ...] an "immediate" structure describing
4616  *              the type.
4617  *     objfile: ?
4618  *   Return value: A pointer to a "struct type" (representation of a
4619  *                 type in GDB's internal symbol table - see gdbtypes.h)
4620  *   Routine description:
4621  *     There are a variety of places when scanning the DNTT when we
4622  *     need to interpret a "type" field. The simplest and most basic
4623  *     example is when we're processing the symbol table record
4624  *     for a data symbol (a SVAR or DVAR record). That has
4625  *     a "type" field specifying the type of the data symbol. That
4626  *     "type" field is either an "immediate" type specification (for the
4627  *     fundamental types) or a DNTT pointer (for more complicated types).
4628  *     For the more complicated types, we may or may not have already
4629  *     processed the pointed-to type. (Multiple data symbols can of course
4630  *     share the same type).
4631  *     The job of hpread_type_lookup() is to process this "type" field.
4632  *     Most of the real work is done in subroutines. Here we interpret
4633  *     the immediate flag. If not immediate, chase the DNTT pointer to
4634  *     find our way to the SOM record describing the type, switch on
4635  *     the SOM kind, and then call an appropriate subroutine depending
4636  *     on what kind of type we are constructing. (e.g., an array type,
4637  *     a struct/class type, etc).
4638  */
4639 static struct type *
4640 hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile)
4641 {
4642   union dnttentry *dn_bufp;
4643   struct type *tmp_type;
4644
4645   /* First see if it's a simple builtin type.  */
4646   if (hp_type.dntti.immediate)
4647     {
4648       /* If this is a template argument, the argument number is
4649        * encoded in the bitlength. All other cases, just return
4650        * GDB's representation of this fundamental type.
4651        */
4652       if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG)
4653         return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength);
4654       else
4655         return lookup_fundamental_type (objfile,
4656                                         hpread_type_translate (hp_type));
4657     }
4658
4659   /* Not a builtin type.  We'll have to read it in.  */
4660   if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile))
4661     dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile);
4662   else
4663     /* This is a fancy way of returning NULL */
4664     return lookup_fundamental_type (objfile, FT_VOID);
4665
4666   switch (dn_bufp->dblock.kind)
4667     {
4668     case DNTT_TYPE_SRCFILE:
4669     case DNTT_TYPE_MODULE:
4670     case DNTT_TYPE_ENTRY:
4671     case DNTT_TYPE_BEGIN:
4672     case DNTT_TYPE_END:
4673     case DNTT_TYPE_IMPORT:
4674     case DNTT_TYPE_LABEL:
4675     case DNTT_TYPE_FPARAM:
4676     case DNTT_TYPE_SVAR:
4677     case DNTT_TYPE_DVAR:
4678     case DNTT_TYPE_CONST:
4679     case DNTT_TYPE_MEMENUM:
4680     case DNTT_TYPE_VARIANT:
4681     case DNTT_TYPE_FILE:
4682     case DNTT_TYPE_WITH:
4683     case DNTT_TYPE_COMMON:
4684     case DNTT_TYPE_COBSTRUCT:
4685     case DNTT_TYPE_XREF:
4686     case DNTT_TYPE_SA:
4687     case DNTT_TYPE_MACRO:
4688     case DNTT_TYPE_BLOCKDATA:
4689     case DNTT_TYPE_CLASS_SCOPE:
4690     case DNTT_TYPE_MEMACCESS:
4691     case DNTT_TYPE_INHERITANCE:
4692     case DNTT_TYPE_OBJECT_ID:
4693     case DNTT_TYPE_FRIEND_CLASS:
4694     case DNTT_TYPE_FRIEND_FUNC:
4695       /* These are not types - something went wrong.  */
4696       /* This is a fancy way of returning NULL */
4697       return lookup_fundamental_type (objfile, FT_VOID);
4698
4699     case DNTT_TYPE_FUNCTION:
4700       /* We wind up here when dealing with class member functions
4701        * (called from hpread_read_struct_type(), i.e. when processing
4702        * the class definition itself).
4703        */
4704       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4705
4706     case DNTT_TYPE_DOC_FUNCTION:
4707       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4708
4709     case DNTT_TYPE_TYPEDEF:
4710       {
4711         /* A typedef - chase it down by making a recursive call */
4712         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4713                                                       objfile);
4714
4715         /* The following came from the base hpread.c that we inherited.
4716          * It is WRONG so I have commented it out. - RT
4717          *...
4718
4719          char *suffix;
4720          suffix = VT (objfile) + dn_bufp->dtype.name;
4721          TYPE_NAME (structtype) = suffix;
4722
4723          * ... further explanation ....
4724          *
4725          * What we have here is a typedef pointing to a typedef.
4726          * E.g.,
4727          * typedef int foo;
4728          * typedef foo fum;
4729          *
4730          * What we desire to build is (these are pictures
4731          * of "struct type"'s):
4732          *
4733          *  +---------+     +----------+     +------------+
4734          *  | typedef |     | typedef  |     | fund. type |
4735          *  |     type| ->  |      type| ->  |            |
4736          *  | "fum"   |     | "foo"    |     | "int"      |
4737          *  +---------+     +----------+     +------------+
4738          *
4739          * What this commented-out code is doing is smashing the
4740          * name of pointed-to-type to be the same as the pointed-from
4741          * type. So we wind up with something like:
4742          *
4743          *  +---------+     +----------+     +------------+
4744          *  | typedef |     | typedef  |     | fund. type |
4745          *  |     type| ->  |      type| ->  |            |
4746          *  | "fum"   |     | "fum"    |     | "fum"      |
4747          *  +---------+     +----------+     +------------+
4748          *
4749          */
4750
4751         return structtype;
4752       }
4753
4754     case DNTT_TYPE_TAGDEF:
4755       {
4756         /* Just a little different from above.  We have to tack on
4757          * an identifier of some kind (struct, union, enum, class, etc).
4758          */
4759         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4760                                                       objfile);
4761         char *prefix, *suffix;
4762         suffix = VT (objfile) + dn_bufp->dtype.name;
4763
4764         /* Lookup the next type in the list.  It should be a structure,
4765          * union, class, enum, or template type.
4766          * We will need to attach that to our name.
4767          */
4768         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
4769           dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
4770         else
4771           {
4772             complaint (&symfile_complaints, _("error in hpread_type_lookup()."));
4773             return NULL;
4774           }
4775
4776         if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
4777           {
4778             prefix = "struct ";
4779           }
4780         else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
4781           {
4782             prefix = "union ";
4783           }
4784         else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
4785           {
4786             /* Further field for CLASS saying how it was really declared */
4787             /* 0==class, 1==union, 2==struct */
4788             if (dn_bufp->dclass.class_decl == 0)
4789               prefix = "class ";
4790             else if (dn_bufp->dclass.class_decl == 1)
4791               prefix = "union ";
4792             else if (dn_bufp->dclass.class_decl == 2)
4793               prefix = "struct ";
4794             else
4795               prefix = "";
4796           }
4797         else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM)
4798           {
4799             prefix = "enum ";
4800           }
4801         else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4802           {
4803             prefix = "template ";
4804           }
4805         else
4806           {
4807             prefix = "";
4808           }
4809
4810         /* Build the correct name.  */
4811         TYPE_NAME (structtype)
4812           = (char *) obstack_alloc (&objfile->objfile_obstack,
4813                                     strlen (prefix) + strlen (suffix) + 1);
4814         TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix);
4815         TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix);
4816         TYPE_TAG_NAME (structtype) = suffix;
4817
4818         /* For classes/structs, we have to set the static member "physnames"
4819            to point to strings like "Class::Member" */
4820         if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT)
4821           fix_static_member_physnames (structtype, suffix, objfile);
4822
4823         return structtype;
4824       }
4825
4826     case DNTT_TYPE_POINTER:
4827       /* Pointer type - call a routine in gdbtypes.c that constructs
4828        * the appropriate GDB type.
4829        */
4830       return make_pointer_type (
4831                                  hpread_type_lookup (dn_bufp->dptr.pointsto,
4832                                                      objfile),
4833                                  NULL);
4834
4835     case DNTT_TYPE_REFERENCE:
4836       /* C++ reference type - call a routine in gdbtypes.c that constructs
4837        * the appropriate GDB type.
4838        */
4839       return make_reference_type (
4840                            hpread_type_lookup (dn_bufp->dreference.pointsto,
4841                                                objfile),
4842                                    NULL);
4843
4844     case DNTT_TYPE_ENUM:
4845       return hpread_read_enum_type (hp_type, dn_bufp, objfile);
4846     case DNTT_TYPE_SET:
4847       return hpread_read_set_type (hp_type, dn_bufp, objfile);
4848     case DNTT_TYPE_SUBRANGE:
4849       return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
4850     case DNTT_TYPE_ARRAY:
4851       return hpread_read_array_type (hp_type, dn_bufp, objfile);
4852     case DNTT_TYPE_STRUCT:
4853     case DNTT_TYPE_UNION:
4854       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4855     case DNTT_TYPE_FIELD:
4856       return hpread_type_lookup (dn_bufp->dfield.type, objfile);
4857
4858     case DNTT_TYPE_FUNCTYPE:
4859       /* Here we want to read the function SOMs and return a
4860        * type for it. We get here, for instance, when processing
4861        * pointer-to-function type.
4862        */
4863       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4864
4865     case DNTT_TYPE_PTRMEM:
4866       /* Declares a C++ pointer-to-data-member type.
4867        * The "pointsto" field defines the class,
4868        * while the "memtype" field defines the pointed-to-type.
4869        */
4870       {
4871         struct type *ptrmemtype;
4872         struct type *class_type;
4873         struct type *memtype;
4874         memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4875                                       objfile),
4876           class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4877                                            objfile),
4878           ptrmemtype = alloc_type (objfile);
4879         smash_to_member_type (ptrmemtype, class_type, memtype);
4880         return make_pointer_type (ptrmemtype, NULL);
4881       }
4882       break;
4883
4884     case DNTT_TYPE_PTRMEMFUNC:
4885       /* Defines a C++ pointer-to-function-member type.
4886        * The "pointsto" field defines the class,
4887        * while the "memtype" field defines the pointed-to-type.
4888        */
4889       {
4890         struct type *ptrmemtype;
4891         struct type *class_type;
4892         struct type *functype;
4893         struct type *retvaltype;
4894         int nargs;
4895         int i;
4896         class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4897                                          objfile);
4898         functype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4899                                        objfile);
4900         retvaltype = TYPE_TARGET_TYPE (functype);
4901         nargs = TYPE_NFIELDS (functype);
4902         ptrmemtype = alloc_type (objfile);
4903
4904         smash_to_method_type (ptrmemtype, class_type, retvaltype,
4905                               TYPE_FIELDS (functype),
4906                               TYPE_NFIELDS (functype),
4907                               0);
4908         return make_pointer_type (ptrmemtype, NULL);
4909       }
4910       break;
4911
4912     case DNTT_TYPE_CLASS:
4913       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4914
4915     case DNTT_TYPE_GENFIELD:
4916       /* Chase pointer from GENFIELD to FIELD, and make recursive
4917        * call on that.
4918        */
4919       return hpread_type_lookup (dn_bufp->dgenfield.field, objfile);
4920
4921     case DNTT_TYPE_VFUNC:
4922       /* C++ virtual function.
4923        * We get here in the course of processing a class type which
4924        * contains virtual functions. Just go through another level
4925        * of indirection to get to the pointed-to function SOM.
4926        */
4927       return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile);
4928
4929     case DNTT_TYPE_MODIFIER:
4930       /* Check the modifiers and then just make a recursive call on
4931        * the "type" pointed to by the modifier DNTT.
4932        *
4933        * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4934        * "m_void" modifiers?  Is static_flag really needed here?
4935        * (m_static used for methods of classes, elsewhere).
4936        */
4937       tmp_type = make_cv_type (dn_bufp->dmodifier.m_const,
4938                                dn_bufp->dmodifier.m_volatile,
4939                       hpread_type_lookup (dn_bufp->dmodifier.type, objfile),
4940                                0);
4941       return tmp_type;
4942
4943
4944     case DNTT_TYPE_MEMFUNC:
4945       /* Member function. Treat like a function.
4946        * I think we get here in the course of processing a
4947        * pointer-to-member-function type...
4948        */
4949       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4950
4951     case DNTT_TYPE_DOC_MEMFUNC:
4952       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4953
4954     case DNTT_TYPE_TEMPLATE:
4955       /* Template - sort of the header for a template definition,
4956        * which like a class, points to a member list and also points
4957        * to a TEMPLATE_ARG list of type-arguments.
4958        */
4959       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4960
4961     case DNTT_TYPE_TEMPLATE_ARG:
4962       {
4963         char *name;
4964         /* The TEMPLATE record points to an argument list of
4965          * TEMPLATE_ARG records, each of which describes one
4966          * of the type-arguments.
4967          */
4968         name = VT (objfile) + dn_bufp->dtempl_arg.name;
4969         return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name);
4970       }
4971
4972     case DNTT_TYPE_FUNC_TEMPLATE:
4973       /* We wind up here when processing a TEMPLATE type,
4974        * if the template has member function(s).
4975        * Treat it like a FUNCTION.
4976        */
4977       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4978
4979     case DNTT_TYPE_LINK:
4980       /* The LINK record is used to link up templates with instantiations.
4981        * There is no type associated with the LINK record per se.
4982        */
4983       return lookup_fundamental_type (objfile, FT_VOID);
4984
4985       /* Also not yet handled... */
4986       /* case DNTT_TYPE_DYN_ARRAY_DESC: */
4987       /* case DNTT_TYPE_DESC_SUBRANGE: */
4988       /* case DNTT_TYPE_BEGIN_EXT: */
4989       /* case DNTT_TYPE_INLN: */
4990       /* case DNTT_TYPE_INLN_LIST: */
4991       /* case DNTT_TYPE_ALIAS: */
4992     default:
4993       /* A fancy way of returning NULL */
4994       return lookup_fundamental_type (objfile, FT_VOID);
4995     }
4996 }
4997
4998 static sltpointer
4999 hpread_record_lines (struct subfile *subfile, sltpointer s_idx,
5000                      sltpointer e_idx, struct objfile *objfile,
5001                      CORE_ADDR offset)
5002 {
5003   union sltentry *sl_bufp;
5004
5005   while (s_idx <= e_idx)
5006     {
5007       sl_bufp = hpread_get_slt (s_idx, objfile);
5008       /* Only record "normal" entries in the SLT.  */
5009       if (sl_bufp->snorm.sltdesc == SLT_NORMAL
5010           || sl_bufp->snorm.sltdesc == SLT_EXIT)
5011         record_line (subfile, sl_bufp->snorm.line,
5012                      sl_bufp->snorm.address + offset);
5013       else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
5014         record_line (subfile, sl_bufp->snormoff.line,
5015                      sl_bufp->snormoff.address + offset);
5016       s_idx++;
5017     }
5018   return e_idx;
5019 }
5020
5021 /* Given a function "f" which is a member of a class, find
5022  * the classname that it is a member of. Used to construct
5023  * the name (e.g., "c::f") which GDB will put in the
5024  * "demangled name" field of the function's symbol.
5025  * Called from hpread_process_one_debug_symbol()
5026  * If "f" is not a member function, return NULL.
5027  */
5028 static char *
5029 class_of (struct type *functype)
5030 {
5031   struct type *first_param_type;
5032   char *first_param_name;
5033   struct type *pointed_to_type;
5034   char *class_name;
5035
5036   /* Check that the function has a first argument "this",
5037    * and that "this" is a pointer to a class. If not,
5038    * functype is not a member function, so return NULL.
5039    */
5040   if (TYPE_NFIELDS (functype) == 0)
5041     return NULL;
5042   first_param_name = TYPE_FIELD_NAME (functype, 0);
5043   if (first_param_name == NULL)
5044     return NULL;                /* paranoia */
5045   if (strcmp (first_param_name, "this"))
5046     return NULL;
5047   first_param_type = TYPE_FIELD_TYPE (functype, 0);
5048   if (first_param_type == NULL)
5049     return NULL;                /* paranoia */
5050   if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR)
5051     return NULL;
5052
5053   /* Get the thing that "this" points to, check that
5054    * it's a class, and get its class name.
5055    */
5056   pointed_to_type = TYPE_TARGET_TYPE (first_param_type);
5057   if (pointed_to_type == NULL)
5058     return NULL;                /* paranoia */
5059   if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS)
5060     return NULL;
5061   class_name = TYPE_NAME (pointed_to_type);
5062   if (class_name == NULL)
5063     return NULL;                /* paranoia */
5064
5065   /* The class name may be of the form "class c", in which case
5066    * we want to strip off the leading "class ".
5067    */
5068   if (strncmp (class_name, "class ", 6) == 0)
5069     class_name += 6;
5070
5071   return class_name;
5072 }
5073
5074 /* Internalize one native debug symbol.
5075  * Called in a loop from hpread_expand_symtab().
5076  * Arguments:
5077  *   dn_bufp:
5078  *   name:
5079  *   section_offsets:
5080  *   objfile:
5081  *   text_offset:
5082  *   text_size:
5083  *   filename:
5084  *   index:             Index of this symbol
5085  *   at_module_boundary_p Pointer to boolean flag to control caller's loop.
5086  */
5087
5088 static void
5089 hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name,
5090                                  struct section_offsets *section_offsets,
5091                                  struct objfile *objfile, CORE_ADDR text_offset,
5092                                  int text_size, char *filename, int index,
5093                                  int *at_module_boundary_p)
5094 {
5095   unsigned long desc;
5096   int type;
5097   CORE_ADDR valu;
5098   int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
5099   int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
5100   union dnttentry *dn_temp;
5101   dnttpointer hp_type;
5102   struct symbol *sym;
5103   struct context_stack *new;
5104   char *class_scope_name;
5105
5106   /* Allocate one GDB debug symbol and fill in some default values. */
5107   sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5108                                          sizeof (struct symbol));
5109   memset (sym, 0, sizeof (struct symbol));
5110   DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->objfile_obstack);
5111   SYMBOL_LANGUAGE (sym) = language_auto;
5112   SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5113   SYMBOL_LINE (sym) = 0;
5114   SYMBOL_VALUE (sym) = 0;
5115   SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5116
5117   /* Just a trick in case the SOM debug symbol is a type definition.
5118    * There are routines that are set up to build a GDB type symbol, given
5119    * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5120    * This allows us to call those same routines.
5121    */
5122   hp_type.dnttp.extension = 1;
5123   hp_type.dnttp.immediate = 0;
5124   hp_type.dnttp.global = 0;
5125   hp_type.dnttp.index = index;
5126
5127   /* This "type" is the type of SOM record.
5128    * Switch on SOM type.
5129    */
5130   type = dn_bufp->dblock.kind;
5131   switch (type)
5132     {
5133     case DNTT_TYPE_SRCFILE:
5134       /* This type of symbol indicates from which source file or
5135        * include file any following data comes. It may indicate:
5136        *
5137        * o   The start of an entirely new source file (and thus
5138        *     a new module)
5139        *
5140        * o   The start of a different source file due to #include
5141        *
5142        * o   The end of an include file and the return to the original
5143        *     file. Thus if "foo.c" includes "bar.h", we see first
5144        *     a SRCFILE for foo.c, then one for bar.h, and then one for
5145        *     foo.c again.
5146        *
5147        * If it indicates the start of a new module then we must
5148        * finish the symbol table of the previous module
5149        * (if any) and start accumulating a new symbol table.
5150        */
5151
5152       valu = text_offset;
5153       if (!last_source_file)
5154         {
5155           /*
5156            * A note on "last_source_file": this is a char* pointing
5157            * to the actual file name.  "start_symtab" sets it,
5158            * "end_symtab" clears it.
5159            *
5160            * So if "last_source_file" is NULL, then either this is
5161            * the first record we are looking at, or a previous call
5162            * to "end_symtab()" was made to close out the previous
5163            * module.  Since we're now quitting the scan loop when we
5164            * see a MODULE END record, we should never get here, except
5165            * in the case that we're not using the quick look-up tables
5166            * and have to use the old system as a fall-back.
5167            */
5168           start_symtab (name, NULL, valu);
5169           record_debugformat ("HP");
5170           SL_INDEX (objfile) = dn_bufp->dsfile.address;
5171         }
5172
5173       else
5174         {
5175           /* Either a new include file, or a SRCFILE record
5176            * saying we are back in the main source (or out of
5177            * a nested include file) again.
5178            */
5179           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5180                                                     SL_INDEX (objfile),
5181                                                     dn_bufp->dsfile.address,
5182                                                     objfile, offset);
5183         }
5184
5185       /* A note on "start_subfile".  This routine will check
5186        * the name we pass it and look for an existing subfile
5187        * of that name.  There's thus only one sub-file for the
5188        * actual source (e.g. for "foo.c" in foo.c), despite the
5189        * fact that we'll see lots of SRCFILE entries for foo.c
5190        * inside foo.c.
5191        */
5192       start_subfile (name, NULL);
5193       break;
5194
5195     case DNTT_TYPE_MODULE:
5196       /*
5197        * We no longer ignore DNTT_TYPE_MODULE symbols.  The module
5198        * represents the meaningful semantic structure of a compilation
5199        * unit.  We expect to start the psymtab-to-symtab expansion
5200        * looking at a MODULE entry, and to end it at the corresponding
5201        * END MODULE entry.
5202        *
5203        *--Begin outdated comments
5204        *
5205        * This record signifies the start of a new source module
5206        * In C/C++ there is no explicit "module" construct in the language,
5207        * but each compilation unit is implicitly a module and they
5208        * do emit the DNTT_TYPE_MODULE records.
5209        * The end of the module is marked by a matching DNTT_TYPE_END record.
5210        *
5211        * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5212        * is it notices the DNTT_TYPE_END record for the previous
5213        * module (see comments under DNTT_TYPE_END case), and then treats
5214        * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5215        * (i.e., it makes a start_symtab() call).
5216        * This scheme seems a little convoluted, but I'll leave it
5217        * alone on the principle "if it ain't broke don't fix
5218        * it". (RT).
5219        *
5220        *-- End outdated comments
5221        */
5222
5223       valu = text_offset;
5224       if (!last_source_file)
5225         {
5226           /* Start of a new module. We know this because "last_source_file"
5227            * is NULL, which can only happen the first time or if we just
5228            * made a call to end_symtab() to close out the previous module.
5229            */
5230           start_symtab (name, NULL, valu);
5231           SL_INDEX (objfile) = dn_bufp->dmodule.address;
5232         }
5233       else
5234         {
5235           /* This really shouldn't happen if we're using the quick
5236            * look-up tables, as it would mean we'd scanned past an
5237            * END MODULE entry.  But if we're not using the tables,
5238            * we started the module on the SRCFILE entry, so it's ok.
5239            * For now, accept this.
5240            */
5241           /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5242            *           name );
5243            */
5244           *at_module_boundary_p = -1;
5245         }
5246
5247       start_subfile (name, NULL);
5248       break;
5249
5250     case DNTT_TYPE_FUNCTION:
5251     case DNTT_TYPE_ENTRY:
5252       /* A function or secondary entry point.  */
5253       valu = dn_bufp->dfunc.lowaddr + offset;
5254
5255       /* Record lines up to this point. */
5256       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5257                                                 SL_INDEX (objfile),
5258                                                 dn_bufp->dfunc.address,
5259                                                 objfile, offset);
5260
5261       WITHIN_FUNCTION (objfile) = 1;
5262       CURRENT_FUNCTION_VALUE (objfile) = valu;
5263
5264       /* Stack must be empty now.  */
5265       if (context_stack_depth != 0)
5266         lbrac_unmatched_complaint (symnum);
5267       new = push_context (0, valu);
5268
5269       /* Built a type for the function. This includes processing
5270        * the symbol records for the function parameters.
5271        */
5272       SYMBOL_CLASS (sym) = LOC_BLOCK;
5273       SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1);
5274
5275       /* All functions in C++ have prototypes.  For C we don't have enough
5276          information in the debug info.  */
5277       if (SYMBOL_LANGUAGE (sym) == language_cplus)
5278         TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
5279
5280       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5281        * (if any), which we get from the "alias" field of the SOM record
5282        * if that exists.
5283        */
5284       if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5285           dn_bufp->dfunc.alias &&       /* has an alias */
5286           *(char *) (VT (objfile) + dn_bufp->dfunc.alias))      /* not a null string */
5287         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias;
5288       else
5289         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5290
5291       /* Special hack to get around HP compilers' insistence on
5292        * reporting "main" as "_MAIN_" for C/C++ */
5293       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5294           (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0))
5295         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5296
5297       /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5298        * be the demangled name.
5299        */
5300       if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5301         {
5302           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5303            * calling the demangler in libiberty (cplus_demangle()) to
5304            * do the job. This generally does the job, even though
5305            * it's intended for the GNU compiler and not the aCC compiler
5306            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5307            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5308            * Generally, we don't want params when we display
5309            * a demangled name, but when I took out the DMGL_PARAMS,
5310            * some things broke, so I'm leaving it in here, and
5311            * working around the issue in stack.c. - RT
5312            */
5313           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack);
5314           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) &&
5315               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5316             {
5317
5318               /* Well, the symbol name is mangled, but the
5319                * demangler in libiberty failed so the demangled
5320                * field is still NULL. Try to
5321                * do the job ourselves based on the "name" field
5322                * in the SOM record. A complication here is that
5323                * the name field contains only the function name
5324                * (like "f"), whereas we want the class qualification
5325                * (as in "c::f"). Try to reconstruct that.
5326                */
5327               char *basename;
5328               char *classname;
5329               char *dem_name;
5330               basename = VT (objfile) + dn_bufp->dfunc.name;
5331               classname = class_of (SYMBOL_TYPE (sym));
5332               if (classname)
5333                 {
5334                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5335                   strcpy (dem_name, classname);
5336                   strcat (dem_name, "::");
5337                   strcat (dem_name, basename);
5338                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5339                   SYMBOL_LANGUAGE (sym) = language_cplus;
5340                 }
5341             }
5342         }
5343
5344       /* Add the function symbol to the list of symbols in this blockvector */
5345       if (dn_bufp->dfunc.global)
5346         add_symbol_to_list (sym, &global_symbols);
5347       else
5348         add_symbol_to_list (sym, &file_symbols);
5349       new->name = sym;
5350
5351       /* Search forward to the next BEGIN and also read
5352        * in the line info up to that point.
5353        * Not sure why this is needed.
5354        * In HP FORTRAN this code is harmful since there
5355        * may not be a BEGIN after the FUNCTION.
5356        * So I made it C/C++ specific. - RT
5357        */
5358       if (dn_bufp->dfunc.language == HP_LANGUAGE_C ||
5359           dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5360         {
5361           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5362             {
5363               dn_bufp = hpread_get_lntt (++index, objfile);
5364               if (dn_bufp->dblock.extension)
5365                 continue;
5366             }
5367           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5368                                                     SL_INDEX (objfile),
5369                                                     dn_bufp->dbegin.address,
5370                                                     objfile, offset);
5371           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5372         }
5373       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5374       break;
5375
5376     case DNTT_TYPE_DOC_FUNCTION:
5377       valu = dn_bufp->ddocfunc.lowaddr + offset;
5378
5379       /* Record lines up to this point. */
5380       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5381                                                 SL_INDEX (objfile),
5382                                                 dn_bufp->ddocfunc.address,
5383                                                 objfile, offset);
5384
5385       WITHIN_FUNCTION (objfile) = 1;
5386       CURRENT_FUNCTION_VALUE (objfile) = valu;
5387       /* Stack must be empty now.  */
5388       if (context_stack_depth != 0)
5389         lbrac_unmatched_complaint (symnum);
5390       new = push_context (0, valu);
5391
5392       /* Built a type for the function. This includes processing
5393        * the symbol records for the function parameters.
5394        */
5395       SYMBOL_CLASS (sym) = LOC_BLOCK;
5396       SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1);
5397
5398       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5399        * (if any), which we get from the "alias" field of the SOM record
5400        * if that exists.
5401        */
5402       if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5403           dn_bufp->ddocfunc.alias &&    /* has an alias */
5404           *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias))   /* not a null string */
5405         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias;
5406       else
5407         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5408
5409       /* Special hack to get around HP compilers' insistence on
5410        * reporting "main" as "_MAIN_" for C/C++ */
5411       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5412           (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0))
5413         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5414
5415       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5416         {
5417
5418           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5419            * calling the demangler in libiberty (cplus_demangle()) to
5420            * do the job. This generally does the job, even though
5421            * it's intended for the GNU compiler and not the aCC compiler
5422            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5423            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5424            * Generally, we don't want params when we display
5425            * a demangled name, but when I took out the DMGL_PARAMS,
5426            * some things broke, so I'm leaving it in here, and
5427            * working around the issue in stack.c. - RT
5428            */
5429           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack);
5430
5431           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) &&
5432               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5433             {
5434
5435               /* Well, the symbol name is mangled, but the
5436                * demangler in libiberty failed so the demangled
5437                * field is still NULL. Try to
5438                * do the job ourselves based on the "name" field
5439                * in the SOM record. A complication here is that
5440                * the name field contains only the function name
5441                * (like "f"), whereas we want the class qualification
5442                * (as in "c::f"). Try to reconstruct that.
5443                */
5444               char *basename;
5445               char *classname;
5446               char *dem_name;
5447               basename = VT (objfile) + dn_bufp->ddocfunc.name;
5448               classname = class_of (SYMBOL_TYPE (sym));
5449               if (classname)
5450                 {
5451                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5452                   strcpy (dem_name, classname);
5453                   strcat (dem_name, "::");
5454                   strcat (dem_name, basename);
5455                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5456                   SYMBOL_LANGUAGE (sym) = language_cplus;
5457                 }
5458             }
5459         }
5460
5461       /* Add the function symbol to the list of symbols in this blockvector */
5462       if (dn_bufp->ddocfunc.global)
5463         add_symbol_to_list (sym, &global_symbols);
5464       else
5465         add_symbol_to_list (sym, &file_symbols);
5466       new->name = sym;
5467
5468       /* Search forward to the next BEGIN and also read
5469        * in the line info up to that point.
5470        * Not sure why this is needed.
5471        * In HP FORTRAN this code is harmful since there
5472        * may not be a BEGIN after the FUNCTION.
5473        * So I made it C/C++ specific. - RT
5474        */
5475       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C ||
5476           dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5477         {
5478           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5479             {
5480               dn_bufp = hpread_get_lntt (++index, objfile);
5481               if (dn_bufp->dblock.extension)
5482                 continue;
5483             }
5484           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5485                                                     SL_INDEX (objfile),
5486                                                     dn_bufp->dbegin.address,
5487                                                     objfile, offset);
5488           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5489         }
5490       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5491       break;
5492
5493     case DNTT_TYPE_BEGIN:
5494       /* Begin a new scope. */
5495       if (context_stack_depth == 1 /* this means we're at function level */  &&
5496           context_stack[0].name != NULL /* this means it's a function */  &&
5497           context_stack[0].depth == 0   /* this means it's the first BEGIN
5498                                            we've seen after the FUNCTION */
5499         )
5500         {
5501           /* This is the first BEGIN after a FUNCTION.
5502            * We ignore this one, since HP compilers always insert
5503            * at least one BEGIN, i.e. it's:
5504            *
5505            *     FUNCTION
5506            *     argument symbols
5507            *     BEGIN
5508            *     local symbols
5509            *        (possibly nested BEGIN ... END's if there are inner { } blocks)
5510            *     END
5511            *     END
5512            *
5513            * By ignoring this first BEGIN, the local symbols get treated
5514            * as belonging to the function scope, and "print func::local_sym"
5515            * works (which is what we want).
5516            */
5517
5518           /* All we do here is increase the depth count associated with
5519            * the FUNCTION entry in the context stack. This ensures that
5520            * the next BEGIN we see (if any), representing a real nested { }
5521            * block, will get processed.
5522            */
5523
5524           context_stack[0].depth++;
5525
5526         }
5527       else
5528         {
5529
5530           /* Record lines up to this SLT pointer. */
5531           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5532                                                     SL_INDEX (objfile),
5533                                                     dn_bufp->dbegin.address,
5534                                                     objfile, offset);
5535           /* Calculate start address of new scope */
5536           valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
5537           valu += offset;       /* Relocate for dynamic loading */
5538           /* We use the scope start DNTT index as nesting depth identifier! */
5539           desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile);
5540           new = push_context (desc, valu);
5541         }
5542       break;
5543
5544     case DNTT_TYPE_END:
5545       /* End a scope.  */
5546
5547       /* Valid end kinds are:
5548        *  MODULE
5549        *  FUNCTION
5550        *  WITH
5551        *  COMMON
5552        *  BEGIN
5553        *  CLASS_SCOPE
5554        */
5555
5556       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5557                                                 SL_INDEX (objfile),
5558                                                 dn_bufp->dend.address,
5559                                                 objfile, offset);
5560       switch (dn_bufp->dend.endkind)
5561         {
5562         case DNTT_TYPE_MODULE:
5563           /* Ending a module ends the symbol table for that module.
5564            * Calling end_symtab() has the side effect of clearing the
5565            * last_source_file pointer, which in turn signals
5566            * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5567            * record as a module-begin.
5568            */
5569           valu = text_offset + text_size + offset;
5570
5571           /* Tell our caller that we're done with expanding the
5572            * debug information for a module.
5573            */
5574           *at_module_boundary_p = 1;
5575
5576           /* Don't do this, as our caller will do it!
5577
5578            *      (void) end_symtab (valu, objfile, 0);
5579            */
5580           break;
5581
5582         case DNTT_TYPE_FUNCTION:
5583           /* Ending a function, well, ends the function's scope.  */
5584           dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
5585                                      objfile);
5586           valu = dn_temp->dfunc.hiaddr + offset;
5587           /* Insert func params into local list */
5588           merge_symbol_lists (&param_symbols, &local_symbols);
5589           new = pop_context ();
5590           /* Make a block for the local symbols within.  */
5591           finish_block (new->name, &local_symbols, new->old_blocks,
5592                         new->start_addr, valu, objfile);
5593           WITHIN_FUNCTION (objfile) = 0;        /* This may have to change for Pascal */
5594           local_symbols = new->locals;
5595           param_symbols = new->params;
5596           break;
5597
5598         case DNTT_TYPE_BEGIN:
5599           if (context_stack_depth == 1 &&
5600               context_stack[0].name != NULL &&
5601               context_stack[0].depth == 1)
5602             {
5603               /* This is the END corresponding to the
5604                * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5605                */
5606               context_stack[0].depth--;
5607             }
5608           else
5609             {
5610               /* Ending a local scope.  */
5611               valu = hpread_get_location (dn_bufp->dend.address, objfile);
5612               /* Why in the hell is this needed?  */
5613               valu += offset + 9;       /* Relocate for dynamic loading */
5614               new = pop_context ();
5615               desc = dn_bufp->dend.beginscope.dnttp.index;
5616               if (desc != new->depth)
5617                 lbrac_mismatch_complaint (symnum);
5618
5619               /* Make a block for the local symbols within.  */
5620               finish_block (new->name, &local_symbols, new->old_blocks,
5621                             new->start_addr, valu, objfile);
5622               local_symbols = new->locals;
5623               param_symbols = new->params;
5624             }
5625           break;
5626
5627         case DNTT_TYPE_WITH:
5628           /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5629            * we can ignore the DNTT_TYPE_END that ends it.
5630            */
5631           break;
5632
5633         case DNTT_TYPE_COMMON:
5634           /* End a FORTRAN common block. We don't currently handle these */
5635           complaint (&symfile_complaints,
5636                      _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n"));
5637           break;
5638
5639         case DNTT_TYPE_CLASS_SCOPE:
5640
5641           /* pai: FIXME Not handling nested classes for now -- must
5642              * maintain a stack */
5643           class_scope_name = NULL;
5644
5645 #if 0
5646           /* End a class scope */
5647           valu = hpread_get_location (dn_bufp->dend.address, objfile);
5648           /* Why in the hell is this needed?  */
5649           valu += offset + 9;   /* Relocate for dynamic loading */
5650           new = pop_context ();
5651           desc = dn_bufp->dend.beginscope.dnttp.index;
5652           if (desc != new->depth)
5653             lbrac_mismatch_complaint ((char *) symnum);
5654           /* Make a block for the local symbols within.  */
5655           finish_block (new->name, &local_symbols, new->old_blocks,
5656                         new->start_addr, valu, objfile);
5657           local_symbols = new->locals;
5658           param_symbols = new->params;
5659 #endif
5660           break;
5661
5662         default:
5663           complaint (&symfile_complaints,
5664                      _("internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind."));
5665           break;
5666         }
5667       break;
5668
5669       /* DNTT_TYPE_IMPORT is not handled */
5670
5671     case DNTT_TYPE_LABEL:
5672       SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
5673       break;
5674
5675     case DNTT_TYPE_FPARAM:
5676       /* Function parameters.  */
5677       /* Note 1: This code was present in the 4.16 sources, and then
5678          removed, because fparams are handled in
5679          hpread_read_function_type().  However, while fparam symbols
5680          are indeed handled twice, this code here cannot be removed
5681          because then they don't get added to the local symbol list of
5682          the function's code block, which leads to a failure to look
5683          up locals, "this"-relative member names, etc.  So I've put
5684          this code back in. pai/1997-07-21 */
5685       /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5686          in hpread_read_function_type(), so FPARAMS had to be handled
5687          here.  I changed the location to be the appropriate argument
5688          kinds rather than LOC_LOCAL. pai/1997-08-08 */
5689       /* Note 3: Well, the fix in Note 2 above broke argument printing
5690          in traceback frames, and further it makes assumptions about the
5691          order of the FPARAM entries from HP compilers (cc and aCC in particular
5692          generate them in reverse orders -- fixing one breaks for the other).
5693          So I've added code in hpread_read_function_type() to add fparams
5694          to a param_symbols list for the current context level.  These are
5695          then merged into local_symbols when a function end is reached.
5696          pai/1997-08-11 */
5697
5698       break;                    /* do nothing; handled in hpread_read_function_type() */
5699
5700 #if 0                           /* Old code */
5701       if (dn_bufp->dfparam.regparam)
5702         SYMBOL_CLASS (sym) = LOC_REGISTER;
5703       else if (dn_bufp->dfparam.indirect)
5704         SYMBOL_CLASS (sym) = LOC_REF_ARG;
5705       else
5706         SYMBOL_CLASS (sym) = LOC_ARG;
5707       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5708       if (dn_bufp->dfparam.copyparam)
5709         {
5710           SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5711           SYMBOL_VALUE (sym)
5712             += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
5713         }
5714       else
5715         SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5716       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
5717       add_symbol_to_list (sym, &fparam_symbols);
5718       break;
5719 #endif
5720
5721     case DNTT_TYPE_SVAR:
5722       /* Static variables.  */
5723       SYMBOL_CLASS (sym) = LOC_STATIC;
5724
5725       /* Note: There is a case that arises with globals in shared
5726        * libraries where we need to set the address to LOC_INDIRECT.
5727        * This case is if you have a global "g" in one library, and
5728        * it is referenced "extern <type> g;" in another library.
5729        * If we're processing the symbols for the referencing library,
5730        * we'll see a global "g", but in this case the address given
5731        * in the symbol table contains a pointer to the real "g".
5732        * We use the storage class LOC_INDIRECT to indicate this. RT
5733        */
5734       if (is_in_import_list (DEPRECATED_SYMBOL_NAME (sym), objfile))
5735         SYMBOL_CLASS (sym) = LOC_INDIRECT;
5736
5737       SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset;
5738       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
5739
5740       if (dn_bufp->dsvar.global)
5741         add_symbol_to_list (sym, &global_symbols);
5742
5743       else if (WITHIN_FUNCTION (objfile))
5744         add_symbol_to_list (sym, &local_symbols);
5745
5746       else
5747         add_symbol_to_list (sym, &file_symbols);
5748
5749       if (dn_bufp->dsvar.thread_specific)
5750         {
5751           /* Thread-local variable.
5752            */
5753           SYMBOL_CLASS (sym) = LOC_HP_THREAD_LOCAL_STATIC;
5754           SYMBOL_BASEREG (sym) = HPPA_CR27_REGNUM;
5755
5756           if (objfile->flags & OBJF_SHARED)
5757             {
5758               /*
5759                * This variable is not only thread local but
5760                * in a shared library.
5761                *
5762                * Alas, the shared lib structures are private
5763                * to "somsolib.c".  But C lets us point to one.
5764                */
5765               struct so_list *so;
5766               struct hppa_objfile_private *priv;
5767
5768               priv = (struct hppa_objfile_private *)
5769                 objfile_data (objfile, hppa_objfile_priv_data);
5770               if (priv == NULL)
5771                 error (_("Internal error in reading shared library information."));
5772
5773               so = ((struct hppa_objfile_private *) priv)->so_info;
5774               if (so == NULL)
5775                 error (_("Internal error in reading shared library information."));
5776
5777               /* Thread-locals in shared libraries do NOT have the
5778                * standard offset ("data_offset"), so we re-calculate
5779                * where to look for this variable, using a call-back
5780                * to interpret the private shared-library data.
5781                */
5782               SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location +
5783                 gdbarch_tdep (current_gdbarch)->solib_thread_start_addr (so);
5784             }
5785         }
5786       break;
5787
5788     case DNTT_TYPE_DVAR:
5789       /* Dynamic variables.  */
5790       if (dn_bufp->ddvar.regvar)
5791         SYMBOL_CLASS (sym) = LOC_REGISTER;
5792       else
5793         SYMBOL_CLASS (sym) = LOC_LOCAL;
5794
5795       SYMBOL_VALUE (sym) = dn_bufp->ddvar.location;
5796       SYMBOL_VALUE (sym)
5797         += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
5798       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
5799       if (dn_bufp->ddvar.global)
5800         add_symbol_to_list (sym, &global_symbols);
5801       else if (WITHIN_FUNCTION (objfile))
5802         add_symbol_to_list (sym, &local_symbols);
5803       else
5804         add_symbol_to_list (sym, &file_symbols);
5805       break;
5806
5807     case DNTT_TYPE_CONST:
5808       /* A constant (pascal?).  */
5809       SYMBOL_CLASS (sym) = LOC_CONST;
5810       SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
5811       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
5812       if (dn_bufp->dconst.global)
5813         add_symbol_to_list (sym, &global_symbols);
5814       else if (WITHIN_FUNCTION (objfile))
5815         add_symbol_to_list (sym, &local_symbols);
5816       else
5817         add_symbol_to_list (sym, &file_symbols);
5818       break;
5819
5820     case DNTT_TYPE_TYPEDEF:
5821       /* A typedef. We do want to process these, since a name is
5822        * added to the domain for the typedef'ed name.
5823        */
5824       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5825       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5826       if (dn_bufp->dtype.global)
5827         add_symbol_to_list (sym, &global_symbols);
5828       else if (WITHIN_FUNCTION (objfile))
5829         add_symbol_to_list (sym, &local_symbols);
5830       else
5831         add_symbol_to_list (sym, &file_symbols);
5832       break;
5833
5834     case DNTT_TYPE_TAGDEF:
5835       {
5836         int global = dn_bufp->dtag.global;
5837         /* Structure, union, enum, template, or class tag definition */
5838         /* We do want to process these, since a name is
5839          * added to the domain for the tag name (and if C++ class,
5840          * for the typename also).
5841          */
5842         SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5843
5844         /* The tag contains in its "type" field a pointer to the
5845          * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5846          * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5847          * record that actually defines the type.
5848          */
5849         SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5850         TYPE_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5851         TYPE_TAG_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5852         if (dn_bufp->dtag.global)
5853           add_symbol_to_list (sym, &global_symbols);
5854         else if (WITHIN_FUNCTION (objfile))
5855           add_symbol_to_list (sym, &local_symbols);
5856         else
5857           add_symbol_to_list (sym, &file_symbols);
5858
5859         /* If this is a C++ class, then we additionally
5860          * need to define a typedef for the
5861          * class type. E.g., so that the name "c" becomes visible as
5862          * a type name when the user says "class c { ... }".
5863          * In order to figure this out, we need to chase down the "type"
5864          * field to get to the DNTT_TYPE_CLASS record.
5865          *
5866          * We also add the typename for ENUM. Though this isn't
5867          * strictly correct, it is necessary because of the debug info
5868          * generated by the aCC compiler, in which we cannot
5869          * distinguish between:
5870          *   enum e { ... };
5871          * and
5872          *   typedef enum { ... } e;
5873          * I.e., the compiler emits the same debug info for the above
5874          * two cases, in both cases "e" appearing as a tagdef.
5875          * Therefore go ahead and generate the typename so that
5876          * "ptype e" will work in the above cases.
5877          *
5878          * We also add the typename for TEMPLATE, so as to allow "ptype t"
5879          * when "t" is a template name.
5880          */
5881         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
5882           dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
5883         else
5884           {
5885             complaint (&symfile_complaints, _("error processing class tagdef"));
5886             return;
5887           }
5888         if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
5889             dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
5890             dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
5891           {
5892             struct symbol *newsym;
5893
5894             newsym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5895                                                     sizeof (struct symbol));
5896             memset (newsym, 0, sizeof (struct symbol));
5897             DEPRECATED_SYMBOL_NAME (newsym) = name;
5898             SYMBOL_LANGUAGE (newsym) = language_auto;
5899             SYMBOL_DOMAIN (newsym) = VAR_DOMAIN;
5900             SYMBOL_LINE (newsym) = 0;
5901             SYMBOL_VALUE (newsym) = 0;
5902             SYMBOL_CLASS (newsym) = LOC_TYPEDEF;
5903             SYMBOL_TYPE (newsym) = sym->type;
5904             if (global)
5905               add_symbol_to_list (newsym, &global_symbols);
5906             else if (WITHIN_FUNCTION (objfile))
5907               add_symbol_to_list (newsym, &local_symbols);
5908             else
5909               add_symbol_to_list (newsym, &file_symbols);
5910           }
5911       }
5912       break;
5913
5914     case DNTT_TYPE_POINTER:
5915       /* Declares a pointer type. Should not be necessary to do anything
5916        * with the type at this level; these are processed
5917        * at the hpread_type_lookup() level.
5918        */
5919       break;
5920
5921     case DNTT_TYPE_ENUM:
5922       /* Declares an enum type. Should not be necessary to do anything
5923        * with the type at this level; these are processed
5924        * at the hpread_type_lookup() level.
5925        */
5926       break;
5927
5928     case DNTT_TYPE_MEMENUM:
5929       /* Member of enum */
5930       /* Ignored at this level, but hpread_read_enum_type() will take
5931        * care of walking the list of enumeration members.
5932        */
5933       break;
5934
5935     case DNTT_TYPE_SET:
5936       /* Declares a set type. Should not be necessary to do anything
5937        * with the type at this level; these are processed
5938        * at the hpread_type_lookup() level.
5939        */
5940       break;
5941
5942     case DNTT_TYPE_SUBRANGE:
5943       /* Declares a subrange type. Should not be necessary to do anything
5944        * with the type at this level; these are processed
5945        * at the hpread_type_lookup() level.
5946        */
5947       break;
5948
5949     case DNTT_TYPE_ARRAY:
5950       /* Declares an array type. Should not be necessary to do anything
5951        * with the type at this level; these are processed
5952        * at the hpread_type_lookup() level.
5953        */
5954       break;
5955
5956     case DNTT_TYPE_STRUCT:
5957     case DNTT_TYPE_UNION:
5958       /* Declares an struct/union type.
5959        * Should not be necessary to do anything
5960        * with the type at this level; these are processed
5961        * at the hpread_type_lookup() level.
5962        */
5963       break;
5964
5965     case DNTT_TYPE_FIELD:
5966       /* Structure/union/class field */
5967       /* Ignored at this level, but hpread_read_struct_type() will take
5968        * care of walking the list of structure/union/class members.
5969        */
5970       break;
5971
5972       /* DNTT_TYPE_VARIANT is not handled by GDB */
5973
5974       /* DNTT_TYPE_FILE is not handled by GDB */
5975
5976     case DNTT_TYPE_FUNCTYPE:
5977       /* Function type */
5978       /* Ignored at this level, handled within hpread_type_lookup() */
5979       break;
5980
5981     case DNTT_TYPE_WITH:
5982       /* This is emitted within methods to indicate "with <class>"
5983        * scoping rules (i.e., indicate that the class data members
5984        * are directly visible).
5985        * However, since GDB already infers this by looking at the
5986        * "this" argument, interpreting the DNTT_TYPE_WITH
5987        * symbol record is unnecessary.
5988        */
5989       break;
5990
5991     case DNTT_TYPE_COMMON:
5992       /* FORTRAN common. Not yet handled. */
5993       complaint (&symfile_complaints,
5994                  _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON."));
5995       break;
5996
5997       /* DNTT_TYPE_COBSTRUCT is not handled by GDB.  */
5998       /* DNTT_TYPE_XREF is not handled by GDB.  */
5999       /* DNTT_TYPE_SA is not handled by GDB.  */
6000       /* DNTT_TYPE_MACRO is not handled by GDB */
6001
6002     case DNTT_TYPE_BLOCKDATA:
6003       /* Not sure what this is - part of FORTRAN support maybe?
6004        * Anyway, not yet handled.
6005        */
6006       complaint (&symfile_complaints,
6007                  _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA."));
6008       break;
6009
6010     case DNTT_TYPE_CLASS_SCOPE:
6011
6012
6013
6014       /* The compiler brackets member functions with a CLASS_SCOPE/END
6015        * pair of records, presumably to put them in a different scope
6016        * from the module scope where they are normally defined.
6017        * E.g., in the situation:
6018        *   void f() { ... }
6019        *   void c::f() { ...}
6020        * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
6021        * This causes "break f" at the module level to pick the
6022        * the file-level function f(), not the member function
6023        * (which needs to be referenced via "break c::f").
6024        *
6025        * Here we record the class name to generate the demangled names of
6026        * member functions later.
6027        *
6028        * FIXME Not being used now for anything -- cplus_demangle seems
6029        * enough for getting the class-qualified names of functions. We
6030        * may need this for handling nested classes and types.  */
6031
6032       /* pai: FIXME Not handling nested classes for now -- need to
6033        * maintain a stack */
6034
6035       dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile);
6036       if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF)
6037         class_scope_name = VT (objfile) + dn_temp->dtag.name;
6038       else
6039         class_scope_name = NULL;
6040
6041 #if 0
6042
6043       /* Begin a new scope.  */
6044       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
6045                                                 SL_INDEX (objfile),
6046                                               dn_bufp->dclass_scope.address,
6047                                                 objfile, offset);
6048       valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile);
6049       valu += offset;           /* Relocate for dynamic loading */
6050       desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile);
6051       /* We use the scope start DNTT index as the nesting depth identifier! */
6052       new = push_context (desc, valu);
6053 #endif
6054       break;
6055
6056     case DNTT_TYPE_REFERENCE:
6057       /* Declares a C++ reference type. Should not be necessary to do anything
6058        * with the type at this level; these are processed
6059        * at the hpread_type_lookup() level.
6060        */
6061       break;
6062
6063     case DNTT_TYPE_PTRMEM:
6064       /* Declares a C++ pointer-to-data-member type. This does not
6065        * need to be handled at this level; being a type description it
6066        * is instead handled at the hpread_type_lookup() level.
6067        */
6068       break;
6069
6070     case DNTT_TYPE_PTRMEMFUNC:
6071       /* Declares a C++ pointer-to-function-member type. This does not
6072        * need to be handled at this level; being a type description it
6073        * is instead handled at the hpread_type_lookup() level.
6074        */
6075       break;
6076
6077     case DNTT_TYPE_CLASS:
6078       /* Declares a class type.
6079        * Should not be necessary to do anything
6080        * with the type at this level; these are processed
6081        * at the hpread_type_lookup() level.
6082        */
6083       break;
6084
6085     case DNTT_TYPE_GENFIELD:
6086       /* I believe this is used for class member functions */
6087       /* Ignored at this level, but hpread_read_struct_type() will take
6088        * care of walking the list of class members.
6089        */
6090       break;
6091
6092     case DNTT_TYPE_VFUNC:
6093       /* Virtual function */
6094       /* This does not have to be handled at this level; handled in
6095        * the course of processing class symbols.
6096        */
6097       break;
6098
6099     case DNTT_TYPE_MEMACCESS:
6100       /* DDE ignores this symbol table record.
6101        * It has something to do with "modified access" to class members.
6102        * I'll assume we can safely ignore it too.
6103        */
6104       break;
6105
6106     case DNTT_TYPE_INHERITANCE:
6107       /* These don't have to be handled here, since they are handled
6108        * within hpread_read_struct_type() in the process of constructing
6109        * a class type.
6110        */
6111       break;
6112
6113     case DNTT_TYPE_FRIEND_CLASS:
6114     case DNTT_TYPE_FRIEND_FUNC:
6115       /* These can safely be ignored, as GDB doesn't need this
6116        * info. DDE only uses it in "describe". We may later want
6117        * to extend GDB's "ptype" to give this info, but for now
6118        * it seems safe enough to ignore it.
6119        */
6120       break;
6121
6122     case DNTT_TYPE_MODIFIER:
6123       /* Intended to supply "modified access" to a type */
6124       /* From the way DDE handles this, it looks like it always
6125        * modifies a type. Therefore it is safe to ignore it at this
6126        * level, and handle it in hpread_type_lookup().
6127        */
6128       break;
6129
6130     case DNTT_TYPE_OBJECT_ID:
6131       /* Just ignore this - that's all DDE does */
6132       break;
6133
6134     case DNTT_TYPE_MEMFUNC:
6135       /* Member function */
6136       /* This does not have to be handled at this level; handled in
6137        * the course of processing class symbols.
6138        */
6139       break;
6140
6141     case DNTT_TYPE_DOC_MEMFUNC:
6142       /* Member function */
6143       /* This does not have to be handled at this level; handled in
6144        * the course of processing class symbols.
6145        */
6146       break;
6147
6148     case DNTT_TYPE_TEMPLATE:
6149       /* Template - sort of the header for a template definition,
6150        * which like a class, points to a member list and also points
6151        * to a TEMPLATE_ARG list of type-arguments.
6152        * We do not need to process TEMPLATE records at this level though.
6153        */
6154       break;
6155
6156     case DNTT_TYPE_TEMPLATE_ARG:
6157       /* The TEMPLATE record points to an argument list of
6158        * TEMPLATE_ARG records, each of which describes one
6159        * of the type-arguments.
6160        * We do not need to process TEMPLATE_ARG records at this level though.
6161        */
6162       break;
6163
6164     case DNTT_TYPE_FUNC_TEMPLATE:
6165       /* This will get emitted for member functions of templates.
6166        * But we don't need to process this record at this level though,
6167        * we will process it in the course of processing a TEMPLATE
6168        * record.
6169        */
6170       break;
6171
6172     case DNTT_TYPE_LINK:
6173       /* The LINK record is used to link up templates with instantiations. */
6174       /* It is not clear why this is needed, and furthermore aCC does
6175        * not appear to generate this, so I think we can safely ignore it. - RT
6176        */
6177       break;
6178
6179       /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6180       /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6181       /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6182       /* DNTT_TYPE_INLN is not handled by GDB */
6183       /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6184       /* DNTT_TYPE_ALIAS is not handled by GDB */
6185
6186     default:
6187       break;
6188     }
6189 }
6190
6191 /* Get nesting depth for a DNTT entry.
6192  * DN_BUFP points to a DNTT entry.
6193  * OBJFILE is the object file.
6194  * REPORT_NESTED is a flag; if 0, real nesting depth is
6195  * reported, if it is 1, the function simply returns a
6196  * non-zero value if the nesting depth is anything > 0.
6197  *
6198  * Return value is an integer.  0 => not a local type / name
6199  * positive return => type or name is local to some
6200  * block or function.
6201  */
6202
6203
6204 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6205    this function now returns 0 right away. It was taking too much time
6206    at start up. Now, though, the local types are not handled correctly.
6207  */
6208
6209
6210 static int
6211 hpread_get_scope_depth (union dnttentry *dn_bufp, struct objfile *objfile,
6212                         int report_nested)
6213 {
6214   int index;
6215   union dnttentry *dn_tmp;
6216   short depth = 0;
6217 /****************************/
6218   return 0;
6219 /****************************/
6220
6221   index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block));
6222
6223   while (--index >= 0)
6224     {
6225       dn_tmp = hpread_get_lntt (index, objfile);
6226       switch (dn_tmp->dblock.kind)
6227         {
6228         case DNTT_TYPE_MODULE:
6229           return depth;
6230         case DNTT_TYPE_END:
6231           /* index is signed int; dnttp.index is 29-bit unsigned int! */
6232           index = (int) dn_tmp->dend.beginscope.dnttp.index;
6233           break;
6234         case DNTT_TYPE_BEGIN:
6235         case DNTT_TYPE_FUNCTION:
6236         case DNTT_TYPE_DOC_FUNCTION:
6237         case DNTT_TYPE_WITH:
6238         case DNTT_TYPE_COMMON:
6239         case DNTT_TYPE_CLASS_SCOPE:
6240           depth++;
6241           if (report_nested)
6242             return 1;
6243           break;
6244         default:
6245           break;
6246         }
6247     }
6248   return depth;
6249 }
6250
6251 /* Adjust the bitoffsets for all fields of an anonymous union of
6252    type TYPE by negative BITS.  This handles HP aCC's hideous habit
6253    of giving members of anonymous unions bit offsets relative to the
6254    enclosing structure instead of relative to the union itself. */
6255
6256 static void
6257 hpread_adjust_bitoffsets (struct type *type, int bits)
6258 {
6259   int i;
6260
6261   /* This is done only for unions; caller had better check that
6262      it is an anonymous one. */
6263   if (TYPE_CODE (type) != TYPE_CODE_UNION)
6264     return;
6265
6266   /* Adjust each field; since this is a union, there are no base
6267      classes. Also no static membes.  Also, no need for recursion as
6268      the members of this union if themeselves structs or unions, have
6269      the correct bitoffsets; if an anonymous union is a member of this
6270      anonymous union, the code in hpread_read_struct_type() will
6271      adjust for that. */
6272
6273   for (i = 0; i < TYPE_NFIELDS (type); i++)
6274     TYPE_FIELD_BITPOS (type, i) -= bits;
6275 }
6276
6277 /* Return the adjustment necessary to make for addresses on the stack
6278    as presented by hpread.c.
6279
6280    This is necessary because of the stack direction on the PA and the
6281    bizarre way in which someone (?) decided they wanted to handle
6282    frame pointerless code in GDB.  */
6283 int
6284 hpread_adjust_stack_address (CORE_ADDR func_addr)
6285 {
6286   struct unwind_table_entry *u;
6287
6288   u = find_unwind_entry (func_addr);
6289   if (!u)
6290     return 0;
6291   else
6292     return u->Total_frame_size << 3;
6293 }
6294
6295 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6296    classes, we have to chase through a chain of threaded FIELD entries.
6297    If we encounter an anonymous union in the chain, we must recursively skip over
6298    that too.
6299
6300    This function does a "next" in the chain of FIELD entries, but transparently
6301    skips over anonymous unions' fields (recursively).
6302
6303    Inputs are the number of times to do "next" at the top level, the dnttpointer
6304    (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6305    and the ubiquitous objfile parameter. (Note: FIELDP is a **.)  Return value
6306    is a dnttpointer for the new field after all the skipped ones */
6307
6308 static dnttpointer
6309 hpread_get_next_skip_over_anon_unions (int skip_fields, dnttpointer field,
6310                                        union dnttentry **fieldp,
6311                                        struct objfile *objfile)
6312 {
6313   struct type *anon_type;
6314   int i;
6315   int bitoffset;
6316   char *name;
6317
6318   for (i = 0; i < skip_fields; i++)
6319     {
6320       /* Get type of item we're looking at now; recursively processes the types
6321          of these intermediate items we skip over, so they aren't lost. */
6322       anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile);
6323       anon_type = CHECK_TYPEDEF (anon_type);
6324       bitoffset = (*fieldp)->dfield.bitoffset;
6325       name = VT (objfile) + (*fieldp)->dfield.name;
6326       /* First skip over one item to avoid stack death on recursion */
6327       field = (*fieldp)->dfield.nextfield;
6328       *fieldp = hpread_get_lntt (field.dnttp.index, objfile);
6329       /* Do we have another anonymous union? If so, adjust the bitoffsets
6330          of its members and skip over its members. */
6331       if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) &&
6332           (!name || DEPRECATED_STREQ (name, "")))
6333         {
6334           hpread_adjust_bitoffsets (anon_type, bitoffset);
6335           field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile);
6336         }
6337     }
6338   return field;
6339 }