gdb/hpread.c

   1 /* Read hp debug symbols and convert to internal format, for GDB.
   2    Copyright 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., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, 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 "somsolib.h"
  39 #include "gdb_assert.h"
  40
  41 /* Private information attached to an objfile which we use to find
  42    and internalize the HP C debug symbols within that objfile.  */
  43
  44 struct hpread_symfile_info
  45   {
  46     /* The contents of each of the debug sections (there are 4 of them).  */
  47     char *gntt;
  48     char *lntt;
  49     char *slt;
  50     char *vt;
  51
  52     /* We keep the size of the $VT$ section for range checking.  */
  53     unsigned int vt_size;
  54
  55     /* Some routines still need to know the number of symbols in the
  56        main debug sections ($LNTT$ and $GNTT$). */
  57     unsigned int lntt_symcount;
  58     unsigned int gntt_symcount;
  59
  60     /* To keep track of all the types we've processed.  */
  61     struct type **dntt_type_vector;
  62     int dntt_type_vector_length;
  63
  64     /* Keeps track of the beginning of a range of source lines.  */
  65     sltpointer sl_index;
  66
  67     /* Some state variables we'll need.  */
  68     int within_function;
  69
  70     /* Keep track of the current function's address.  We may need to look
  71        up something based on this address.  */
  72     unsigned int current_function_value;
  73   };
  74
  75 /* Accessor macros to get at the fields.  */
  76 #define HPUX_SYMFILE_INFO(o) \
  77   ((struct hpread_symfile_info *)((o)->sym_private))
  78 #define GNTT(o)                 (HPUX_SYMFILE_INFO(o)->gntt)
  79 #define LNTT(o)                 (HPUX_SYMFILE_INFO(o)->lntt)
  80 #define SLT(o)                  (HPUX_SYMFILE_INFO(o)->slt)
  81 #define VT(o)                   (HPUX_SYMFILE_INFO(o)->vt)
  82 #define VT_SIZE(o)              (HPUX_SYMFILE_INFO(o)->vt_size)
  83 #define LNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->lntt_symcount)
  84 #define GNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->gntt_symcount)
  85 #define DNTT_TYPE_VECTOR(o)     (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
  86 #define DNTT_TYPE_VECTOR_LENGTH(o) \
  87   (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
  88 #define SL_INDEX(o)             (HPUX_SYMFILE_INFO(o)->sl_index)
  89 #define WITHIN_FUNCTION(o)      (HPUX_SYMFILE_INFO(o)->within_function)
  90 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
  91
  92 \f
  93 /* We put a pointer to this structure in the read_symtab_private field
  94    of the psymtab.  */
  95
  96 struct symloc
  97   {
  98     /* The offset within the file symbol table of first local symbol for
  99        this file.  */
 100
 101     int ldsymoff;
 102
 103     /* Length (in bytes) of the section of the symbol table devoted to
 104        this file's symbols (actually, the section bracketed may contain
 105        more than just this file's symbols).  If ldsymlen is 0, the only
 106        reason for this thing's existence is the dependency list.
 107        Nothing else will happen when it is read in.  */
 108
 109     int ldsymlen;
 110   };
 111
 112 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
 113 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
 114 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
 115 \f
 116 /* Complaints about the symbols we have encountered.  */
 117 static void
 118 lbrac_unmatched_complaint (int arg1)
 119 {
 120   complaint (&symfile_complaints, "unmatched N_LBRAC before symtab pos %d",
 121              arg1);
 122 }
 123
 124 static void
 125 lbrac_mismatch_complaint (int arg1)
 126 {
 127   complaint (&symfile_complaints,
 128              "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
 129 }
 130
 131 /* To generate dumping code, uncomment this define.  The dumping
 132    itself is controlled by routine-local statics called "dumping". */
 133 /* #define DUMPING         1 */
 134
 135 /* To use the quick look-up tables, uncomment this define. */
 136 #define QUICK_LOOK_UP      1
 137
 138 /* To call PXDB to process un-processed files, uncomment this define. */
 139 #define USE_PXDB           1
 140
 141 /* Forward procedure declarations */
 142
 143 /* Used in somread.c.  */
 144 void hpread_symfile_init (struct objfile *);
 145
 146 void do_pxdb (bfd *);
 147
 148 void hpread_build_psymtabs (struct objfile *, int);
 149
 150 void hpread_symfile_finish (struct objfile *);
 151
 152 static void set_namestring (union dnttentry *sym, char **namep,
 153                             struct objfile *objfile);
 154
 155 static union dnttentry *hpread_get_gntt (int, struct objfile *);
 156
 157 static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile);
 158
 159
 160 static unsigned long hpread_get_textlow (int, int, struct objfile *, int);
 161
 162 static struct partial_symtab *hpread_start_psymtab
 163   (struct objfile *, char *, CORE_ADDR, int,
 164    struct partial_symbol **, struct partial_symbol **);
 165
 166 static struct partial_symtab *hpread_end_psymtab
 167   (struct partial_symtab *, char **, int, int, CORE_ADDR,
 168    struct partial_symtab **, int);
 169
 170 static unsigned long hpread_get_scope_start (sltpointer, struct objfile *);
 171
 172 static unsigned long hpread_get_line (sltpointer, struct objfile *);
 173
 174 static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);
 175
 176 static int hpread_has_name (enum dntt_entry_type kind);
 177
 178 static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);
 179
 180 static void hpread_psymtab_to_symtab (struct partial_symtab *);
 181
 182 static struct symtab *hpread_expand_symtab
 183   (struct objfile *, int, int, CORE_ADDR, int,
 184    struct section_offsets *, char *);
 185
 186 static int hpread_type_translate (dnttpointer);
 187
 188 static struct type **hpread_lookup_type (dnttpointer, struct objfile *);
 189
 190 static struct type *hpread_alloc_type (dnttpointer, struct objfile *);
 191
 192 static struct type *hpread_read_enum_type
 193   (dnttpointer, union dnttentry *, struct objfile *);
 194
 195 static struct type *hpread_read_function_type
 196   (dnttpointer, union dnttentry *, struct objfile *, int);
 197
 198 static struct type *hpread_read_doc_function_type
 199   (dnttpointer, union dnttentry *, struct objfile *, int);
 200
 201 static struct type *hpread_read_struct_type
 202   (dnttpointer, union dnttentry *, struct objfile *);
 203
 204 static struct type *hpread_get_nth_template_arg (struct objfile *, int);
 205
 206 static struct type *hpread_read_templ_arg_type
 207   (dnttpointer, union dnttentry *, struct objfile *, char *);
 208
 209 static struct type *hpread_read_set_type
 210   (dnttpointer, union dnttentry *, struct objfile *);
 211
 212 static struct type *hpread_read_array_type
 213   (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile);
 214
 215 static struct type *hpread_read_subrange_type
 216   (dnttpointer, union dnttentry *, struct objfile *);
 217
 218 static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
 219
 220 static sltpointer hpread_record_lines
 221   (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
 222
 223 static void hpread_process_one_debug_symbol
 224   (union dnttentry *, char *, struct section_offsets *,
 225    struct objfile *, CORE_ADDR, int, char *, int, int *);
 226
 227 static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int);
 228
 229 static void fix_static_member_physnames
 230   (struct type *, char *, struct objfile *);
 231
 232 static void fixup_class_method_type
 233   (struct type *, struct type *, struct objfile *);
 234
 235 static void hpread_adjust_bitoffsets (struct type *, int);
 236
 237 static dnttpointer hpread_get_next_skip_over_anon_unions
 238   (int, dnttpointer, union dnttentry **, struct objfile *);
 239
 240 \f
 241 /* Global to indicate presence of HP-compiled objects,
 242    in particular, SOM executable file with SOM debug info
 243    Defined in symtab.c, used in hppa-tdep.c. */
 244 extern int hp_som_som_object_present;
 245
 246 /* Static used to indicate a class type that requires a
 247    fix-up of one of its method types */
 248 static struct type *fixup_class = NULL;
 249
 250 /* Static used to indicate the method type that is to be
 251    used to fix-up the type for fixup_class */
 252 static struct type *fixup_method = NULL;
 253
 254 #ifdef USE_PXDB
 255
 256 /* NOTE use of system files!  May not be portable. */
 257
 258 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
 259 #define PXDB_BSD  "/usr/bin/pxdb"
 260
 261 #include <stdlib.h>
 262 #include "gdb_string.h"
 263
 264 /* check for the existence of a file, given its full pathname */
 265 static int
 266 file_exists (char *filename)
 267 {
 268   if (filename)
 269     return (access (filename, F_OK) == 0);
 270   return 0;
 271 }
 272
 273
 274 /* Translate from the "hp_language" enumeration in hp-symtab.h
 275    used in the debug info to gdb's generic enumeration in defs.h. */
 276 static enum language
 277 trans_lang (enum hp_language in_lang)
 278 {
 279   if (in_lang == HP_LANGUAGE_C)
 280     return language_c;
 281
 282   else if (in_lang == HP_LANGUAGE_CPLUSPLUS)
 283     return language_cplus;
 284
 285   else if (in_lang == HP_LANGUAGE_FORTRAN)
 286     return language_fortran;
 287
 288   else
 289     return language_unknown;
 290 }
 291
 292 static char main_string[] = "main";
 293 \f
 294
 295 /* Given the native debug symbol SYM, set NAMEP to the name associated
 296    with the debug symbol.  Note we may be called with a debug symbol which
 297    has no associated name, in that case we return an empty string.  */
 298
 299 static void
 300 set_namestring (union dnttentry *sym, char **namep, struct objfile *objfile)
 301 {
 302   /* Note that we "know" that the name for any symbol is always in the same
 303      place.  Hence we don't have to conditionalize on the symbol type.  */
 304   if (! hpread_has_name (sym->dblock.kind))
 305     *namep = "";
 306   else if ((unsigned) sym->dsfile.name >= VT_SIZE (objfile))
 307     {
 308       complaint (&symfile_complaints, "bad string table offset in symbol %d",
 309                  symnum);
 310       *namep = "";
 311     }
 312   else
 313     *namep = sym->dsfile.name + VT (objfile);
 314 }
 315
 316 /* Call PXDB to process our file.
 317
 318    Approach copied from DDE's "dbgk_run_pxdb".  Note: we
 319    don't check for BSD location of pxdb, nor for existence
 320    of pxdb itself, etc.
 321
 322    NOTE: uses system function and string functions directly.
 323
 324    Return value: 1 if ok, 0 if not */
 325 static int
 326 hpread_call_pxdb (const char *file_name)
 327 {
 328   char *p;
 329   int status;
 330   int retval;
 331
 332   if (file_exists (PXDB_SVR4))
 333     {
 334       p = xmalloc (strlen (PXDB_SVR4) + strlen (file_name) + 2);
 335       strcpy (p, PXDB_SVR4);
 336       strcat (p, " ");
 337       strcat (p, file_name);
 338
 339       warning ("File not processed by pxdb--about to process now.\n");
 340       status = system (p);
 341
 342       retval = (status == 0);
 343     }
 344   else
 345     {
 346       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);
 347
 348       retval = 0;
 349     }
 350   return retval;
 351 }                               /* hpread_call_pxdb */
 352 \f
 353
 354 /* Return 1 if the file turns out to need pre-processing
 355    by PXDB, and we have thus called PXDB to do this processing
 356    and the file therefore needs to be re-loaded.  Otherwise
 357    return 0. */
 358 static int
 359 hpread_pxdb_needed (bfd *sym_bfd)
 360 {
 361   asection *pinfo_section, *debug_section, *header_section;
 362   unsigned int do_pxdb;
 363   char *buf;
 364   bfd_size_type header_section_size;
 365
 366   unsigned long tmp;
 367   unsigned int pxdbed;
 368
 369   header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$");
 370   if (!header_section)
 371     {
 372       return 0;                 /* No header at all, can't recover... */
 373     }
 374
 375   debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$");
 376   pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$");
 377
 378   if (pinfo_section && !debug_section)
 379     {
 380       /* Debug info with DOC, has different header format.
 381          this only happens if the file was pxdbed and compiled optimized
 382          otherwise the PINFO section is not there. */
 383       header_section_size = bfd_section_size (objfile->obfd, header_section);
 384
 385       if (header_section_size == (bfd_size_type) sizeof (DOC_info_PXDB_header))
 386         {
 387           buf = alloca (sizeof (DOC_info_PXDB_header));
 388
 389           if (!bfd_get_section_contents (sym_bfd,
 390                                          header_section,
 391                                          buf, 0,
 392                                          header_section_size))
 393             error ("bfd_get_section_contents\n");
 394
 395           tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 4));
 396           pxdbed = (tmp >> 31) & 0x1;
 397
 398           if (!pxdbed)
 399             error ("file debug header info invalid\n");
 400           do_pxdb = 0;
 401         }
 402
 403       else
 404         error ("invalid $HEADER$ size in executable \n");
 405     }
 406
 407   else
 408     {
 409
 410       /* this can be three different cases:
 411          1. pxdbed and not doc
 412          - DEBUG and HEADER sections are there
 413          - header is PXDB_header type
 414          - pxdbed flag is set to 1
 415
 416          2. not pxdbed and doc
 417          - DEBUG and HEADER  sections are there
 418          - header is DOC_info_header type
 419          - pxdbed flag is set to 0
 420
 421          3. not pxdbed and not doc
 422          - DEBUG and HEADER sections are there
 423          - header is XDB_header type
 424          - pxdbed flag is set to 0
 425
 426          NOTE: the pxdbed flag is meaningful also in the not
 427          already pxdb processed version of the header,
 428          because in case on non-already processed by pxdb files
 429          that same bit in the header would be always zero.
 430          Why? Because the bit is the leftmost bit of a word
 431          which contains a 'length' which is always a positive value
 432          so that bit is never set to 1 (otherwise it would be negative)
 433
 434          Given the above, we have two choices : either we ignore the
 435          size of the header itself and just look at the pxdbed field,
 436          or we check the size and then we (for safety and paranoia related
 437          issues) check the bit.
 438          The first solution is used by DDE, the second by PXDB itself.
 439          I am using the second one here, because I already wrote it,
 440          and it is the end of a long day.
 441          Also, using the first approach would still involve size issues
 442          because we need to read in the contents of the header section, and
 443          give the correct amount of stuff we want to read to the
 444          get_bfd_section_contents function.  */
 445
 446       /* decide which case depending on the size of the header section.
 447          The size is as defined in hp-symtab.h  */
 448
 449       header_section_size = bfd_section_size (objfile->obfd, header_section);
 450
 451       if (header_section_size == (bfd_size_type) sizeof (PXDB_header))  /* pxdb and not doc */
 452         {
 453
 454           buf = alloca (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\n");
 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\n");
 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\":\n", \
 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->sym_private =
1671     xmmalloc (objfile->md, sizeof (struct hpread_symfile_info));
1672   memset (objfile->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->symbol_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->symbol_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->symbol_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->symbol_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->sym_private != NULL)
2288     {
2289       xmfree (objfile->md, objfile->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   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.\n");
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                 xmmalloc (objfile->md, 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                 xmrealloc (objfile->md,
3046                            (char *) DNTT_TYPE_VECTOR (objfile),
3047                    (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
3048
3049               memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0,
3050                       (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) *
3051                       sizeof (struct type *));
3052             }
3053
3054         }
3055       return &DNTT_TYPE_VECTOR (objfile)[index];
3056     }
3057   else
3058     return NULL;
3059 }
3060
3061 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
3062    Note we'll just return the address of a GDB internal type if we already
3063    have it lying around.  */
3064
3065 static struct type *
3066 hpread_alloc_type (dnttpointer hp_type, struct objfile *objfile)
3067 {
3068   struct type **type_addr;
3069
3070   type_addr = hpread_lookup_type (hp_type, objfile);
3071   if (*type_addr == 0)
3072     {
3073       *type_addr = alloc_type (objfile);
3074
3075       /* A hack - if we really are a C++ class symbol, then this default
3076        * will get overriden later on.
3077        */
3078       TYPE_CPLUS_SPECIFIC (*type_addr)
3079         = (struct cplus_struct_type *) &cplus_struct_default;
3080     }
3081
3082   return *type_addr;
3083 }
3084
3085 /* Read a native enumerated type and return it in GDB internal form.  */
3086
3087 static struct type *
3088 hpread_read_enum_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3089                        struct objfile *objfile)
3090 {
3091   struct type *type;
3092   struct pending **symlist, *osyms, *syms;
3093   struct pending *local_list = NULL;
3094   int o_nsyms, nsyms = 0;
3095   dnttpointer mem;
3096   union dnttentry *memp;
3097   char *name;
3098   long n;
3099   struct symbol *sym;
3100
3101   /* Allocate a GDB type. If we've already read in this enum type,
3102    * it'll return the already built GDB type, so stop here.
3103    * (Note: I added this check, to conform with what's done for
3104    *  struct, union, class.
3105    *  I assume this is OK. - RT)
3106    */
3107   type = hpread_alloc_type (hp_type, objfile);
3108   if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3109     return type;
3110
3111   /* HP C supports "sized enums", where a specifier such as "short" or
3112      "char" can be used to get enums of different sizes. So don't assume
3113      an enum is always 4 bytes long. pai/1997-08-21 */
3114   TYPE_LENGTH (type) = dn_bufp->denum.bitlength / 8;
3115
3116   symlist = &file_symbols;
3117   osyms = *symlist;
3118   o_nsyms = osyms ? osyms->nsyms : 0;
3119
3120   /* Get a name for each member and add it to our list of members.
3121    * The list of "mem" SOM records we are walking should all be
3122    * SOM type DNTT_TYPE_MEMENUM (not checked).
3123    */
3124   mem = dn_bufp->denum.firstmem;
3125   while (mem.word && mem.word != DNTTNIL)
3126     {
3127       memp = hpread_get_lntt (mem.dnttp.index, objfile);
3128
3129       name = VT (objfile) + memp->dmember.name;
3130       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3131                                              sizeof (struct symbol));
3132       memset (sym, 0, sizeof (struct symbol));
3133       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3134                                         &objfile->symbol_obstack);
3135       SYMBOL_CLASS (sym) = LOC_CONST;
3136       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3137       SYMBOL_VALUE (sym) = memp->dmember.value;
3138       add_symbol_to_list (sym, symlist);
3139       nsyms++;
3140       mem = memp->dmember.nextmem;
3141     }
3142
3143   /* Now that we know more about the enum, fill in more info.  */
3144   TYPE_CODE (type) = TYPE_CODE_ENUM;
3145   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3146   TYPE_NFIELDS (type) = nsyms;
3147   TYPE_FIELDS (type) = (struct field *)
3148     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nsyms);
3149
3150   /* Find the symbols for the members and put them into the type.
3151      The symbols can be found in the symlist that we put them on
3152      to cause them to be defined.  osyms contains the old value
3153      of that symlist; everything up to there was defined by us.
3154
3155      Note that we preserve the order of the enum constants, so
3156      that in something like "enum {FOO, LAST_THING=FOO}" we print
3157      FOO, not LAST_THING.  */
3158   for (syms = *symlist, n = 0; syms; syms = syms->next)
3159     {
3160       int j = 0;
3161       if (syms == osyms)
3162         j = o_nsyms;
3163       for (; j < syms->nsyms; j++, n++)
3164         {
3165           struct symbol *xsym = syms->symbol[j];
3166           SYMBOL_TYPE (xsym) = type;
3167           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3168           TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3169           TYPE_FIELD_BITSIZE (type, n) = 0;
3170           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3171         }
3172       if (syms == osyms)
3173         break;
3174     }
3175
3176   return type;
3177 }
3178
3179 /* Read and internalize a native function debug symbol.  */
3180
3181 static struct type *
3182 hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3183                            struct objfile *objfile, int newblock)
3184 {
3185   struct type *type, *type1;
3186   struct pending *syms;
3187   struct pending *local_list = NULL;
3188   int nsyms = 0;
3189   dnttpointer param;
3190   union dnttentry *paramp;
3191   char *name;
3192   long n;
3193   struct symbol *sym;
3194   int record_args = 1;
3195
3196   /* See if we've already read in this type.  */
3197   type = hpread_alloc_type (hp_type, objfile);
3198   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3199     {
3200       record_args = 0;          /* already read in, don't modify type */
3201     }
3202   else
3203     {
3204       /* Nope, so read it in and store it away.  */
3205       if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3206           dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3207         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval,
3208                                                           objfile));
3209       else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3210         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval,
3211                                                           objfile));
3212       else                      /* expect DNTT_TYPE_FUNC_TEMPLATE */
3213         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval,
3214                                                           objfile));
3215       replace_type (type, type1);
3216
3217       /* Mark it -- in the middle of processing */
3218       TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3219     }
3220
3221   /* Now examine each parameter noting its type, location, and a
3222      wealth of other information.  */
3223   if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3224       dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3225     param = dn_bufp->dfunc.firstparam;
3226   else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3227     param = dn_bufp->dfunctype.firstparam;
3228   else                          /* expect DNTT_TYPE_FUNC_TEMPLATE */
3229     param = dn_bufp->dfunc_template.firstparam;
3230   while (param.word && param.word != DNTTNIL)
3231     {
3232       paramp = hpread_get_lntt (param.dnttp.index, objfile);
3233       nsyms++;
3234       param = paramp->dfparam.nextparam;
3235
3236       /* Get the name.  */
3237       name = VT (objfile) + paramp->dfparam.name;
3238       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3239                                              sizeof (struct symbol));
3240       (void) memset (sym, 0, sizeof (struct symbol));
3241       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3242                                         &objfile->symbol_obstack);
3243
3244       /* Figure out where it lives.  */
3245       if (paramp->dfparam.regparam)
3246         SYMBOL_CLASS (sym) = LOC_REGPARM;
3247       else if (paramp->dfparam.indirect)
3248         SYMBOL_CLASS (sym) = LOC_REF_ARG;
3249       else
3250         SYMBOL_CLASS (sym) = LOC_ARG;
3251       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3252       if (paramp->dfparam.copyparam)
3253         {
3254           SYMBOL_VALUE (sym) = paramp->dfparam.location;
3255 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3256           SYMBOL_VALUE (sym)
3257             += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3258 #endif
3259           /* This is likely a pass-by-invisible reference parameter,
3260              Hack on the symbol class to make GDB happy.  */
3261           /* ??rehrauer: This appears to be broken w/r/t to passing
3262              C values of type float and struct.  Perhaps this ought
3263              to be highighted as a special case, but for now, just
3264              allowing these to be LOC_ARGs seems to work fine.
3265            */
3266 #if 0
3267           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3268 #endif
3269         }
3270       else
3271         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3272
3273       /* Get its type.  */
3274       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3275       /* Add it to the symbol list.  */
3276       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3277        * called on FPARAM symbols from the process_one_debug_symbol()
3278        * level... so parameters are getting added twice! (this shows
3279        * up in the symbol dump you get from "maint print symbols ...").
3280        * Note 2 (RT) I took out the processing of FPARAM from the
3281        * process_one_debug_symbol() level, so at the moment parameters are only
3282        * being processed here. This seems to have no ill effect.
3283        */
3284       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3285          each fparam on the local_symbols list from here.  Now we use the
3286          local_list to which fparams are added below, and set the param_symbols
3287          global to point to that at the end of this routine. */
3288       /* elz: I added this new list of symbols which is local to the function.
3289          this list is the one which is actually used to build the type for the
3290          function rather than the gloabal list pointed to by symlist.
3291          Using a global list to keep track of the parameters is wrong, because
3292          this function is called recursively if one parameter happend to be
3293          a function itself with more parameters in it. Adding parameters to the
3294          same global symbol list would not work!
3295          Actually it did work in case of cc compiled programs where you do
3296          not check the parameter lists of the arguments. */
3297       add_symbol_to_list (sym, &local_list);
3298
3299     }
3300
3301   /* If type was read in earlier, don't bother with modifying
3302      the type struct */
3303   if (!record_args)
3304     goto finish;
3305
3306   /* Note how many parameters we found.  */
3307   TYPE_NFIELDS (type) = nsyms;
3308   TYPE_FIELDS (type) = (struct field *)
3309     obstack_alloc (&objfile->objfile_obstack,
3310                    sizeof (struct field) * nsyms);
3311
3312   /* Find the symbols for the parameters and
3313      use them to fill parameter-type information into the function-type.
3314      The parameter symbols can be found in the local_list that we just put them on. */
3315   /* Note that we preserve the order of the parameters, so
3316      that in something like "enum {FOO, LAST_THING=FOO}" we print
3317      FOO, not LAST_THING.  */
3318
3319   /* get the parameters types from the local list not the global list
3320      so that the type can be correctly constructed for functions which
3321      have function as parameters */
3322   for (syms = local_list, n = 0; syms; syms = syms->next)
3323     {
3324       int j = 0;
3325       for (j = 0; j < syms->nsyms; j++, n++)
3326         {
3327           struct symbol *xsym = syms->symbol[j];
3328           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3329           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3330           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3331           TYPE_FIELD_BITSIZE (type, n) = 0;
3332           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3333         }
3334     }
3335   /* Mark it as having been processed */
3336   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3337
3338   /* Check whether we need to fix-up a class type with this function's type */
3339   if (fixup_class && (fixup_method == type))
3340     {
3341       fixup_class_method_type (fixup_class, fixup_method, objfile);
3342       fixup_class = NULL;
3343       fixup_method = NULL;
3344     }
3345
3346   /* Set the param list of this level of the context stack
3347      to our local list.  Do this only if this function was
3348      called for creating a new block, and not if it was called
3349      simply to get the function type. This prevents recursive
3350      invocations from trashing param_symbols. */
3351 finish:
3352   if (newblock)
3353     param_symbols = local_list;
3354
3355   return type;
3356 }
3357
3358
3359 /* Read and internalize a native DOC function debug symbol.  */
3360 /* This is almost identical to hpread_read_function_type(), except
3361  * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3362  * Since debug information for DOC functions is more likely to be
3363  * volatile, please leave it this way.
3364  */
3365 static struct type *
3366 hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3367                                struct objfile *objfile, int newblock)
3368 {
3369   struct pending *syms;
3370   struct pending *local_list = NULL;
3371   int nsyms = 0;
3372   struct type *type;
3373   dnttpointer param;
3374   union dnttentry *paramp;
3375   char *name;
3376   long n;
3377   struct symbol *sym;
3378   int record_args = 1;
3379
3380   /* See if we've already read in this type.  */
3381   type = hpread_alloc_type (hp_type, objfile);
3382   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3383     {
3384       record_args = 0;          /* already read in, don't modify type */
3385     }
3386   else
3387     {
3388       struct type *type1 = NULL;
3389       /* Nope, so read it in and store it away.  */
3390       if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3391           dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3392         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval,
3393                                                           objfile));
3394       /* NOTE: cagney/2003-03-29: Oh, no not again.  TYPE1 is
3395          potentially left undefined here.  Assert it isn't and hope
3396          the assert never fails ...  */
3397       gdb_assert (type1 != NULL);
3398
3399       replace_type (type, type1);
3400
3401       /* Mark it -- in the middle of processing */
3402       TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3403     }
3404
3405   /* Now examine each parameter noting its type, location, and a
3406      wealth of other information.  */
3407   if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3408       dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3409     param = dn_bufp->ddocfunc.firstparam;
3410   while (param.word && param.word != DNTTNIL)
3411     {
3412       paramp = hpread_get_lntt (param.dnttp.index, objfile);
3413       nsyms++;
3414       param = paramp->dfparam.nextparam;
3415
3416       /* Get the name.  */
3417       name = VT (objfile) + paramp->dfparam.name;
3418       sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3419                                              sizeof (struct symbol));
3420       (void) memset (sym, 0, sizeof (struct symbol));
3421       DEPRECATED_SYMBOL_NAME (sym) = name;
3422
3423       /* Figure out where it lives.  */
3424       if (paramp->dfparam.regparam)
3425         SYMBOL_CLASS (sym) = LOC_REGPARM;
3426       else if (paramp->dfparam.indirect)
3427         SYMBOL_CLASS (sym) = LOC_REF_ARG;
3428       else
3429         SYMBOL_CLASS (sym) = LOC_ARG;
3430       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3431       if (paramp->dfparam.copyparam)
3432         {
3433           SYMBOL_VALUE (sym) = paramp->dfparam.location;
3434 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3435           SYMBOL_VALUE (sym)
3436             += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3437 #endif
3438           /* This is likely a pass-by-invisible reference parameter,
3439              Hack on the symbol class to make GDB happy.  */
3440           /* ??rehrauer: This appears to be broken w/r/t to passing
3441              C values of type float and struct.  Perhaps this ought
3442              to be highighted as a special case, but for now, just
3443              allowing these to be LOC_ARGs seems to work fine.
3444            */
3445 #if 0
3446           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3447 #endif
3448         }
3449       else
3450         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3451
3452       /* Get its type.  */
3453       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3454       /* Add it to the symbol list.  */
3455       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3456        * called on FPARAM symbols from the process_one_debug_symbol()
3457        * level... so parameters are getting added twice! (this shows
3458        * up in the symbol dump you get from "maint print symbols ...").
3459        * Note 2 (RT) I took out the processing of FPARAM from the
3460        * process_one_debug_symbol() level, so at the moment parameters are only
3461        * being processed here. This seems to have no ill effect.
3462        */
3463       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3464          each fparam on the local_symbols list from here.  Now we use the
3465          local_list to which fparams are added below, and set the param_symbols
3466          global to point to that at the end of this routine. */
3467
3468       /* elz: I added this new list of symbols which is local to the function.
3469          this list is the one which is actually used to build the type for the
3470          function rather than the gloabal list pointed to by symlist.
3471          Using a global list to keep track of the parameters is wrong, because
3472          this function is called recursively if one parameter happend to be
3473          a function itself with more parameters in it. Adding parameters to the
3474          same global symbol list would not work!
3475          Actually it did work in case of cc compiled programs where you do not check the
3476          parameter lists of the arguments.  */
3477       add_symbol_to_list (sym, &local_list);
3478     }
3479
3480   /* If type was read in earlier, don't bother with modifying
3481      the type struct */
3482   if (!record_args)
3483     goto finish;
3484
3485   /* Note how many parameters we found.  */
3486   TYPE_NFIELDS (type) = nsyms;
3487   TYPE_FIELDS (type) = (struct field *)
3488     obstack_alloc (&objfile->objfile_obstack,
3489                    sizeof (struct field) * nsyms);
3490
3491   /* Find the symbols for the parameters and
3492      use them to fill parameter-type information into the function-type.
3493      The parameter symbols can be found in the local_list that we just put them on. */
3494   /* Note that we preserve the order of the parameters, so
3495      that in something like "enum {FOO, LAST_THING=FOO}" we print
3496      FOO, not LAST_THING.  */
3497
3498   /* get the parameters types from the local list not the global list
3499      so that the type can be correctly constructed for functions which
3500      have function as parameters
3501    */
3502   for (syms = local_list, n = 0; syms; syms = syms->next)
3503     {
3504       int j = 0;
3505       for (j = 0; j < syms->nsyms; j++, n++)
3506         {
3507           struct symbol *xsym = syms->symbol[j];
3508           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3509           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3510           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3511           TYPE_FIELD_BITSIZE (type, n) = 0;
3512           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3513         }
3514     }
3515
3516   /* Mark it as having been processed */
3517   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3518
3519   /* Check whether we need to fix-up a class type with this function's type */
3520   if (fixup_class && (fixup_method == type))
3521     {
3522       fixup_class_method_type (fixup_class, fixup_method, objfile);
3523       fixup_class = NULL;
3524       fixup_method = NULL;
3525     }
3526
3527   /* Set the param list of this level of the context stack
3528      to our local list.  Do this only if this function was
3529      called for creating a new block, and not if it was called
3530      simply to get the function type. This prevents recursive
3531      invocations from trashing param_symbols. */
3532 finish:
3533   if (newblock)
3534     param_symbols = local_list;
3535
3536   return type;
3537 }
3538
3539
3540
3541 /* A file-level variable which keeps track of the current-template
3542  * being processed. Set in hpread_read_struct_type() while processing
3543  * a template type. Referred to in hpread_get_nth_templ_arg().
3544  * Yes, this is a kludge, but it arises from the kludge that already
3545  * exists in symtab.h, namely the fact that they encode
3546  * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3547  * bitlength n. This means that deep in processing fundamental types
3548  * I need to ask the question "what template am I in the middle of?".
3549  * The alternative to stuffing a global would be to pass an argument
3550  * down the chain of calls just for this purpose.
3551  *
3552  * There may be problems handling nested templates... tough.
3553  */
3554 static struct type *current_template = NULL;
3555
3556 /* Read in and internalize a structure definition.
3557  * This same routine is called for struct, union, and class types.
3558  * Also called for templates, since they build a very similar
3559  * type entry as for class types.
3560  */
3561
3562 static struct type *
3563 hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3564                          struct objfile *objfile)
3565 {
3566   /* The data members get linked together into a list of struct nextfield's */
3567   struct nextfield
3568     {
3569       struct nextfield *next;
3570       struct field field;
3571       unsigned char attributes; /* store visibility and virtuality info */
3572 #define ATTR_VIRTUAL 1
3573 #define ATTR_PRIVATE 2
3574 #define ATTR_PROTECT 3
3575     };
3576
3577
3578   /* The methods get linked together into a list of struct next_fn_field's */
3579   struct next_fn_field
3580     {
3581       struct next_fn_field *next;
3582       struct fn_fieldlist field;
3583       struct fn_field fn_field;
3584       int num_fn_fields;
3585     };
3586
3587   /* The template args get linked together into a list of struct next_template's */
3588   struct next_template
3589     {
3590       struct next_template *next;
3591       struct template_arg arg;
3592     };
3593
3594   /* The template instantiations get linked together into a list of these... */
3595   struct next_instantiation
3596     {
3597       struct next_instantiation *next;
3598       struct type *t;
3599     };
3600
3601   struct type *type;
3602   struct type *baseclass;
3603   struct type *memtype;
3604   struct nextfield *list = 0, *tmp_list = 0;
3605   struct next_fn_field *fn_list = 0;
3606   struct next_fn_field *fn_p;
3607   struct next_template *t_new, *t_list = 0;
3608   struct nextfield *new;
3609   struct next_fn_field *fn_new;
3610   struct next_instantiation *i_new, *i_list = 0;
3611   int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0;
3612   int n_base_classes = 0, n_templ_args = 0;
3613   int ninstantiations = 0;
3614   dnttpointer field, fn_field, parent;
3615   union dnttentry *fieldp, *fn_fieldp, *parentp;
3616   int i;
3617   int static_member = 0;
3618   int const_member = 0;
3619   int volatile_member = 0;
3620   unsigned long vtbl_offset;
3621   int need_bitvectors = 0;
3622   char *method_name = NULL;
3623   char *method_alias = NULL;
3624
3625
3626   /* Is it something we've already dealt with?  */
3627   type = hpread_alloc_type (hp_type, objfile);
3628   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
3629       (TYPE_CODE (type) == TYPE_CODE_UNION) ||
3630       (TYPE_CODE (type) == TYPE_CODE_CLASS) ||
3631       (TYPE_CODE (type) == TYPE_CODE_TEMPLATE))
3632     return type;
3633
3634   /* Get the basic type correct.  */
3635   if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3636     {
3637       TYPE_CODE (type) = TYPE_CODE_STRUCT;
3638       TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
3639     }
3640   else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3641     {
3642       TYPE_CODE (type) = TYPE_CODE_UNION;
3643       TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
3644     }
3645   else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3646     {
3647       TYPE_CODE (type) = TYPE_CODE_CLASS;
3648       TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8;
3649
3650       /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3651        * rather than &cplus_struct_default.
3652        */
3653       allocate_cplus_struct_type (type);
3654
3655       /* Fill in declared-type.
3656        * (The C++ compiler will emit TYPE_CODE_CLASS
3657        * for all 3 of "class", "struct"
3658        * "union", and we have to look at the "class_decl" field if we
3659        * want to know how it was really declared)
3660        */
3661       /* (0==class, 1==union, 2==struct) */
3662       TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl;
3663     }
3664   else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3665     {
3666       /* Get the basic type correct.  */
3667       TYPE_CODE (type) = TYPE_CODE_TEMPLATE;
3668       allocate_cplus_struct_type (type);
3669       TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE;
3670     }
3671   else
3672     return type;
3673
3674
3675   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3676
3677   /* For classes, read the parent list.
3678    * Question (RT): Do we need to do this for templates also?
3679    */
3680   if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3681     {
3682
3683       /* First read the parent-list (classes from which we derive fields) */
3684       parent = dn_bufp->dclass.parentlist;
3685       while (parent.word && parent.word != DNTTNIL)
3686         {
3687           parentp = hpread_get_lntt (parent.dnttp.index, objfile);
3688
3689           /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3690
3691           /* Get space to record the next field/data-member. */
3692           new = (struct nextfield *) alloca (sizeof (struct nextfield));
3693           new->next = list;
3694           list = new;
3695
3696           FIELD_BITSIZE (list->field) = 0;
3697           FIELD_STATIC_KIND (list->field) = 0;
3698
3699           /* The "classname" field is actually a DNTT pointer to the base class */
3700           baseclass = hpread_type_lookup (parentp->dinheritance.classname,
3701                                           objfile);
3702           FIELD_TYPE (list->field) = baseclass;
3703
3704           list->field.name = type_name_no_tag (FIELD_TYPE (list->field));
3705
3706           list->attributes = 0;
3707
3708           /* Check for virtuality of base, and set the
3709            * offset of the base subobject within the object.
3710            * (Offset set to -1 for virtual bases (for now).)
3711            */
3712           if (parentp->dinheritance.Virtual)
3713             {
3714               B_SET (&(list->attributes), ATTR_VIRTUAL);
3715               parentp->dinheritance.offset = -1;
3716             }
3717           else
3718             FIELD_BITPOS (list->field) = parentp->dinheritance.offset;
3719
3720           /* Check visibility */
3721           switch (parentp->dinheritance.visibility)
3722             {
3723             case 1:
3724               B_SET (&(list->attributes), ATTR_PROTECT);
3725               break;
3726             case 2:
3727               B_SET (&(list->attributes), ATTR_PRIVATE);
3728               break;
3729             }
3730
3731           n_base_classes++;
3732           nfields++;
3733
3734           parent = parentp->dinheritance.next;
3735         }
3736     }
3737
3738   /* For templates, read the template argument list.
3739    * This must be done before processing the member list, because
3740    * the member list may refer back to this. E.g.:
3741    *   template <class T1, class T2> class q2 {
3742    *     public:
3743    *     T1 a;
3744    *     T2 b;
3745    *   };
3746    * We need to read the argument list "T1", "T2" first.
3747    */
3748   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3749     {
3750       /* Kludge alert: This stuffs a global "current_template" which
3751        * is referred to by hpread_get_nth_templ_arg(). The global
3752        * is cleared at the end of this routine.
3753        */
3754       current_template = type;
3755
3756       /* Read in the argument list */
3757       field = dn_bufp->dtemplate.arglist;
3758       while (field.word && field.word != DNTTNIL)
3759         {
3760           /* Get this template argument */
3761           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3762           if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG)
3763             {
3764               warning ("Invalid debug info: Template argument entry is of wrong kind");
3765               break;
3766             }
3767           /* Bump the count */
3768           n_templ_args++;
3769           /* Allocate and fill in a struct next_template */
3770           t_new = (struct next_template *) alloca (sizeof (struct next_template));
3771           t_new->next = t_list;
3772           t_list = t_new;
3773           t_list->arg.name = VT (objfile) + fieldp->dtempl_arg.name;
3774           t_list->arg.type = hpread_read_templ_arg_type (field, fieldp,
3775                                                  objfile, t_list->arg.name);
3776           /* Walk to the next template argument */
3777           field = fieldp->dtempl_arg.nextarg;
3778         }
3779     }
3780
3781   TYPE_NTEMPLATE_ARGS (type) = n_templ_args;
3782
3783   if (n_templ_args > 0)
3784     TYPE_TEMPLATE_ARGS (type) = (struct template_arg *)
3785       obstack_alloc (&objfile->objfile_obstack, sizeof (struct template_arg) * n_templ_args);
3786   for (n = n_templ_args; t_list; t_list = t_list->next)
3787     {
3788       n -= 1;
3789       TYPE_TEMPLATE_ARG (type, n) = t_list->arg;
3790     }
3791
3792   /* Next read in and internalize all the fields/members.  */
3793   if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3794     field = dn_bufp->dstruct.firstfield;
3795   else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3796     field = dn_bufp->dunion.firstfield;
3797   else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3798     field = dn_bufp->dclass.memberlist;
3799   else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3800     field = dn_bufp->dtemplate.memberlist;
3801   else
3802     field.word = DNTTNIL;
3803
3804   while (field.word && field.word != DNTTNIL)
3805     {
3806       fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3807
3808       /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
3809        * or a DNTT_TYPE_GENFIELD record.
3810        */
3811       vtbl_offset = 0;
3812       static_member = 0;
3813       const_member = 0;
3814       volatile_member = 0;
3815
3816       if (fieldp->dblock.kind == DNTT_TYPE_GENFIELD)
3817         {
3818
3819           /* The type will be GENFIELD if the field is a method or
3820            * a static member (or some other cases -- see below)
3821            */
3822
3823           /* Follow a link to get to the record for the field. */
3824           fn_field = fieldp->dgenfield.field;
3825           fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3826
3827           /* Virtual funcs are indicated by a VFUNC which points to the
3828            * real entry
3829            */
3830           if (fn_fieldp->dblock.kind == DNTT_TYPE_VFUNC)
3831             {
3832               vtbl_offset = fn_fieldp->dvfunc.vtbl_offset;
3833               fn_field = fn_fieldp->dvfunc.funcptr;
3834               fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3835             }
3836
3837           /* A function's entry may be preceded by a modifier which
3838            * labels it static/constant/volatile.
3839            */
3840           if (fn_fieldp->dblock.kind == DNTT_TYPE_MODIFIER)
3841             {
3842               static_member = fn_fieldp->dmodifier.m_static;
3843               const_member = fn_fieldp->dmodifier.m_const;
3844               volatile_member = fn_fieldp->dmodifier.m_volatile;
3845               fn_field = fn_fieldp->dmodifier.type;
3846               fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3847             }
3848
3849           /* Check whether we have a method */
3850           if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
3851               (fn_fieldp->dblock.kind == DNTT_TYPE_FUNCTION) ||
3852               (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) ||
3853               (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_FUNCTION))
3854             {
3855               /* Method found */
3856
3857               short ix = 0;
3858
3859               /* Look up function type of method */
3860               memtype = hpread_type_lookup (fn_field, objfile);
3861
3862               /* Methods can be seen before classes in the SOM records.
3863                  If we are processing this class because it's a parameter of a
3864                  method, at this point the method's type is actually incomplete;
3865                  we'll have to fix it up later; mark the class for this. */
3866
3867               if (TYPE_INCOMPLETE (memtype))
3868                 {
3869                   TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3870                   if (fixup_class)
3871                     warning ("Two classes to fix up for method??  Type information may be incorrect for some classes.");
3872                   if (fixup_method)
3873                     warning ("Two methods to be fixed up at once?? Type information may be incorrect for some classes.");
3874                   fixup_class = type;   /* remember this class has to be fixed up */
3875                   fixup_method = memtype;       /* remember the method type to be used in fixup */
3876                 }
3877
3878               /* HP aCC generates operator names without the "operator" keyword, and
3879                  generates null strings as names for operators that are
3880                  user-defined type conversions to basic types (e.g. operator int ()).
3881                  So try to reconstruct name as best as possible. */
3882
3883               method_name = (char *) (VT (objfile) + fn_fieldp->dfunc.name);
3884               method_alias = (char *) (VT (objfile) + fn_fieldp->dfunc.alias);
3885
3886               if (!method_name ||       /* no name */
3887                   !*method_name ||      /* or null name */
3888                   cplus_mangle_opname (method_name, DMGL_ANSI))         /* or name is an operator like "<" */
3889                 {
3890                   char *tmp_name = cplus_demangle (method_alias, DMGL_ANSI);
3891                   char *op_string = strstr (tmp_name, "operator");
3892                   method_name = xmalloc (strlen (op_string) + 1);       /* don't overwrite VT! */
3893                   strcpy (method_name, op_string);
3894                 }
3895
3896               /* First check if a method of the same name has already been seen. */
3897               fn_p = fn_list;
3898               while (fn_p)
3899                 {
3900                   if (DEPRECATED_STREQ (fn_p->field.name, method_name))
3901                     break;
3902                   fn_p = fn_p->next;
3903                 }
3904
3905               /* If no such method was found, allocate a new entry in the list */
3906               if (!fn_p)
3907                 {
3908                   /* Get space to record this member function */
3909                   /* Note: alloca used; this will disappear on routine exit */
3910                   fn_new = (struct next_fn_field *) alloca (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               new->next = list;
4029               list = new;
4030
4031               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4032               SET_FIELD_PHYSNAME (list->field, 0);      /* initialize to empty */
4033               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4034
4035               FIELD_TYPE (list->field) = memtype;
4036               list->attributes = 0;
4037               switch (fieldp->dgenfield.visibility)
4038                 {
4039                 case 1:
4040                   B_SET (&(list->attributes), ATTR_PROTECT);
4041                   break;
4042                 case 2:
4043                   B_SET (&(list->attributes), ATTR_PRIVATE);
4044                   break;
4045                 }
4046               nfields++;
4047             }
4048
4049           else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD)
4050             {
4051               /* FIELDs follow GENFIELDs for fields of anonymous unions.
4052                  Code below is replicated from the case for FIELDs further
4053                  below, except that fieldp is replaced by fn_fieldp */
4054               if (!fn_fieldp->dfield.a_union)
4055                 warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
4056               /* Get space to record the next field/data-member. */
4057               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4058               new->next = list;
4059               list = new;
4060
4061               list->field.name = VT (objfile) + fn_fieldp->dfield.name;
4062               FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset;
4063               if (fn_fieldp->dfield.bitlength % 8)
4064                 list->field.bitsize = fn_fieldp->dfield.bitlength;
4065               else
4066                 list->field.bitsize = 0;
4067
4068               memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile);
4069               list->field.type = memtype;
4070               list->attributes = 0;
4071               switch (fn_fieldp->dfield.visibility)
4072                 {
4073                 case 1:
4074                   B_SET (&(list->attributes), ATTR_PROTECT);
4075                   break;
4076                 case 2:
4077                   B_SET (&(list->attributes), ATTR_PRIVATE);
4078                   break;
4079                 }
4080               nfields++;
4081             }
4082           else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4083             {
4084               /* Field of anonymous union; union is not inside a class */
4085               if (!fn_fieldp->dsvar.a_union)
4086                 warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
4087               /* Get space to record the next field/data-member. */
4088               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4089               new->next = list;
4090               list = new;
4091
4092               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4093               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4094               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4095               FIELD_STATIC_KIND (list->field) = 0;
4096               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4097               list->field.type = memtype;
4098               list->attributes = 0;
4099               /* No info to set visibility -- always public */
4100               nfields++;
4101             }
4102           else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR)
4103             {
4104               /* Field of anonymous union; union is not inside a class */
4105               if (!fn_fieldp->ddvar.a_union)
4106                 warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
4107               /* Get space to record the next field/data-member. */
4108               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4109               new->next = list;
4110               list = new;
4111
4112               list->field.name = VT (objfile) + fn_fieldp->ddvar.name;
4113               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4114               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4115               FIELD_STATIC_KIND (list->field) = 0;
4116               memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile);
4117               list->field.type = memtype;
4118               list->attributes = 0;
4119               /* No info to set visibility -- always public */
4120               nfields++;
4121             }
4122           else
4123             {                   /* Not a method, nor a static data member, nor an anon union field */
4124
4125               /* This case is for miscellaneous type entries (local enums,
4126                  local function templates, etc.) that can be present
4127                  inside a class. */
4128
4129               /* Enums -- will be handled by other code that takes care
4130                  of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4131                  it's not clear we could have handled them here at all. */
4132               /* FUNC_TEMPLATE: is handled by other code (?). */
4133               /* MEMACCESS: modified access for inherited member. Not
4134                  sure what to do with this, ignoriing it at present. */
4135
4136               /* What other entries can appear following a GENFIELD which
4137                  we do not handle above?  (MODIFIER, VFUNC handled above.) */
4138
4139               if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) &&
4140                   (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) &&
4141                   (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE))
4142                 warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
4143                          fn_fieldp->dblock.kind);
4144             }
4145           /* walk to the next FIELD or GENFIELD */
4146           field = fieldp->dgenfield.nextfield;
4147
4148         }
4149       else if (fieldp->dblock.kind == DNTT_TYPE_FIELD)
4150         {
4151
4152           /* Ordinary structure/union/class field */
4153           struct type *anon_union_type;
4154
4155           /* Get space to record the next field/data-member. */
4156           new = (struct nextfield *) alloca (sizeof (struct nextfield));
4157           new->next = list;
4158           list = new;
4159
4160           list->field.name = VT (objfile) + fieldp->dfield.name;
4161
4162
4163           /* A FIELD by itself (without a GENFIELD) can also be a static
4164              member.  Mark it as static with a physname of NULL.
4165              fix_static_member_physnames will assign the physname later. */
4166           if (fieldp->dfield.staticmem)
4167             {
4168               SET_FIELD_PHYSNAME (list->field, NULL);
4169               FIELD_BITPOS (list->field) = 0;
4170               FIELD_BITSIZE (list->field) = 0;
4171             }
4172           else
4173             /* Non-static data member */
4174             {
4175               FIELD_STATIC_KIND (list->field) = 0;
4176               FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
4177               if (fieldp->dfield.bitlength % 8)
4178                 FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
4179               else
4180                 FIELD_BITSIZE (list->field) = 0;
4181             }
4182
4183           memtype = hpread_type_lookup (fieldp->dfield.type, objfile);
4184           FIELD_TYPE (list->field) = memtype;
4185           list->attributes = 0;
4186           switch (fieldp->dfield.visibility)
4187             {
4188             case 1:
4189               B_SET (&(list->attributes), ATTR_PROTECT);
4190               break;
4191             case 2:
4192               B_SET (&(list->attributes), ATTR_PRIVATE);
4193               break;
4194             }
4195           nfields++;
4196
4197
4198           /* Note 1: First, we have to check if the current field is an anonymous
4199              union. If it is, then *its* fields are threaded along in the
4200              nextfield chain. :-( This was supposed to help debuggers, but is
4201              really just a nuisance since we deal with anonymous unions anyway by
4202              checking that the name is null.  So anyway, we skip over the fields
4203              of the anonymous union. pai/1997-08-22 */
4204           /* Note 2: In addition, the bitoffsets for the fields of the anon union
4205              are relative to the enclosing struct, *NOT* relative to the anon
4206              union!  This is an even bigger nuisance -- we have to go in and munge
4207              the anon union's type information appropriately. pai/1997-08-22 */
4208
4209           /* Both tasks noted above are done by a separate function.  This takes us
4210              to the next FIELD or GENFIELD, skipping anon unions, and recursively
4211              processing intermediate types. */
4212           field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile);
4213
4214         }
4215       else
4216         {
4217           /* neither field nor genfield ?? is this possible?? */
4218           /* pai:: FIXME walk to the next -- how? */
4219           warning ("Internal error: unexpected DNTT kind %d encountered as field of struct",
4220                    fieldp->dblock.kind);
4221           warning ("Skipping remaining fields of struct");
4222           break;                /* get out of loop of fields */
4223         }
4224     }
4225
4226   /* If it's a template, read in the instantiation list */
4227   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4228     {
4229       ninstantiations = 0;
4230       field = dn_bufp->dtemplate.expansions;
4231       while (field.word && field.word != DNTTNIL)
4232         {
4233           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4234
4235           /* The expansions or nextexp should point to a tagdef */
4236           if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF)
4237             break;
4238
4239           i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation));
4240           i_new->next = i_list;
4241           i_list = i_new;
4242           i_list->t = hpread_type_lookup (field, objfile);
4243           ninstantiations++;
4244
4245           /* And the "type" field of that should point to a class */
4246           field = fieldp->dtag.type;
4247           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4248           if (fieldp->dblock.kind != DNTT_TYPE_CLASS)
4249             break;
4250
4251           /* Get the next expansion */
4252           field = fieldp->dclass.nextexp;
4253         }
4254     }
4255   TYPE_NINSTANTIATIONS (type) = ninstantiations;
4256   if (ninstantiations > 0)
4257     TYPE_INSTANTIATIONS (type) = (struct type **)
4258       obstack_alloc (&objfile->objfile_obstack, sizeof (struct type *) * ninstantiations);
4259   for (n = ninstantiations; i_list; i_list = i_list->next)
4260     {
4261       n -= 1;
4262       TYPE_INSTANTIATION (type, n) = i_list->t;
4263     }
4264
4265
4266   /* Copy the field-list to GDB's symbol table */
4267   TYPE_NFIELDS (type) = nfields;
4268   TYPE_N_BASECLASSES (type) = n_base_classes;
4269   TYPE_FIELDS (type) = (struct field *)
4270     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nfields);
4271   /* Copy the saved-up fields into the field vector.  */
4272   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4273     {
4274       n -= 1;
4275       TYPE_FIELD (type, n) = tmp_list->field;
4276     }
4277
4278   /* Copy the "function-field-list" (i.e., the list of member
4279    * functions in the class) to GDB's symbol table
4280    */
4281   TYPE_NFN_FIELDS (type) = n_fn_fields;
4282   TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total;
4283   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
4284     obstack_alloc (&objfile->objfile_obstack, sizeof (struct fn_fieldlist) * n_fn_fields);
4285   for (n = n_fn_fields; fn_list; fn_list = fn_list->next)
4286     {
4287       n -= 1;
4288       TYPE_FN_FIELDLIST (type, n) = fn_list->field;
4289     }
4290
4291   /* pai:: FIXME -- perhaps each bitvector should be created individually */
4292   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4293     {
4294       n -= 1;
4295       if (tmp_list->attributes)
4296         {
4297           need_bitvectors = 1;
4298           break;
4299         }
4300     }
4301
4302   if (need_bitvectors)
4303     {
4304       /* pai:: this step probably redundant */
4305       ALLOCATE_CPLUS_STRUCT_TYPE (type);
4306
4307       TYPE_FIELD_VIRTUAL_BITS (type) =
4308         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4309       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields);
4310
4311       TYPE_FIELD_PRIVATE_BITS (type) =
4312         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4313       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
4314
4315       TYPE_FIELD_PROTECTED_BITS (type) =
4316         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4317       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
4318
4319       /* this field vector isn't actually used with HP aCC */
4320       TYPE_FIELD_IGNORE_BITS (type) =
4321         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4322       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
4323
4324       while (nfields-- > 0)
4325         {
4326           if (B_TST (&(list->attributes), ATTR_VIRTUAL))
4327             SET_TYPE_FIELD_VIRTUAL (type, nfields);
4328           if (B_TST (&(list->attributes), ATTR_PRIVATE))
4329             SET_TYPE_FIELD_PRIVATE (type, nfields);
4330           if (B_TST (&(list->attributes), ATTR_PROTECT))
4331             SET_TYPE_FIELD_PROTECTED (type, nfields);
4332
4333           list = list->next;
4334         }
4335     }
4336   else
4337     {
4338       TYPE_FIELD_VIRTUAL_BITS (type) = NULL;
4339       TYPE_FIELD_PROTECTED_BITS (type) = NULL;
4340       TYPE_FIELD_PRIVATE_BITS (type) = NULL;
4341     }
4342
4343   if (has_vtable (type))
4344     {
4345       /* Allocate space for class runtime information */
4346       TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info));
4347       /* Set flag for vtable */
4348       TYPE_VTABLE (type) = 1;
4349       /* The first non-virtual base class with a vtable. */
4350       TYPE_PRIMARY_BASE (type) = primary_base_class (type);
4351       /* The virtual base list. */
4352       TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type);
4353     }
4354   else
4355     TYPE_RUNTIME_PTR (type) = NULL;
4356
4357   /* If this is a local type (C++ - declared inside a function), record file name & line # */
4358   if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ ))
4359     {
4360       TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info));
4361       TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1);
4362       strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name);
4363       if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0))
4364         TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line;
4365       else
4366         TYPE_LOCALTYPE_LINE (type) = 0;
4367     }
4368   else
4369     TYPE_LOCALTYPE_PTR (type) = NULL;
4370
4371   /* Clear the global saying what template we are in the middle of processing */
4372   current_template = NULL;
4373
4374   return type;
4375 }
4376
4377 /* Adjust the physnames for each static member of a struct
4378    or class type to be something like "A::x"; then various
4379    other pieces of code that do a lookup_symbol on the phyname
4380    work correctly.
4381    TYPE is a pointer to the struct/class type
4382    NAME is a char * (string) which is the class/struct name
4383    Void return */
4384
4385 static void
4386 fix_static_member_physnames (struct type *type, char *class_name,
4387                              struct objfile *objfile)
4388 {
4389   int i;
4390
4391   /* We fix the member names only for classes or structs */
4392   if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
4393     return;
4394
4395   for (i = 0; i < TYPE_NFIELDS (type); i++)
4396     if (TYPE_FIELD_STATIC (type, i))
4397       {
4398         if (TYPE_FIELD_STATIC_PHYSNAME (type, i))
4399           return;               /* physnames are already set */
4400
4401         SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i],
4402                             obstack_alloc (&objfile->objfile_obstack,
4403              strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3));
4404         strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name);
4405         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::");
4406         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i));
4407       }
4408 }
4409
4410 /* Fix-up the type structure for a CLASS so that the type entry
4411  * for a method (previously marked with a null type in hpread_read_struct_type()
4412  * is set correctly to METHOD.
4413  * OBJFILE is as for other such functions.
4414  * Void return. */
4415
4416 static void
4417 fixup_class_method_type (struct type *class, struct type *method,
4418                          struct objfile *objfile)
4419 {
4420   int i, j, k;
4421
4422   if (!class || !method || !objfile)
4423     return;
4424
4425   /* Only for types that have methods */
4426   if ((TYPE_CODE (class) != TYPE_CODE_CLASS) &&
4427       (TYPE_CODE (class) != TYPE_CODE_UNION))
4428     return;
4429
4430   /* Loop over all methods and find the one marked with a NULL type */
4431   for (i = 0; i < TYPE_NFN_FIELDS (class); i++)
4432     for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++)
4433       if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL)
4434         {
4435           /* Set the method type */
4436           TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method;
4437
4438           /* Break out of both loops -- only one method to fix up in a class */
4439           goto finish;
4440         }
4441
4442 finish:
4443   TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE;
4444 }
4445
4446
4447 /* If we're in the middle of processing a template, get a pointer
4448  * to the Nth template argument.
4449  * An example may make this clearer:
4450  *   template <class T1, class T2> class q2 {
4451  *     public:
4452  *     T1 a;
4453  *     T2 b;
4454  *   };
4455  * The type for "a" will be "first template arg" and
4456  * the type for "b" will be "second template arg".
4457  * We need to look these up in order to fill in "a" and "b"'s type.
4458  * This is called from hpread_type_lookup().
4459  */
4460 static struct type *
4461 hpread_get_nth_template_arg (struct objfile *objfile, int n)
4462 {
4463   if (current_template != NULL)
4464     return TYPE_TEMPLATE_ARG (current_template, n).type;
4465   else
4466     return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG);
4467 }
4468
4469 /* Read in and internalize a TEMPL_ARG (template arg) symbol.  */
4470
4471 static struct type *
4472 hpread_read_templ_arg_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4473                             struct objfile *objfile, char *name)
4474 {
4475   struct type *type;
4476
4477   /* See if it's something we've already deal with.  */
4478   type = hpread_alloc_type (hp_type, objfile);
4479   if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG)
4480     return type;
4481
4482   /* Nope.  Fill in the appropriate fields.  */
4483   TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG;
4484   TYPE_LENGTH (type) = 0;
4485   TYPE_NFIELDS (type) = 0;
4486   TYPE_NAME (type) = name;
4487   return type;
4488 }
4489
4490 /* Read in and internalize a set debug symbol.  */
4491
4492 static struct type *
4493 hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4494                       struct objfile *objfile)
4495 {
4496   struct type *type;
4497
4498   /* See if it's something we've already deal with.  */
4499   type = hpread_alloc_type (hp_type, objfile);
4500   if (TYPE_CODE (type) == TYPE_CODE_SET)
4501     return type;
4502
4503   /* Nope.  Fill in the appropriate fields.  */
4504   TYPE_CODE (type) = TYPE_CODE_SET;
4505   TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8;
4506   TYPE_NFIELDS (type) = 0;
4507   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype,
4508                                                 objfile);
4509   return type;
4510 }
4511
4512 /* Read in and internalize an array debug symbol.  */
4513
4514 static struct type *
4515 hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4516                         struct objfile *objfile)
4517 {
4518   struct type *type;
4519
4520   /* Allocate an array type symbol.
4521    * Why no check for already-read here, like in the other
4522    * hpread_read_xxx_type routines?  Because it kept us
4523    * from properly determining the size of the array!
4524    */
4525   type = hpread_alloc_type (hp_type, objfile);
4526
4527   TYPE_CODE (type) = TYPE_CODE_ARRAY;
4528
4529   /* Although the hp-symtab.h does not *require* this to be the case,
4530    * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4531    * I.e., express both array-length and element-length in bits,
4532    * or express both array-length and element-length in bytes.
4533    */
4534   if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) ||
4535         (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes)))
4536     {
4537       warning ("error in hpread_array_type.\n");
4538       return NULL;
4539     }
4540   else if (dn_bufp->darray.arraylength == 0x7fffffff)
4541     {
4542       /* The HP debug format represents char foo[]; as an array with
4543        * length 0x7fffffff.  Internally GDB wants to represent this
4544        *  as an array of length zero.
4545        */
4546       TYPE_LENGTH (type) = 0;
4547     }
4548   else if (dn_bufp->darray.arrayisbytes)
4549     TYPE_LENGTH (type) = dn_bufp->darray.arraylength;
4550   else                          /* arraylength is in bits */
4551     TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
4552
4553   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype,
4554                                                 objfile);
4555
4556   /* The one "field" is used to store the subscript type */
4557   /* Since C and C++ multi-dimensional arrays are simply represented
4558    * as: array of array of ..., we only need one subscript-type
4559    * per array. This subscript type is typically a subrange of integer.
4560    * If this gets extended to support languages like Pascal, then
4561    * we need to fix this to represent multi-dimensional arrays properly.
4562    */
4563   TYPE_NFIELDS (type) = 1;
4564   TYPE_FIELDS (type) = (struct field *)
4565     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field));
4566   TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype,
4567                                                   objfile);
4568   return type;
4569 }
4570
4571 /* Read in and internalize a subrange debug symbol.  */
4572 static struct type *
4573 hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4574                            struct objfile *objfile)
4575 {
4576   struct type *type;
4577
4578   /* Is it something we've already dealt with.  */
4579   type = hpread_alloc_type (hp_type, objfile);
4580   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4581     return type;
4582
4583   /* Nope, internalize it.  */
4584   TYPE_CODE (type) = TYPE_CODE_RANGE;
4585   TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
4586   TYPE_NFIELDS (type) = 2;
4587   TYPE_FIELDS (type)
4588     = (struct field *) obstack_alloc (&objfile->objfile_obstack,
4589                                       2 * sizeof (struct field));
4590
4591   if (dn_bufp->dsubr.dyn_low)
4592     TYPE_FIELD_BITPOS (type, 0) = 0;
4593   else
4594     TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound;
4595
4596   if (dn_bufp->dsubr.dyn_high)
4597     TYPE_FIELD_BITPOS (type, 1) = -1;
4598   else
4599     TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound;
4600   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype,
4601                                                 objfile);
4602   return type;
4603 }
4604
4605 /* struct type * hpread_type_lookup(hp_type, objfile)
4606  *   Arguments:
4607  *     hp_type: A pointer into the DNTT specifying what type we
4608  *              are about to "look up"., or else [for fundamental types
4609  *              like int, float, ...] an "immediate" structure describing
4610  *              the type.
4611  *     objfile: ?
4612  *   Return value: A pointer to a "struct type" (representation of a
4613  *                 type in GDB's internal symbol table - see gdbtypes.h)
4614  *   Routine description:
4615  *     There are a variety of places when scanning the DNTT when we
4616  *     need to interpret a "type" field. The simplest and most basic
4617  *     example is when we're processing the symbol table record
4618  *     for a data symbol (a SVAR or DVAR record). That has
4619  *     a "type" field specifying the type of the data symbol. That
4620  *     "type" field is either an "immediate" type specification (for the
4621  *     fundamental types) or a DNTT pointer (for more complicated types).
4622  *     For the more complicated types, we may or may not have already
4623  *     processed the pointed-to type. (Multiple data symbols can of course
4624  *     share the same type).
4625  *     The job of hpread_type_lookup() is to process this "type" field.
4626  *     Most of the real work is done in subroutines. Here we interpret
4627  *     the immediate flag. If not immediate, chase the DNTT pointer to
4628  *     find our way to the SOM record describing the type, switch on
4629  *     the SOM kind, and then call an appropriate subroutine depending
4630  *     on what kind of type we are constructing. (e.g., an array type,
4631  *     a struct/class type, etc).
4632  */
4633 static struct type *
4634 hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile)
4635 {
4636   union dnttentry *dn_bufp;
4637   struct type *tmp_type;
4638
4639   /* First see if it's a simple builtin type.  */
4640   if (hp_type.dntti.immediate)
4641     {
4642       /* If this is a template argument, the argument number is
4643        * encoded in the bitlength. All other cases, just return
4644        * GDB's representation of this fundamental type.
4645        */
4646       if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG)
4647         return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength);
4648       else
4649         return lookup_fundamental_type (objfile,
4650                                         hpread_type_translate (hp_type));
4651     }
4652
4653   /* Not a builtin type.  We'll have to read it in.  */
4654   if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile))
4655     dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile);
4656   else
4657     /* This is a fancy way of returning NULL */
4658     return lookup_fundamental_type (objfile, FT_VOID);
4659
4660   switch (dn_bufp->dblock.kind)
4661     {
4662     case DNTT_TYPE_SRCFILE:
4663     case DNTT_TYPE_MODULE:
4664     case DNTT_TYPE_ENTRY:
4665     case DNTT_TYPE_BEGIN:
4666     case DNTT_TYPE_END:
4667     case DNTT_TYPE_IMPORT:
4668     case DNTT_TYPE_LABEL:
4669     case DNTT_TYPE_FPARAM:
4670     case DNTT_TYPE_SVAR:
4671     case DNTT_TYPE_DVAR:
4672     case DNTT_TYPE_CONST:
4673     case DNTT_TYPE_MEMENUM:
4674     case DNTT_TYPE_VARIANT:
4675     case DNTT_TYPE_FILE:
4676     case DNTT_TYPE_WITH:
4677     case DNTT_TYPE_COMMON:
4678     case DNTT_TYPE_COBSTRUCT:
4679     case DNTT_TYPE_XREF:
4680     case DNTT_TYPE_SA:
4681     case DNTT_TYPE_MACRO:
4682     case DNTT_TYPE_BLOCKDATA:
4683     case DNTT_TYPE_CLASS_SCOPE:
4684     case DNTT_TYPE_MEMACCESS:
4685     case DNTT_TYPE_INHERITANCE:
4686     case DNTT_TYPE_OBJECT_ID:
4687     case DNTT_TYPE_FRIEND_CLASS:
4688     case DNTT_TYPE_FRIEND_FUNC:
4689       /* These are not types - something went wrong.  */
4690       /* This is a fancy way of returning NULL */
4691       return lookup_fundamental_type (objfile, FT_VOID);
4692
4693     case DNTT_TYPE_FUNCTION:
4694       /* We wind up here when dealing with class member functions
4695        * (called from hpread_read_struct_type(), i.e. when processing
4696        * the class definition itself).
4697        */
4698       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4699
4700     case DNTT_TYPE_DOC_FUNCTION:
4701       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4702
4703     case DNTT_TYPE_TYPEDEF:
4704       {
4705         /* A typedef - chase it down by making a recursive call */
4706         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4707                                                       objfile);
4708
4709         /* The following came from the base hpread.c that we inherited.
4710          * It is WRONG so I have commented it out. - RT
4711          *...
4712
4713          char *suffix;
4714          suffix = VT (objfile) + dn_bufp->dtype.name;
4715          TYPE_NAME (structtype) = suffix;
4716
4717          * ... further explanation ....
4718          *
4719          * What we have here is a typedef pointing to a typedef.
4720          * E.g.,
4721          * typedef int foo;
4722          * typedef foo fum;
4723          *
4724          * What we desire to build is (these are pictures
4725          * of "struct type"'s):
4726          *
4727          *  +---------+     +----------+     +------------+
4728          *  | typedef |     | typedef  |     | fund. type |
4729          *  |     type| ->  |      type| ->  |            |
4730          *  | "fum"   |     | "foo"    |     | "int"      |
4731          *  +---------+     +----------+     +------------+
4732          *
4733          * What this commented-out code is doing is smashing the
4734          * name of pointed-to-type to be the same as the pointed-from
4735          * type. So we wind up with something like:
4736          *
4737          *  +---------+     +----------+     +------------+
4738          *  | typedef |     | typedef  |     | fund. type |
4739          *  |     type| ->  |      type| ->  |            |
4740          *  | "fum"   |     | "fum"    |     | "fum"      |
4741          *  +---------+     +----------+     +------------+
4742          *
4743          */
4744
4745         return structtype;
4746       }
4747
4748     case DNTT_TYPE_TAGDEF:
4749       {
4750         /* Just a little different from above.  We have to tack on
4751          * an identifier of some kind (struct, union, enum, class, etc).
4752          */
4753         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4754                                                       objfile);
4755         char *prefix, *suffix;
4756         suffix = VT (objfile) + dn_bufp->dtype.name;
4757
4758         /* Lookup the next type in the list.  It should be a structure,
4759          * union, class, enum, or template type.
4760          * We will need to attach that to our name.
4761          */
4762         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
4763           dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
4764         else
4765           {
4766             complaint (&symfile_complaints, "error in hpread_type_lookup().");
4767             return NULL;
4768           }
4769
4770         if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
4771           {
4772             prefix = "struct ";
4773           }
4774         else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
4775           {
4776             prefix = "union ";
4777           }
4778         else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
4779           {
4780             /* Further field for CLASS saying how it was really declared */
4781             /* 0==class, 1==union, 2==struct */
4782             if (dn_bufp->dclass.class_decl == 0)
4783               prefix = "class ";
4784             else if (dn_bufp->dclass.class_decl == 1)
4785               prefix = "union ";
4786             else if (dn_bufp->dclass.class_decl == 2)
4787               prefix = "struct ";
4788             else
4789               prefix = "";
4790           }
4791         else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM)
4792           {
4793             prefix = "enum ";
4794           }
4795         else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4796           {
4797             prefix = "template ";
4798           }
4799         else
4800           {
4801             prefix = "";
4802           }
4803
4804         /* Build the correct name.  */
4805         TYPE_NAME (structtype)
4806           = (char *) obstack_alloc (&objfile->objfile_obstack,
4807                                     strlen (prefix) + strlen (suffix) + 1);
4808         TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix);
4809         TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix);
4810         TYPE_TAG_NAME (structtype) = suffix;
4811
4812         /* For classes/structs, we have to set the static member "physnames"
4813            to point to strings like "Class::Member" */
4814         if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT)
4815           fix_static_member_physnames (structtype, suffix, objfile);
4816
4817         return structtype;
4818       }
4819
4820     case DNTT_TYPE_POINTER:
4821       /* Pointer type - call a routine in gdbtypes.c that constructs
4822        * the appropriate GDB type.
4823        */
4824       return make_pointer_type (
4825                                  hpread_type_lookup (dn_bufp->dptr.pointsto,
4826                                                      objfile),
4827                                  NULL);
4828
4829     case DNTT_TYPE_REFERENCE:
4830       /* C++ reference type - call a routine in gdbtypes.c that constructs
4831        * the appropriate GDB type.
4832        */
4833       return make_reference_type (
4834                            hpread_type_lookup (dn_bufp->dreference.pointsto,
4835                                                objfile),
4836                                    NULL);
4837
4838     case DNTT_TYPE_ENUM:
4839       return hpread_read_enum_type (hp_type, dn_bufp, objfile);
4840     case DNTT_TYPE_SET:
4841       return hpread_read_set_type (hp_type, dn_bufp, objfile);
4842     case DNTT_TYPE_SUBRANGE:
4843       return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
4844     case DNTT_TYPE_ARRAY:
4845       return hpread_read_array_type (hp_type, dn_bufp, objfile);
4846     case DNTT_TYPE_STRUCT:
4847     case DNTT_TYPE_UNION:
4848       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4849     case DNTT_TYPE_FIELD:
4850       return hpread_type_lookup (dn_bufp->dfield.type, objfile);
4851
4852     case DNTT_TYPE_FUNCTYPE:
4853       /* Here we want to read the function SOMs and return a
4854        * type for it. We get here, for instance, when processing
4855        * pointer-to-function type.
4856        */
4857       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4858
4859     case DNTT_TYPE_PTRMEM:
4860       /* Declares a C++ pointer-to-data-member type.
4861        * The "pointsto" field defines the class,
4862        * while the "memtype" field defines the pointed-to-type.
4863        */
4864       {
4865         struct type *ptrmemtype;
4866         struct type *class_type;
4867         struct type *memtype;
4868         memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4869                                       objfile),
4870           class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4871                                            objfile),
4872           ptrmemtype = alloc_type (objfile);
4873         smash_to_member_type (ptrmemtype, class_type, memtype);
4874         return make_pointer_type (ptrmemtype, NULL);
4875       }
4876       break;
4877
4878     case DNTT_TYPE_PTRMEMFUNC:
4879       /* Defines a C++ pointer-to-function-member type.
4880        * The "pointsto" field defines the class,
4881        * while the "memtype" field defines the pointed-to-type.
4882        */
4883       {
4884         struct type *ptrmemtype;
4885         struct type *class_type;
4886         struct type *functype;
4887         struct type *retvaltype;
4888         int nargs;
4889         int i;
4890         class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4891                                          objfile);
4892         functype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4893                                        objfile);
4894         retvaltype = TYPE_TARGET_TYPE (functype);
4895         nargs = TYPE_NFIELDS (functype);
4896         ptrmemtype = alloc_type (objfile);
4897
4898         smash_to_method_type (ptrmemtype, class_type, retvaltype,
4899                               TYPE_FIELDS (functype),
4900                               TYPE_NFIELDS (functype),
4901                               0);
4902         return make_pointer_type (ptrmemtype, NULL);
4903       }
4904       break;
4905
4906     case DNTT_TYPE_CLASS:
4907       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4908
4909     case DNTT_TYPE_GENFIELD:
4910       /* Chase pointer from GENFIELD to FIELD, and make recursive
4911        * call on that.
4912        */
4913       return hpread_type_lookup (dn_bufp->dgenfield.field, objfile);
4914
4915     case DNTT_TYPE_VFUNC:
4916       /* C++ virtual function.
4917        * We get here in the course of processing a class type which
4918        * contains virtual functions. Just go through another level
4919        * of indirection to get to the pointed-to function SOM.
4920        */
4921       return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile);
4922
4923     case DNTT_TYPE_MODIFIER:
4924       /* Check the modifiers and then just make a recursive call on
4925        * the "type" pointed to by the modifier DNTT.
4926        *
4927        * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4928        * "m_void" modifiers?  Is static_flag really needed here?
4929        * (m_static used for methods of classes, elsewhere).
4930        */
4931       tmp_type = make_cv_type (dn_bufp->dmodifier.m_const,
4932                                dn_bufp->dmodifier.m_volatile,
4933                       hpread_type_lookup (dn_bufp->dmodifier.type, objfile),
4934                                0);
4935       return tmp_type;
4936
4937
4938     case DNTT_TYPE_MEMFUNC:
4939       /* Member function. Treat like a function.
4940        * I think we get here in the course of processing a
4941        * pointer-to-member-function type...
4942        */
4943       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4944
4945     case DNTT_TYPE_DOC_MEMFUNC:
4946       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4947
4948     case DNTT_TYPE_TEMPLATE:
4949       /* Template - sort of the header for a template definition,
4950        * which like a class, points to a member list and also points
4951        * to a TEMPLATE_ARG list of type-arguments.
4952        */
4953       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4954
4955     case DNTT_TYPE_TEMPLATE_ARG:
4956       {
4957         char *name;
4958         /* The TEMPLATE record points to an argument list of
4959          * TEMPLATE_ARG records, each of which describes one
4960          * of the type-arguments.
4961          */
4962         name = VT (objfile) + dn_bufp->dtempl_arg.name;
4963         return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name);
4964       }
4965
4966     case DNTT_TYPE_FUNC_TEMPLATE:
4967       /* We wind up here when processing a TEMPLATE type,
4968        * if the template has member function(s).
4969        * Treat it like a FUNCTION.
4970        */
4971       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4972
4973     case DNTT_TYPE_LINK:
4974       /* The LINK record is used to link up templates with instantiations.
4975        * There is no type associated with the LINK record per se.
4976        */
4977       return lookup_fundamental_type (objfile, FT_VOID);
4978
4979       /* Also not yet handled... */
4980       /* case DNTT_TYPE_DYN_ARRAY_DESC: */
4981       /* case DNTT_TYPE_DESC_SUBRANGE: */
4982       /* case DNTT_TYPE_BEGIN_EXT: */
4983       /* case DNTT_TYPE_INLN: */
4984       /* case DNTT_TYPE_INLN_LIST: */
4985       /* case DNTT_TYPE_ALIAS: */
4986     default:
4987       /* A fancy way of returning NULL */
4988       return lookup_fundamental_type (objfile, FT_VOID);
4989     }
4990 }
4991
4992 static sltpointer
4993 hpread_record_lines (struct subfile *subfile, sltpointer s_idx,
4994                      sltpointer e_idx, struct objfile *objfile,
4995                      CORE_ADDR offset)
4996 {
4997   union sltentry *sl_bufp;
4998
4999   while (s_idx <= e_idx)
5000     {
5001       sl_bufp = hpread_get_slt (s_idx, objfile);
5002       /* Only record "normal" entries in the SLT.  */
5003       if (sl_bufp->snorm.sltdesc == SLT_NORMAL
5004           || sl_bufp->snorm.sltdesc == SLT_EXIT)
5005         record_line (subfile, sl_bufp->snorm.line,
5006                      sl_bufp->snorm.address + offset);
5007       else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
5008         record_line (subfile, sl_bufp->snormoff.line,
5009                      sl_bufp->snormoff.address + offset);
5010       s_idx++;
5011     }
5012   return e_idx;
5013 }
5014
5015 /* Given a function "f" which is a member of a class, find
5016  * the classname that it is a member of. Used to construct
5017  * the name (e.g., "c::f") which GDB will put in the
5018  * "demangled name" field of the function's symbol.
5019  * Called from hpread_process_one_debug_symbol()
5020  * If "f" is not a member function, return NULL.
5021  */
5022 static char *
5023 class_of (struct type *functype)
5024 {
5025   struct type *first_param_type;
5026   char *first_param_name;
5027   struct type *pointed_to_type;
5028   char *class_name;
5029
5030   /* Check that the function has a first argument "this",
5031    * and that "this" is a pointer to a class. If not,
5032    * functype is not a member function, so return NULL.
5033    */
5034   if (TYPE_NFIELDS (functype) == 0)
5035     return NULL;
5036   first_param_name = TYPE_FIELD_NAME (functype, 0);
5037   if (first_param_name == NULL)
5038     return NULL;                /* paranoia */
5039   if (strcmp (first_param_name, "this"))
5040     return NULL;
5041   first_param_type = TYPE_FIELD_TYPE (functype, 0);
5042   if (first_param_type == NULL)
5043     return NULL;                /* paranoia */
5044   if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR)
5045     return NULL;
5046
5047   /* Get the thing that "this" points to, check that
5048    * it's a class, and get its class name.
5049    */
5050   pointed_to_type = TYPE_TARGET_TYPE (first_param_type);
5051   if (pointed_to_type == NULL)
5052     return NULL;                /* paranoia */
5053   if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS)
5054     return NULL;
5055   class_name = TYPE_NAME (pointed_to_type);
5056   if (class_name == NULL)
5057     return NULL;                /* paranoia */
5058
5059   /* The class name may be of the form "class c", in which case
5060    * we want to strip off the leading "class ".
5061    */
5062   if (strncmp (class_name, "class ", 6) == 0)
5063     class_name += 6;
5064
5065   return class_name;
5066 }
5067
5068 /* Internalize one native debug symbol.
5069  * Called in a loop from hpread_expand_symtab().
5070  * Arguments:
5071  *   dn_bufp:
5072  *   name:
5073  *   section_offsets:
5074  *   objfile:
5075  *   text_offset:
5076  *   text_size:
5077  *   filename:
5078  *   index:             Index of this symbol
5079  *   at_module_boundary_p Pointer to boolean flag to control caller's loop.
5080  */
5081
5082 static void
5083 hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name,
5084                                  struct section_offsets *section_offsets,
5085                                  struct objfile *objfile, CORE_ADDR text_offset,
5086                                  int text_size, char *filename, int index,
5087                                  int *at_module_boundary_p)
5088 {
5089   unsigned long desc;
5090   int type;
5091   CORE_ADDR valu;
5092   int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
5093   int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
5094   union dnttentry *dn_temp;
5095   dnttpointer hp_type;
5096   struct symbol *sym;
5097   struct context_stack *new;
5098   char *class_scope_name;
5099
5100   /* Allocate one GDB debug symbol and fill in some default values. */
5101   sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
5102                                          sizeof (struct symbol));
5103   memset (sym, 0, sizeof (struct symbol));
5104   DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->symbol_obstack);
5105   SYMBOL_LANGUAGE (sym) = language_auto;
5106   SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5107   SYMBOL_LINE (sym) = 0;
5108   SYMBOL_VALUE (sym) = 0;
5109   SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5110
5111   /* Just a trick in case the SOM debug symbol is a type definition.
5112    * There are routines that are set up to build a GDB type symbol, given
5113    * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5114    * This allows us to call those same routines.
5115    */
5116   hp_type.dnttp.extension = 1;
5117   hp_type.dnttp.immediate = 0;
5118   hp_type.dnttp.global = 0;
5119   hp_type.dnttp.index = index;
5120
5121   /* This "type" is the type of SOM record.
5122    * Switch on SOM type.
5123    */
5124   type = dn_bufp->dblock.kind;
5125   switch (type)
5126     {
5127     case DNTT_TYPE_SRCFILE:
5128       /* This type of symbol indicates from which source file or
5129        * include file any following data comes. It may indicate:
5130        *
5131        * o   The start of an entirely new source file (and thus
5132        *     a new module)
5133        *
5134        * o   The start of a different source file due to #include
5135        *
5136        * o   The end of an include file and the return to the original
5137        *     file. Thus if "foo.c" includes "bar.h", we see first
5138        *     a SRCFILE for foo.c, then one for bar.h, and then one for
5139        *     foo.c again.
5140        *
5141        * If it indicates the start of a new module then we must
5142        * finish the symbol table of the previous module
5143        * (if any) and start accumulating a new symbol table.
5144        */
5145
5146       valu = text_offset;
5147       if (!last_source_file)
5148         {
5149           /*
5150            * A note on "last_source_file": this is a char* pointing
5151            * to the actual file name.  "start_symtab" sets it,
5152            * "end_symtab" clears it.
5153            *
5154            * So if "last_source_file" is NULL, then either this is
5155            * the first record we are looking at, or a previous call
5156            * to "end_symtab()" was made to close out the previous
5157            * module.  Since we're now quitting the scan loop when we
5158            * see a MODULE END record, we should never get here, except
5159            * in the case that we're not using the quick look-up tables
5160            * and have to use the old system as a fall-back.
5161            */
5162           start_symtab (name, NULL, valu);
5163           record_debugformat ("HP");
5164           SL_INDEX (objfile) = dn_bufp->dsfile.address;
5165         }
5166
5167       else
5168         {
5169           /* Either a new include file, or a SRCFILE record
5170            * saying we are back in the main source (or out of
5171            * a nested include file) again.
5172            */
5173           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5174                                                     SL_INDEX (objfile),
5175                                                     dn_bufp->dsfile.address,
5176                                                     objfile, offset);
5177         }
5178
5179       /* A note on "start_subfile".  This routine will check
5180        * the name we pass it and look for an existing subfile
5181        * of that name.  There's thus only one sub-file for the
5182        * actual source (e.g. for "foo.c" in foo.c), despite the
5183        * fact that we'll see lots of SRCFILE entries for foo.c
5184        * inside foo.c.
5185        */
5186       start_subfile (name, NULL);
5187       break;
5188
5189     case DNTT_TYPE_MODULE:
5190       /*
5191        * We no longer ignore DNTT_TYPE_MODULE symbols.  The module
5192        * represents the meaningful semantic structure of a compilation
5193        * unit.  We expect to start the psymtab-to-symtab expansion
5194        * looking at a MODULE entry, and to end it at the corresponding
5195        * END MODULE entry.
5196        *
5197        *--Begin outdated comments
5198        *
5199        * This record signifies the start of a new source module
5200        * In C/C++ there is no explicit "module" construct in the language,
5201        * but each compilation unit is implicitly a module and they
5202        * do emit the DNTT_TYPE_MODULE records.
5203        * The end of the module is marked by a matching DNTT_TYPE_END record.
5204        *
5205        * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5206        * is it notices the DNTT_TYPE_END record for the previous
5207        * module (see comments under DNTT_TYPE_END case), and then treats
5208        * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5209        * (i.e., it makes a start_symtab() call).
5210        * This scheme seems a little convoluted, but I'll leave it
5211        * alone on the principle "if it ain't broke don't fix
5212        * it". (RT).
5213        *
5214        *-- End outdated comments
5215        */
5216
5217       valu = text_offset;
5218       if (!last_source_file)
5219         {
5220           /* Start of a new module. We know this because "last_source_file"
5221            * is NULL, which can only happen the first time or if we just
5222            * made a call to end_symtab() to close out the previous module.
5223            */
5224           start_symtab (name, NULL, valu);
5225           SL_INDEX (objfile) = dn_bufp->dmodule.address;
5226         }
5227       else
5228         {
5229           /* This really shouldn't happen if we're using the quick
5230            * look-up tables, as it would mean we'd scanned past an
5231            * END MODULE entry.  But if we're not using the tables,
5232            * we started the module on the SRCFILE entry, so it's ok.
5233            * For now, accept this.
5234            */
5235           /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5236            *           name );
5237            */
5238           *at_module_boundary_p = -1;
5239         }
5240
5241       start_subfile (name, NULL);
5242       break;
5243
5244     case DNTT_TYPE_FUNCTION:
5245     case DNTT_TYPE_ENTRY:
5246       /* A function or secondary entry point.  */
5247       valu = dn_bufp->dfunc.lowaddr + offset;
5248
5249       /* Record lines up to this point. */
5250       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5251                                                 SL_INDEX (objfile),
5252                                                 dn_bufp->dfunc.address,
5253                                                 objfile, offset);
5254
5255       WITHIN_FUNCTION (objfile) = 1;
5256       CURRENT_FUNCTION_VALUE (objfile) = valu;
5257
5258       /* Stack must be empty now.  */
5259       if (context_stack_depth != 0)
5260         lbrac_unmatched_complaint (symnum);
5261       new = push_context (0, valu);
5262
5263       /* Built a type for the function. This includes processing
5264        * the symbol records for the function parameters.
5265        */
5266       SYMBOL_CLASS (sym) = LOC_BLOCK;
5267       SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1);
5268
5269       /* All functions in C++ have prototypes.  For C we don't have enough
5270          information in the debug info.  */
5271       if (SYMBOL_LANGUAGE (sym) == language_cplus)
5272         TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
5273
5274       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5275        * (if any), which we get from the "alias" field of the SOM record
5276        * if that exists.
5277        */
5278       if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5279           dn_bufp->dfunc.alias &&       /* has an alias */
5280           *(char *) (VT (objfile) + dn_bufp->dfunc.alias))      /* not a null string */
5281         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias;
5282       else
5283         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5284
5285       /* Special hack to get around HP compilers' insistence on
5286        * reporting "main" as "_MAIN_" for C/C++ */
5287       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5288           (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0))
5289         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5290
5291       /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5292        * be the demangled name.
5293        */
5294       if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5295         {
5296           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5297            * calling the demangler in libiberty (cplus_demangle()) to
5298            * do the job. This generally does the job, even though
5299            * it's intended for the GNU compiler and not the aCC compiler
5300            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5301            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5302            * Generally, we don't want params when we display
5303            * a demangled name, but when I took out the DMGL_PARAMS,
5304            * some things broke, so I'm leaving it in here, and
5305            * working around the issue in stack.c. - RT
5306            */
5307           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
5308           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) &&
5309               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5310             {
5311
5312               /* Well, the symbol name is mangled, but the
5313                * demangler in libiberty failed so the demangled
5314                * field is still NULL. Try to
5315                * do the job ourselves based on the "name" field
5316                * in the SOM record. A complication here is that
5317                * the name field contains only the function name
5318                * (like "f"), whereas we want the class qualification
5319                * (as in "c::f"). Try to reconstruct that.
5320                */
5321               char *basename;
5322               char *classname;
5323               char *dem_name;
5324               basename = VT (objfile) + dn_bufp->dfunc.name;
5325               classname = class_of (SYMBOL_TYPE (sym));
5326               if (classname)
5327                 {
5328                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5329                   strcpy (dem_name, classname);
5330                   strcat (dem_name, "::");
5331                   strcat (dem_name, basename);
5332                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5333                   SYMBOL_LANGUAGE (sym) = language_cplus;
5334                 }
5335             }
5336         }
5337
5338       /* Add the function symbol to the list of symbols in this blockvector */
5339       if (dn_bufp->dfunc.global)
5340         add_symbol_to_list (sym, &global_symbols);
5341       else
5342         add_symbol_to_list (sym, &file_symbols);
5343       new->name = sym;
5344
5345       /* Search forward to the next BEGIN and also read
5346        * in the line info up to that point.
5347        * Not sure why this is needed.
5348        * In HP FORTRAN this code is harmful since there
5349        * may not be a BEGIN after the FUNCTION.
5350        * So I made it C/C++ specific. - RT
5351        */
5352       if (dn_bufp->dfunc.language == HP_LANGUAGE_C ||
5353           dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5354         {
5355           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5356             {
5357               dn_bufp = hpread_get_lntt (++index, objfile);
5358               if (dn_bufp->dblock.extension)
5359                 continue;
5360             }
5361           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5362                                                     SL_INDEX (objfile),
5363                                                     dn_bufp->dbegin.address,
5364                                                     objfile, offset);
5365           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5366         }
5367       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5368       break;
5369
5370     case DNTT_TYPE_DOC_FUNCTION:
5371       valu = dn_bufp->ddocfunc.lowaddr + offset;
5372
5373       /* Record lines up to this point. */
5374       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5375                                                 SL_INDEX (objfile),
5376                                                 dn_bufp->ddocfunc.address,
5377                                                 objfile, offset);
5378
5379       WITHIN_FUNCTION (objfile) = 1;
5380       CURRENT_FUNCTION_VALUE (objfile) = valu;
5381       /* Stack must be empty now.  */
5382       if (context_stack_depth != 0)
5383         lbrac_unmatched_complaint (symnum);
5384       new = push_context (0, valu);
5385
5386       /* Built a type for the function. This includes processing
5387        * the symbol records for the function parameters.
5388        */
5389       SYMBOL_CLASS (sym) = LOC_BLOCK;
5390       SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1);
5391
5392       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5393        * (if any), which we get from the "alias" field of the SOM record
5394        * if that exists.
5395        */
5396       if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5397           dn_bufp->ddocfunc.alias &&    /* has an alias */
5398           *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias))   /* not a null string */
5399         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias;
5400       else
5401         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5402
5403       /* Special hack to get around HP compilers' insistence on
5404        * reporting "main" as "_MAIN_" for C/C++ */
5405       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5406           (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0))
5407         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5408
5409       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5410         {
5411
5412           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5413            * calling the demangler in libiberty (cplus_demangle()) to
5414            * do the job. This generally does the job, even though
5415            * it's intended for the GNU compiler and not the aCC compiler
5416            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5417            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5418            * Generally, we don't want params when we display
5419            * a demangled name, but when I took out the DMGL_PARAMS,
5420            * some things broke, so I'm leaving it in here, and
5421            * working around the issue in stack.c. - RT
5422            */
5423           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
5424
5425           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) &&
5426               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5427             {
5428
5429               /* Well, the symbol name is mangled, but the
5430                * demangler in libiberty failed so the demangled
5431                * field is still NULL. Try to
5432                * do the job ourselves based on the "name" field
5433                * in the SOM record. A complication here is that
5434                * the name field contains only the function name
5435                * (like "f"), whereas we want the class qualification
5436                * (as in "c::f"). Try to reconstruct that.
5437                */
5438               char *basename;
5439               char *classname;
5440               char *dem_name;
5441               basename = VT (objfile) + dn_bufp->ddocfunc.name;
5442               classname = class_of (SYMBOL_TYPE (sym));
5443               if (classname)
5444                 {
5445                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5446                   strcpy (dem_name, classname);
5447                   strcat (dem_name, "::");
5448                   strcat (dem_name, basename);
5449                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5450                   SYMBOL_LANGUAGE (sym) = language_cplus;
5451                 }
5452             }
5453         }
5454
5455       /* Add the function symbol to the list of symbols in this blockvector */
5456       if (dn_bufp->ddocfunc.global)
5457         add_symbol_to_list (sym, &global_symbols);
5458       else
5459         add_symbol_to_list (sym, &file_symbols);
5460       new->name = sym;
5461
5462       /* Search forward to the next BEGIN and also read
5463        * in the line info up to that point.
5464        * Not sure why this is needed.
5465        * In HP FORTRAN this code is harmful since there
5466        * may not be a BEGIN after the FUNCTION.
5467        * So I made it C/C++ specific. - RT
5468        */
5469       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C ||
5470           dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5471         {
5472           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5473             {
5474               dn_bufp = hpread_get_lntt (++index, objfile);
5475               if (dn_bufp->dblock.extension)
5476                 continue;
5477             }
5478           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5479                                                     SL_INDEX (objfile),
5480                                                     dn_bufp->dbegin.address,
5481                                                     objfile, offset);
5482           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5483         }
5484       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5485       break;
5486
5487     case DNTT_TYPE_BEGIN:
5488       /* Begin a new scope. */
5489       if (context_stack_depth == 1 /* this means we're at function level */  &&
5490           context_stack[0].name != NULL /* this means it's a function */  &&
5491           context_stack[0].depth == 0   /* this means it's the first BEGIN
5492                                            we've seen after the FUNCTION */
5493         )
5494         {
5495           /* This is the first BEGIN after a FUNCTION.
5496            * We ignore this one, since HP compilers always insert
5497            * at least one BEGIN, i.e. it's:
5498            *
5499            *     FUNCTION
5500            *     argument symbols
5501            *     BEGIN
5502            *     local symbols
5503            *        (possibly nested BEGIN ... END's if there are inner { } blocks)
5504            *     END
5505            *     END
5506            *
5507            * By ignoring this first BEGIN, the local symbols get treated
5508            * as belonging to the function scope, and "print func::local_sym"
5509            * works (which is what we want).
5510            */
5511
5512           /* All we do here is increase the depth count associated with
5513            * the FUNCTION entry in the context stack. This ensures that
5514            * the next BEGIN we see (if any), representing a real nested { }
5515            * block, will get processed.
5516            */
5517
5518           context_stack[0].depth++;
5519
5520         }
5521       else
5522         {
5523
5524           /* Record lines up to this SLT pointer. */
5525           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5526                                                     SL_INDEX (objfile),
5527                                                     dn_bufp->dbegin.address,
5528                                                     objfile, offset);
5529           /* Calculate start address of new scope */
5530           valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
5531           valu += offset;       /* Relocate for dynamic loading */
5532           /* We use the scope start DNTT index as nesting depth identifier! */
5533           desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile);
5534           new = push_context (desc, valu);
5535         }
5536       break;
5537
5538     case DNTT_TYPE_END:
5539       /* End a scope.  */
5540
5541       /* Valid end kinds are:
5542        *  MODULE
5543        *  FUNCTION
5544        *  WITH
5545        *  COMMON
5546        *  BEGIN
5547        *  CLASS_SCOPE
5548        */
5549
5550       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5551                                                 SL_INDEX (objfile),
5552                                                 dn_bufp->dend.address,
5553                                                 objfile, offset);
5554       switch (dn_bufp->dend.endkind)
5555         {
5556         case DNTT_TYPE_MODULE:
5557           /* Ending a module ends the symbol table for that module.
5558            * Calling end_symtab() has the side effect of clearing the
5559            * last_source_file pointer, which in turn signals
5560            * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5561            * record as a module-begin.
5562            */
5563           valu = text_offset + text_size + offset;
5564
5565           /* Tell our caller that we're done with expanding the
5566            * debug information for a module.
5567            */
5568           *at_module_boundary_p = 1;
5569
5570           /* Don't do this, as our caller will do it!
5571
5572            *      (void) end_symtab (valu, objfile, 0);
5573            */
5574           break;
5575
5576         case DNTT_TYPE_FUNCTION:
5577           /* Ending a function, well, ends the function's scope.  */
5578           dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
5579                                      objfile);
5580           valu = dn_temp->dfunc.hiaddr + offset;
5581           /* Insert func params into local list */
5582           merge_symbol_lists (&param_symbols, &local_symbols);
5583           new = pop_context ();
5584           /* Make a block for the local symbols within.  */
5585           finish_block (new->name, &local_symbols, new->old_blocks,
5586                         new->start_addr, valu, objfile);
5587           WITHIN_FUNCTION (objfile) = 0;        /* This may have to change for Pascal */
5588           local_symbols = new->locals;
5589           param_symbols = new->params;
5590           break;
5591
5592         case DNTT_TYPE_BEGIN:
5593           if (context_stack_depth == 1 &&
5594               context_stack[0].name != NULL &&
5595               context_stack[0].depth == 1)
5596             {
5597               /* This is the END corresponding to the
5598                * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5599                */
5600               context_stack[0].depth--;
5601             }
5602           else
5603             {
5604               /* Ending a local scope.  */
5605               valu = hpread_get_location (dn_bufp->dend.address, objfile);
5606               /* Why in the hell is this needed?  */
5607               valu += offset + 9;       /* Relocate for dynamic loading */
5608               new = pop_context ();
5609               desc = dn_bufp->dend.beginscope.dnttp.index;
5610               if (desc != new->depth)
5611                 lbrac_mismatch_complaint (symnum);
5612
5613               /* Make a block for the local symbols within.  */
5614               finish_block (new->name, &local_symbols, new->old_blocks,
5615                             new->start_addr, valu, objfile);
5616               local_symbols = new->locals;
5617               param_symbols = new->params;
5618             }
5619           break;
5620
5621         case DNTT_TYPE_WITH:
5622           /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5623            * we can ignore the DNTT_TYPE_END that ends it.
5624            */
5625           break;
5626
5627         case DNTT_TYPE_COMMON:
5628           /* End a FORTRAN common block. We don't currently handle these */
5629           complaint (&symfile_complaints,
5630                      "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n");
5631           break;
5632
5633         case DNTT_TYPE_CLASS_SCOPE:
5634
5635           /* pai: FIXME Not handling nested classes for now -- must
5636              * maintain a stack */
5637           class_scope_name = NULL;
5638
5639 #if 0
5640           /* End a class scope */
5641           valu = hpread_get_location (dn_bufp->dend.address, objfile);
5642           /* Why in the hell is this needed?  */
5643           valu += offset + 9;   /* Relocate for dynamic loading */
5644           new = pop_context ();
5645           desc = dn_bufp->dend.beginscope.dnttp.index;
5646           if (desc != new->depth)
5647             lbrac_mismatch_complaint ((char *) symnum);
5648           /* Make a block for the local symbols within.  */
5649           finish_block (new->name, &local_symbols, new->old_blocks,
5650                         new->start_addr, valu, objfile);
5651           local_symbols = new->locals;
5652           param_symbols = new->params;
5653 #endif
5654           break;
5655
5656         default:
5657           complaint (&symfile_complaints,
5658                      "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.");
5659           break;
5660         }
5661       break;
5662
5663       /* DNTT_TYPE_IMPORT is not handled */
5664
5665     case DNTT_TYPE_LABEL:
5666       SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
5667       break;
5668
5669     case DNTT_TYPE_FPARAM:
5670       /* Function parameters.  */
5671       /* Note 1: This code was present in the 4.16 sources, and then
5672          removed, because fparams are handled in
5673          hpread_read_function_type().  However, while fparam symbols
5674          are indeed handled twice, this code here cannot be removed
5675          because then they don't get added to the local symbol list of
5676          the function's code block, which leads to a failure to look
5677          up locals, "this"-relative member names, etc.  So I've put
5678          this code back in. pai/1997-07-21 */
5679       /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5680          in hpread_read_function_type(), so FPARAMS had to be handled
5681          here.  I changed the location to be the appropriate argument
5682          kinds rather than LOC_LOCAL. pai/1997-08-08 */
5683       /* Note 3: Well, the fix in Note 2 above broke argument printing
5684          in traceback frames, and further it makes assumptions about the
5685          order of the FPARAM entries from HP compilers (cc and aCC in particular
5686          generate them in reverse orders -- fixing one breaks for the other).
5687          So I've added code in hpread_read_function_type() to add fparams
5688          to a param_symbols list for the current context level.  These are
5689          then merged into local_symbols when a function end is reached.
5690          pai/1997-08-11 */
5691
5692       break;                    /* do nothing; handled in hpread_read_function_type() */
5693
5694 #if 0                           /* Old code */
5695       if (dn_bufp->dfparam.regparam)
5696         SYMBOL_CLASS (sym) = LOC_REGISTER;
5697       else if (dn_bufp->dfparam.indirect)
5698         SYMBOL_CLASS (sym) = LOC_REF_ARG;
5699       else
5700         SYMBOL_CLASS (sym) = LOC_ARG;
5701       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5702       if (dn_bufp->dfparam.copyparam)
5703         {
5704           SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5705 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5706           SYMBOL_VALUE (sym)
5707             += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
5708 #endif
5709         }
5710       else
5711         SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5712       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
5713       add_symbol_to_list (sym, &fparam_symbols);
5714       break;
5715 #endif
5716
5717     case DNTT_TYPE_SVAR:
5718       /* Static variables.  */
5719       SYMBOL_CLASS (sym) = LOC_STATIC;
5720
5721       /* Note: There is a case that arises with globals in shared
5722        * libraries where we need to set the address to LOC_INDIRECT.
5723        * This case is if you have a global "g" in one library, and
5724        * it is referenced "extern <type> g;" in another library.
5725        * If we're processing the symbols for the referencing library,
5726        * we'll see a global "g", but in this case the address given
5727        * in the symbol table contains a pointer to the real "g".
5728        * We use the storage class LOC_INDIRECT to indicate this. RT
5729        */
5730       if (is_in_import_list (DEPRECATED_SYMBOL_NAME (sym), objfile))
5731         SYMBOL_CLASS (sym) = LOC_INDIRECT;
5732
5733       SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset;
5734       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
5735
5736       if (dn_bufp->dsvar.global)
5737         add_symbol_to_list (sym, &global_symbols);
5738
5739       else if (WITHIN_FUNCTION (objfile))
5740         add_symbol_to_list (sym, &local_symbols);
5741
5742       else
5743         add_symbol_to_list (sym, &file_symbols);
5744
5745       if (dn_bufp->dsvar.thread_specific)
5746         {
5747           /* Thread-local variable.
5748            */
5749           SYMBOL_CLASS (sym) = LOC_HP_THREAD_LOCAL_STATIC;
5750           SYMBOL_BASEREG (sym) = CR27_REGNUM;
5751
5752           if (objfile->flags & OBJF_SHARED)
5753             {
5754               /*
5755                * This variable is not only thread local but
5756                * in a shared library.
5757                *
5758                * Alas, the shared lib structures are private
5759                * to "somsolib.c".  But C lets us point to one.
5760                */
5761               struct so_list *so;
5762
5763               if (objfile->obj_private == NULL)
5764                 error ("Internal error in reading shared library information.");
5765
5766               so = ((obj_private_data_t *) (objfile->obj_private))->so_info;
5767               if (so == NULL)
5768                 error ("Internal error in reading shared library information.");
5769
5770               /* Thread-locals in shared libraries do NOT have the
5771                * standard offset ("data_offset"), so we re-calculate
5772                * where to look for this variable, using a call-back
5773                * to interpret the private shared-library data.
5774                */
5775               SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location +
5776                 so_lib_thread_start_addr (so);
5777             }
5778         }
5779       break;
5780
5781     case DNTT_TYPE_DVAR:
5782       /* Dynamic variables.  */
5783       if (dn_bufp->ddvar.regvar)
5784         SYMBOL_CLASS (sym) = LOC_REGISTER;
5785       else
5786         SYMBOL_CLASS (sym) = LOC_LOCAL;
5787
5788       SYMBOL_VALUE (sym) = dn_bufp->ddvar.location;
5789 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5790       SYMBOL_VALUE (sym)
5791         += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
5792 #endif
5793       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
5794       if (dn_bufp->ddvar.global)
5795         add_symbol_to_list (sym, &global_symbols);
5796       else if (WITHIN_FUNCTION (objfile))
5797         add_symbol_to_list (sym, &local_symbols);
5798       else
5799         add_symbol_to_list (sym, &file_symbols);
5800       break;
5801
5802     case DNTT_TYPE_CONST:
5803       /* A constant (pascal?).  */
5804       SYMBOL_CLASS (sym) = LOC_CONST;
5805       SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
5806       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
5807       if (dn_bufp->dconst.global)
5808         add_symbol_to_list (sym, &global_symbols);
5809       else if (WITHIN_FUNCTION (objfile))
5810         add_symbol_to_list (sym, &local_symbols);
5811       else
5812         add_symbol_to_list (sym, &file_symbols);
5813       break;
5814
5815     case DNTT_TYPE_TYPEDEF:
5816       /* A typedef. We do want to process these, since a name is
5817        * added to the domain for the typedef'ed name.
5818        */
5819       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5820       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5821       if (dn_bufp->dtype.global)
5822         add_symbol_to_list (sym, &global_symbols);
5823       else if (WITHIN_FUNCTION (objfile))
5824         add_symbol_to_list (sym, &local_symbols);
5825       else
5826         add_symbol_to_list (sym, &file_symbols);
5827       break;
5828
5829     case DNTT_TYPE_TAGDEF:
5830       {
5831         int global = dn_bufp->dtag.global;
5832         /* Structure, union, enum, template, or class tag definition */
5833         /* We do want to process these, since a name is
5834          * added to the domain for the tag name (and if C++ class,
5835          * for the typename also).
5836          */
5837         SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5838
5839         /* The tag contains in its "type" field a pointer to the
5840          * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5841          * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5842          * record that actually defines the type.
5843          */
5844         SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5845         TYPE_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5846         TYPE_TAG_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5847         if (dn_bufp->dtag.global)
5848           add_symbol_to_list (sym, &global_symbols);
5849         else if (WITHIN_FUNCTION (objfile))
5850           add_symbol_to_list (sym, &local_symbols);
5851         else
5852           add_symbol_to_list (sym, &file_symbols);
5853
5854         /* If this is a C++ class, then we additionally
5855          * need to define a typedef for the
5856          * class type. E.g., so that the name "c" becomes visible as
5857          * a type name when the user says "class c { ... }".
5858          * In order to figure this out, we need to chase down the "type"
5859          * field to get to the DNTT_TYPE_CLASS record.
5860          *
5861          * We also add the typename for ENUM. Though this isn't
5862          * strictly correct, it is necessary because of the debug info
5863          * generated by the aCC compiler, in which we cannot
5864          * distinguish between:
5865          *   enum e { ... };
5866          * and
5867          *   typedef enum { ... } e;
5868          * I.e., the compiler emits the same debug info for the above
5869          * two cases, in both cases "e" appearing as a tagdef.
5870          * Therefore go ahead and generate the typename so that
5871          * "ptype e" will work in the above cases.
5872          *
5873          * We also add the typename for TEMPLATE, so as to allow "ptype t"
5874          * when "t" is a template name.
5875          */
5876         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
5877           dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
5878         else
5879           {
5880             complaint (&symfile_complaints, "error processing class tagdef");
5881             return;
5882           }
5883         if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
5884             dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
5885             dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
5886           {
5887             struct symbol *newsym;
5888
5889             newsym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
5890                                                     sizeof (struct symbol));
5891             memset (newsym, 0, sizeof (struct symbol));
5892             DEPRECATED_SYMBOL_NAME (newsym) = name;
5893             SYMBOL_LANGUAGE (newsym) = language_auto;
5894             SYMBOL_DOMAIN (newsym) = VAR_DOMAIN;
5895             SYMBOL_LINE (newsym) = 0;
5896             SYMBOL_VALUE (newsym) = 0;
5897             SYMBOL_CLASS (newsym) = LOC_TYPEDEF;
5898             SYMBOL_TYPE (newsym) = sym->type;
5899             if (global)
5900               add_symbol_to_list (newsym, &global_symbols);
5901             else if (WITHIN_FUNCTION (objfile))
5902               add_symbol_to_list (newsym, &local_symbols);
5903             else
5904               add_symbol_to_list (newsym, &file_symbols);
5905           }
5906       }
5907       break;
5908
5909     case DNTT_TYPE_POINTER:
5910       /* Declares a pointer type. Should not be necessary to do anything
5911        * with the type at this level; these are processed
5912        * at the hpread_type_lookup() level.
5913        */
5914       break;
5915
5916     case DNTT_TYPE_ENUM:
5917       /* Declares an enum type. Should not be necessary to do anything
5918        * with the type at this level; these are processed
5919        * at the hpread_type_lookup() level.
5920        */
5921       break;
5922
5923     case DNTT_TYPE_MEMENUM:
5924       /* Member of enum */
5925       /* Ignored at this level, but hpread_read_enum_type() will take
5926        * care of walking the list of enumeration members.
5927        */
5928       break;
5929
5930     case DNTT_TYPE_SET:
5931       /* Declares a set type. Should not be necessary to do anything
5932        * with the type at this level; these are processed
5933        * at the hpread_type_lookup() level.
5934        */
5935       break;
5936
5937     case DNTT_TYPE_SUBRANGE:
5938       /* Declares a subrange type. Should not be necessary to do anything
5939        * with the type at this level; these are processed
5940        * at the hpread_type_lookup() level.
5941        */
5942       break;
5943
5944     case DNTT_TYPE_ARRAY:
5945       /* Declares an array type. Should not be necessary to do anything
5946        * with the type at this level; these are processed
5947        * at the hpread_type_lookup() level.
5948        */
5949       break;
5950
5951     case DNTT_TYPE_STRUCT:
5952     case DNTT_TYPE_UNION:
5953       /* Declares an struct/union type.
5954        * Should not be necessary to do anything
5955        * with the type at this level; these are processed
5956        * at the hpread_type_lookup() level.
5957        */
5958       break;
5959
5960     case DNTT_TYPE_FIELD:
5961       /* Structure/union/class field */
5962       /* Ignored at this level, but hpread_read_struct_type() will take
5963        * care of walking the list of structure/union/class members.
5964        */
5965       break;
5966
5967       /* DNTT_TYPE_VARIANT is not handled by GDB */
5968
5969       /* DNTT_TYPE_FILE is not handled by GDB */
5970
5971     case DNTT_TYPE_FUNCTYPE:
5972       /* Function type */
5973       /* Ignored at this level, handled within hpread_type_lookup() */
5974       break;
5975
5976     case DNTT_TYPE_WITH:
5977       /* This is emitted within methods to indicate "with <class>"
5978        * scoping rules (i.e., indicate that the class data members
5979        * are directly visible).
5980        * However, since GDB already infers this by looking at the
5981        * "this" argument, interpreting the DNTT_TYPE_WITH
5982        * symbol record is unnecessary.
5983        */
5984       break;
5985
5986     case DNTT_TYPE_COMMON:
5987       /* FORTRAN common. Not yet handled. */
5988       complaint (&symfile_complaints,
5989                  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.");
5990       break;
5991
5992       /* DNTT_TYPE_COBSTRUCT is not handled by GDB.  */
5993       /* DNTT_TYPE_XREF is not handled by GDB.  */
5994       /* DNTT_TYPE_SA is not handled by GDB.  */
5995       /* DNTT_TYPE_MACRO is not handled by GDB */
5996
5997     case DNTT_TYPE_BLOCKDATA:
5998       /* Not sure what this is - part of FORTRAN support maybe?
5999        * Anyway, not yet handled.
6000        */
6001       complaint (&symfile_complaints,
6002                  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.");
6003       break;
6004
6005     case DNTT_TYPE_CLASS_SCOPE:
6006
6007
6008
6009       /* The compiler brackets member functions with a CLASS_SCOPE/END
6010        * pair of records, presumably to put them in a different scope
6011        * from the module scope where they are normally defined.
6012        * E.g., in the situation:
6013        *   void f() { ... }
6014        *   void c::f() { ...}
6015        * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
6016        * This causes "break f" at the module level to pick the
6017        * the file-level function f(), not the member function
6018        * (which needs to be referenced via "break c::f").
6019        *
6020        * Here we record the class name to generate the demangled names of
6021        * member functions later.
6022        *
6023        * FIXME Not being used now for anything -- cplus_demangle seems
6024        * enough for getting the class-qualified names of functions. We
6025        * may need this for handling nested classes and types.  */
6026
6027       /* pai: FIXME Not handling nested classes for now -- need to
6028        * maintain a stack */
6029
6030       dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile);
6031       if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF)
6032         class_scope_name = VT (objfile) + dn_temp->dtag.name;
6033       else
6034         class_scope_name = NULL;
6035
6036 #if 0
6037
6038       /* Begin a new scope.  */
6039       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
6040                                                 SL_INDEX (objfile),
6041                                               dn_bufp->dclass_scope.address,
6042                                                 objfile, offset);
6043       valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile);
6044       valu += offset;           /* Relocate for dynamic loading */
6045       desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile);
6046       /* We use the scope start DNTT index as the nesting depth identifier! */
6047       new = push_context (desc, valu);
6048 #endif
6049       break;
6050
6051     case DNTT_TYPE_REFERENCE:
6052       /* Declares a C++ reference type. Should not be necessary to do anything
6053        * with the type at this level; these are processed
6054        * at the hpread_type_lookup() level.
6055        */
6056       break;
6057
6058     case DNTT_TYPE_PTRMEM:
6059       /* Declares a C++ pointer-to-data-member type. This does not
6060        * need to be handled at this level; being a type description it
6061        * is instead handled at the hpread_type_lookup() level.
6062        */
6063       break;
6064
6065     case DNTT_TYPE_PTRMEMFUNC:
6066       /* Declares a C++ pointer-to-function-member type. This does not
6067        * need to be handled at this level; being a type description it
6068        * is instead handled at the hpread_type_lookup() level.
6069        */
6070       break;
6071
6072     case DNTT_TYPE_CLASS:
6073       /* Declares a class type.
6074        * Should not be necessary to do anything
6075        * with the type at this level; these are processed
6076        * at the hpread_type_lookup() level.
6077        */
6078       break;
6079
6080     case DNTT_TYPE_GENFIELD:
6081       /* I believe this is used for class member functions */
6082       /* Ignored at this level, but hpread_read_struct_type() will take
6083        * care of walking the list of class members.
6084        */
6085       break;
6086
6087     case DNTT_TYPE_VFUNC:
6088       /* Virtual function */
6089       /* This does not have to be handled at this level; handled in
6090        * the course of processing class symbols.
6091        */
6092       break;
6093
6094     case DNTT_TYPE_MEMACCESS:
6095       /* DDE ignores this symbol table record.
6096        * It has something to do with "modified access" to class members.
6097        * I'll assume we can safely ignore it too.
6098        */
6099       break;
6100
6101     case DNTT_TYPE_INHERITANCE:
6102       /* These don't have to be handled here, since they are handled
6103        * within hpread_read_struct_type() in the process of constructing
6104        * a class type.
6105        */
6106       break;
6107
6108     case DNTT_TYPE_FRIEND_CLASS:
6109     case DNTT_TYPE_FRIEND_FUNC:
6110       /* These can safely be ignored, as GDB doesn't need this
6111        * info. DDE only uses it in "describe". We may later want
6112        * to extend GDB's "ptype" to give this info, but for now
6113        * it seems safe enough to ignore it.
6114        */
6115       break;
6116
6117     case DNTT_TYPE_MODIFIER:
6118       /* Intended to supply "modified access" to a type */
6119       /* From the way DDE handles this, it looks like it always
6120        * modifies a type. Therefore it is safe to ignore it at this
6121        * level, and handle it in hpread_type_lookup().
6122        */
6123       break;
6124
6125     case DNTT_TYPE_OBJECT_ID:
6126       /* Just ignore this - that's all DDE does */
6127       break;
6128
6129     case DNTT_TYPE_MEMFUNC:
6130       /* Member function */
6131       /* This does not have to be handled at this level; handled in
6132        * the course of processing class symbols.
6133        */
6134       break;
6135
6136     case DNTT_TYPE_DOC_MEMFUNC:
6137       /* Member function */
6138       /* This does not have to be handled at this level; handled in
6139        * the course of processing class symbols.
6140        */
6141       break;
6142
6143     case DNTT_TYPE_TEMPLATE:
6144       /* Template - sort of the header for a template definition,
6145        * which like a class, points to a member list and also points
6146        * to a TEMPLATE_ARG list of type-arguments.
6147        * We do not need to process TEMPLATE records at this level though.
6148        */
6149       break;
6150
6151     case DNTT_TYPE_TEMPLATE_ARG:
6152       /* The TEMPLATE record points to an argument list of
6153        * TEMPLATE_ARG records, each of which describes one
6154        * of the type-arguments.
6155        * We do not need to process TEMPLATE_ARG records at this level though.
6156        */
6157       break;
6158
6159     case DNTT_TYPE_FUNC_TEMPLATE:
6160       /* This will get emitted for member functions of templates.
6161        * But we don't need to process this record at this level though,
6162        * we will process it in the course of processing a TEMPLATE
6163        * record.
6164        */
6165       break;
6166
6167     case DNTT_TYPE_LINK:
6168       /* The LINK record is used to link up templates with instantiations. */
6169       /* It is not clear why this is needed, and furthermore aCC does
6170        * not appear to generate this, so I think we can safely ignore it. - RT
6171        */
6172       break;
6173
6174       /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6175       /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6176       /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6177       /* DNTT_TYPE_INLN is not handled by GDB */
6178       /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6179       /* DNTT_TYPE_ALIAS is not handled by GDB */
6180
6181     default:
6182       break;
6183     }
6184 }
6185
6186 /* Get nesting depth for a DNTT entry.
6187  * DN_BUFP points to a DNTT entry.
6188  * OBJFILE is the object file.
6189  * REPORT_NESTED is a flag; if 0, real nesting depth is
6190  * reported, if it is 1, the function simply returns a
6191  * non-zero value if the nesting depth is anything > 0.
6192  *
6193  * Return value is an integer.  0 => not a local type / name
6194  * positive return => type or name is local to some
6195  * block or function.
6196  */
6197
6198
6199 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6200    this function now returns 0 right away. It was taking too much time
6201    at start up. Now, though, the local types are not handled correctly.
6202  */
6203
6204
6205 static int
6206 hpread_get_scope_depth (union dnttentry *dn_bufp, struct objfile *objfile,
6207                         int report_nested)
6208 {
6209   int index;
6210   union dnttentry *dn_tmp;
6211   short depth = 0;
6212 /****************************/
6213   return 0;
6214 /****************************/
6215
6216   index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block));
6217
6218   while (--index >= 0)
6219     {
6220       dn_tmp = hpread_get_lntt (index, objfile);
6221       switch (dn_tmp->dblock.kind)
6222         {
6223         case DNTT_TYPE_MODULE:
6224           return depth;
6225         case DNTT_TYPE_END:
6226           /* index is signed int; dnttp.index is 29-bit unsigned int! */
6227           index = (int) dn_tmp->dend.beginscope.dnttp.index;
6228           break;
6229         case DNTT_TYPE_BEGIN:
6230         case DNTT_TYPE_FUNCTION:
6231         case DNTT_TYPE_DOC_FUNCTION:
6232         case DNTT_TYPE_WITH:
6233         case DNTT_TYPE_COMMON:
6234         case DNTT_TYPE_CLASS_SCOPE:
6235           depth++;
6236           if (report_nested)
6237             return 1;
6238           break;
6239         default:
6240           break;
6241         }
6242     }
6243   return depth;
6244 }
6245
6246 /* Adjust the bitoffsets for all fields of an anonymous union of
6247    type TYPE by negative BITS.  This handles HP aCC's hideous habit
6248    of giving members of anonymous unions bit offsets relative to the
6249    enclosing structure instead of relative to the union itself. */
6250
6251 static void
6252 hpread_adjust_bitoffsets (struct type *type, int bits)
6253 {
6254   int i;
6255
6256   /* This is done only for unions; caller had better check that
6257      it is an anonymous one. */
6258   if (TYPE_CODE (type) != TYPE_CODE_UNION)
6259     return;
6260
6261   /* Adjust each field; since this is a union, there are no base
6262      classes. Also no static membes.  Also, no need for recursion as
6263      the members of this union if themeselves structs or unions, have
6264      the correct bitoffsets; if an anonymous union is a member of this
6265      anonymous union, the code in hpread_read_struct_type() will
6266      adjust for that. */
6267
6268   for (i = 0; i < TYPE_NFIELDS (type); i++)
6269     TYPE_FIELD_BITPOS (type, i) -= bits;
6270 }
6271
6272 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6273    classes, we have to chase through a chain of threaded FIELD entries.
6274    If we encounter an anonymous union in the chain, we must recursively skip over
6275    that too.
6276
6277    This function does a "next" in the chain of FIELD entries, but transparently
6278    skips over anonymous unions' fields (recursively).
6279
6280    Inputs are the number of times to do "next" at the top level, the dnttpointer
6281    (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6282    and the ubiquitous objfile parameter. (Note: FIELDP is a **.)  Return value
6283    is a dnttpointer for the new field after all the skipped ones */
6284
6285 static dnttpointer
6286 hpread_get_next_skip_over_anon_unions (int skip_fields, dnttpointer field,
6287                                        union dnttentry **fieldp,
6288                                        struct objfile *objfile)
6289 {
6290   struct type *anon_type;
6291   int i;
6292   int bitoffset;
6293   char *name;
6294
6295   for (i = 0; i < skip_fields; i++)
6296     {
6297       /* Get type of item we're looking at now; recursively processes the types
6298          of these intermediate items we skip over, so they aren't lost. */
6299       anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile);
6300       anon_type = CHECK_TYPEDEF (anon_type);
6301       bitoffset = (*fieldp)->dfield.bitoffset;
6302       name = VT (objfile) + (*fieldp)->dfield.name;
6303       /* First skip over one item to avoid stack death on recursion */
6304       field = (*fieldp)->dfield.nextfield;
6305       *fieldp = hpread_get_lntt (field.dnttp.index, objfile);
6306       /* Do we have another anonymous union? If so, adjust the bitoffsets
6307          of its members and skip over its members. */
6308       if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) &&
6309           (!name || DEPRECATED_STREQ (name, "")))
6310         {
6311           hpread_adjust_bitoffsets (anon_type, bitoffset);
6312           field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile);
6313         }
6314     }
6315   return field;
6316 }