contrib/gdb-6.2.1/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 #include "hppa-tdep.h"
  41
  42 /* Private information attached to an objfile which we use to find
  43    and internalize the HP C debug symbols within that objfile.  */
  44
  45 struct hpread_symfile_info
  46   {
  47     /* The contents of each of the debug sections (there are 4 of them).  */
  48     char *gntt;
  49     char *lntt;
  50     char *slt;
  51     char *vt;
  52
  53     /* We keep the size of the $VT$ section for range checking.  */
  54     unsigned int vt_size;
  55
  56     /* Some routines still need to know the number of symbols in the
  57        main debug sections ($LNTT$ and $GNTT$). */
  58     unsigned int lntt_symcount;
  59     unsigned int gntt_symcount;
  60
  61     /* To keep track of all the types we've processed.  */
  62     struct type **dntt_type_vector;
  63     int dntt_type_vector_length;
  64
  65     /* Keeps track of the beginning of a range of source lines.  */
  66     sltpointer sl_index;
  67
  68     /* Some state variables we'll need.  */
  69     int within_function;
  70
  71     /* Keep track of the current function's address.  We may need to look
  72        up something based on this address.  */
  73     unsigned int current_function_value;
  74   };
  75
  76 /* Accessor macros to get at the fields.  */
  77 #define HPUX_SYMFILE_INFO(o) \
  78   ((struct hpread_symfile_info *)((o)->sym_private))
  79 #define GNTT(o)                 (HPUX_SYMFILE_INFO(o)->gntt)
  80 #define LNTT(o)                 (HPUX_SYMFILE_INFO(o)->lntt)
  81 #define SLT(o)                  (HPUX_SYMFILE_INFO(o)->slt)
  82 #define VT(o)                   (HPUX_SYMFILE_INFO(o)->vt)
  83 #define VT_SIZE(o)              (HPUX_SYMFILE_INFO(o)->vt_size)
  84 #define LNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->lntt_symcount)
  85 #define GNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->gntt_symcount)
  86 #define DNTT_TYPE_VECTOR(o)     (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
  87 #define DNTT_TYPE_VECTOR_LENGTH(o) \
  88   (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
  89 #define SL_INDEX(o)             (HPUX_SYMFILE_INFO(o)->sl_index)
  90 #define WITHIN_FUNCTION(o)      (HPUX_SYMFILE_INFO(o)->within_function)
  91 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
  92
  93 \f
  94 /* We put a pointer to this structure in the read_symtab_private field
  95    of the psymtab.  */
  96
  97 struct symloc
  98   {
  99     /* The offset within the file symbol table of first local symbol for
 100        this file.  */
 101
 102     int ldsymoff;
 103
 104     /* Length (in bytes) of the section of the symbol table devoted to
 105        this file's symbols (actually, the section bracketed may contain
 106        more than just this file's symbols).  If ldsymlen is 0, the only
 107        reason for this thing's existence is the dependency list.
 108        Nothing else will happen when it is read in.  */
 109
 110     int ldsymlen;
 111   };
 112
 113 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
 114 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
 115 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
 116 \f
 117 /* Complaints about the symbols we have encountered.  */
 118 static void
 119 lbrac_unmatched_complaint (int arg1)
 120 {
 121   complaint (&symfile_complaints, "unmatched N_LBRAC before symtab pos %d",
 122              arg1);
 123 }
 124
 125 static void
 126 lbrac_mismatch_complaint (int arg1)
 127 {
 128   complaint (&symfile_complaints,
 129              "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
 130 }
 131
 132 /* To generate dumping code, uncomment this define.  The dumping
 133    itself is controlled by routine-local statics called "dumping". */
 134 /* #define DUMPING         1 */
 135
 136 /* To use the quick look-up tables, uncomment this define. */
 137 #define QUICK_LOOK_UP      1
 138
 139 /* To call PXDB to process un-processed files, uncomment this define. */
 140 #define USE_PXDB           1
 141
 142 /* Forward procedure declarations */
 143
 144 /* Used in somread.c.  */
 145 void hpread_symfile_init (struct objfile *);
 146
 147 void do_pxdb (bfd *);
 148
 149 void hpread_build_psymtabs (struct objfile *, int);
 150
 151 void hpread_symfile_finish (struct objfile *);
 152
 153 static void set_namestring (union dnttentry *sym, char **namep,
 154                             struct objfile *objfile);
 155
 156 static union dnttentry *hpread_get_gntt (int, struct objfile *);
 157
 158 static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile);
 159
 160
 161 static unsigned long hpread_get_textlow (int, int, struct objfile *, int);
 162
 163 static struct partial_symtab *hpread_start_psymtab
 164   (struct objfile *, char *, CORE_ADDR, int,
 165    struct partial_symbol **, struct partial_symbol **);
 166
 167 static struct partial_symtab *hpread_end_psymtab
 168   (struct partial_symtab *, char **, int, int, CORE_ADDR,
 169    struct partial_symtab **, int);
 170
 171 static unsigned long hpread_get_scope_start (sltpointer, struct objfile *);
 172
 173 static unsigned long hpread_get_line (sltpointer, struct objfile *);
 174
 175 static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);
 176
 177 static int hpread_has_name (enum dntt_entry_type kind);
 178
 179 static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);
 180
 181 static void hpread_psymtab_to_symtab (struct partial_symtab *);
 182
 183 static struct symtab *hpread_expand_symtab
 184   (struct objfile *, int, int, CORE_ADDR, int,
 185    struct section_offsets *, char *);
 186
 187 static int hpread_type_translate (dnttpointer);
 188
 189 static struct type **hpread_lookup_type (dnttpointer, struct objfile *);
 190
 191 static struct type *hpread_alloc_type (dnttpointer, struct objfile *);
 192
 193 static struct type *hpread_read_enum_type
 194   (dnttpointer, union dnttentry *, struct objfile *);
 195
 196 static struct type *hpread_read_function_type
 197   (dnttpointer, union dnttentry *, struct objfile *, int);
 198
 199 static struct type *hpread_read_doc_function_type
 200   (dnttpointer, union dnttentry *, struct objfile *, int);
 201
 202 static struct type *hpread_read_struct_type
 203   (dnttpointer, union dnttentry *, struct objfile *);
 204
 205 static struct type *hpread_get_nth_template_arg (struct objfile *, int);
 206
 207 static struct type *hpread_read_templ_arg_type
 208   (dnttpointer, union dnttentry *, struct objfile *, char *);
 209
 210 static struct type *hpread_read_set_type
 211   (dnttpointer, union dnttentry *, struct objfile *);
 212
 213 static struct type *hpread_read_array_type
 214   (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile);
 215
 216 static struct type *hpread_read_subrange_type
 217   (dnttpointer, union dnttentry *, struct objfile *);
 218
 219 static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
 220
 221 static sltpointer hpread_record_lines
 222   (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
 223
 224 static void hpread_process_one_debug_symbol
 225   (union dnttentry *, char *, struct section_offsets *,
 226    struct objfile *, CORE_ADDR, int, char *, int, int *);
 227
 228 static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int);
 229
 230 static void fix_static_member_physnames
 231   (struct type *, char *, struct objfile *);
 232
 233 static void fixup_class_method_type
 234   (struct type *, struct type *, struct objfile *);
 235
 236 static void hpread_adjust_bitoffsets (struct type *, int);
 237
 238 static int hpread_adjust_stack_address (CORE_ADDR func_addr);
 239
 240 static dnttpointer hpread_get_next_skip_over_anon_unions
 241   (int, dnttpointer, union dnttentry **, struct objfile *);
 242
 243 \f
 244 /* Static used to indicate a class type that requires a
 245    fix-up of one of its method types */
 246 static struct type *fixup_class = NULL;
 247
 248 /* Static used to indicate the method type that is to be
 249    used to fix-up the type for fixup_class */
 250 static struct type *fixup_method = NULL;
 251
 252 #ifdef USE_PXDB
 253
 254 /* NOTE use of system files!  May not be portable. */
 255
 256 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
 257 #define PXDB_BSD  "/usr/bin/pxdb"
 258
 259 #include <stdlib.h>
 260 #include "gdb_string.h"
 261
 262 /* check for the existence of a file, given its full pathname */
 263 static int
 264 file_exists (char *filename)
 265 {
 266   if (filename)
 267     return (access (filename, F_OK) == 0);
 268   return 0;
 269 }
 270
 271
 272 /* Translate from the "hp_language" enumeration in hp-symtab.h
 273    used in the debug info to gdb's generic enumeration in defs.h. */
 274 static enum language
 275 trans_lang (enum hp_language in_lang)
 276 {
 277   if (in_lang == HP_LANGUAGE_C)
 278     return language_c;
 279
 280   else if (in_lang == HP_LANGUAGE_CPLUSPLUS)
 281     return language_cplus;
 282
 283   else if (in_lang == HP_LANGUAGE_FORTRAN)
 284     return language_fortran;
 285
 286   else
 287     return language_unknown;
 288 }
 289
 290 static char main_string[] = "main";
 291 \f
 292
 293 /* Given the native debug symbol SYM, set NAMEP to the name associated
 294    with the debug symbol.  Note we may be called with a debug symbol which
 295    has no associated name, in that case we return an empty string.  */
 296
 297 static void
 298 set_namestring (union dnttentry *sym, char **namep, struct objfile *objfile)
 299 {
 300   /* Note that we "know" that the name for any symbol is always in the same
 301      place.  Hence we don't have to conditionalize on the symbol type.  */
 302   if (! hpread_has_name (sym->dblock.kind))
 303     *namep = "";
 304   else if ((unsigned) sym->dsfile.name >= VT_SIZE (objfile))
 305     {
 306       complaint (&symfile_complaints, "bad string table offset in symbol %d",
 307                  symnum);
 308       *namep = "";
 309     }
 310   else
 311     *namep = sym->dsfile.name + VT (objfile);
 312 }
 313
 314 /* Call PXDB to process our file.
 315
 316    Approach copied from DDE's "dbgk_run_pxdb".  Note: we
 317    don't check for BSD location of pxdb, nor for existence
 318    of pxdb itself, etc.
 319
 320    NOTE: uses system function and string functions directly.
 321
 322    Return value: 1 if ok, 0 if not */
 323 static int
 324 hpread_call_pxdb (const char *file_name)
 325 {
 326   char *p;
 327   int status;
 328   int retval;
 329
 330   if (file_exists (PXDB_SVR4))
 331     {
 332       p = xmalloc (strlen (PXDB_SVR4) + strlen (file_name) + 2);
 333       strcpy (p, PXDB_SVR4);
 334       strcat (p, " ");
 335       strcat (p, file_name);
 336
 337       warning ("File not processed by pxdb--about to process now.\n");
 338       status = system (p);
 339
 340       retval = (status == 0);
 341     }
 342   else
 343     {
 344       warning ("pxdb not found at standard location: /opt/langtools/bin\ngdb will not be able to debug %s.\nPlease install pxdb at the above location and then restart gdb.\nYou can also run pxdb on %s with the command\n\"pxdb %s\" and then restart gdb.", file_name, file_name, file_name);
 345
 346       retval = 0;
 347     }
 348   return retval;
 349 }                               /* hpread_call_pxdb */
 350 \f
 351
 352 /* Return 1 if the file turns out to need pre-processing
 353    by PXDB, and we have thus called PXDB to do this processing
 354    and the file therefore needs to be re-loaded.  Otherwise
 355    return 0. */
 356 static int
 357 hpread_pxdb_needed (bfd *sym_bfd)
 358 {
 359   asection *pinfo_section, *debug_section, *header_section;
 360   unsigned int do_pxdb;
 361   char *buf;
 362   bfd_size_type header_section_size;
 363
 364   unsigned long tmp;
 365   unsigned int pxdbed;
 366
 367   header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$");
 368   if (!header_section)
 369     {
 370       return 0;                 /* No header at all, can't recover... */
 371     }
 372
 373   debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$");
 374   pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$");
 375
 376   if (pinfo_section && !debug_section)
 377     {
 378       /* Debug info with DOC, has different header format.
 379          this only happens if the file was pxdbed and compiled optimized
 380          otherwise the PINFO section is not there. */
 381       header_section_size = bfd_section_size (objfile->obfd, header_section);
 382
 383       if (header_section_size == (bfd_size_type) sizeof (DOC_info_PXDB_header))
 384         {
 385           buf = alloca (sizeof (DOC_info_PXDB_header));
 386           memset (buf, 0, sizeof (DOC_info_PXDB_header));
 387
 388           if (!bfd_get_section_contents (sym_bfd,
 389                                          header_section,
 390                                          buf, 0,
 391                                          header_section_size))
 392             error ("bfd_get_section_contents\n");
 393
 394           tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 4));
 395           pxdbed = (tmp >> 31) & 0x1;
 396
 397           if (!pxdbed)
 398             error ("file debug header info invalid\n");
 399           do_pxdb = 0;
 400         }
 401
 402       else
 403         error ("invalid $HEADER$ size in executable \n");
 404     }
 405
 406   else
 407     {
 408
 409       /* this can be three different cases:
 410          1. pxdbed and not doc
 411          - DEBUG and HEADER sections are there
 412          - header is PXDB_header type
 413          - pxdbed flag is set to 1
 414
 415          2. not pxdbed and doc
 416          - DEBUG and HEADER  sections are there
 417          - header is DOC_info_header type
 418          - pxdbed flag is set to 0
 419
 420          3. not pxdbed and not doc
 421          - DEBUG and HEADER sections are there
 422          - header is XDB_header type
 423          - pxdbed flag is set to 0
 424
 425          NOTE: the pxdbed flag is meaningful also in the not
 426          already pxdb processed version of the header,
 427          because in case on non-already processed by pxdb files
 428          that same bit in the header would be always zero.
 429          Why? Because the bit is the leftmost bit of a word
 430          which contains a 'length' which is always a positive value
 431          so that bit is never set to 1 (otherwise it would be negative)
 432
 433          Given the above, we have two choices : either we ignore the
 434          size of the header itself and just look at the pxdbed field,
 435          or we check the size and then we (for safety and paranoia related
 436          issues) check the bit.
 437          The first solution is used by DDE, the second by PXDB itself.
 438          I am using the second one here, because I already wrote it,
 439          and it is the end of a long day.
 440          Also, using the first approach would still involve size issues
 441          because we need to read in the contents of the header section, and
 442          give the correct amount of stuff we want to read to the
 443          get_bfd_section_contents function.  */
 444
 445       /* decide which case depending on the size of the header section.
 446          The size is as defined in hp-symtab.h  */
 447
 448       header_section_size = bfd_section_size (objfile->obfd, header_section);
 449
 450       if (header_section_size == (bfd_size_type) sizeof (PXDB_header))  /* pxdb and not doc */
 451         {
 452
 453           buf = alloca (sizeof (PXDB_header));
 454           memset (buf, 0, sizeof (PXDB_header));
 455           if (!bfd_get_section_contents (sym_bfd,
 456                                          header_section,
 457                                          buf, 0,
 458                                          header_section_size))
 459             error ("bfd_get_section_contents\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->objfile_obstack,
1684                      bfd_section_size (objfile->obfd, gntt_section));
1685
1686   bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile),
1687                          0, bfd_section_size (objfile->obfd, gntt_section));
1688
1689   GNTT_SYMCOUNT (objfile)
1690     = bfd_section_size (objfile->obfd, gntt_section)
1691     / sizeof (struct dntt_type_block);
1692
1693   /* Read in data from the $LNTT$ subspace.   Also keep track of the number
1694      of LNTT symbols.
1695
1696      FIXME: this could be moved into the psymtab-to-symtab expansion
1697      code, and save startup time.  At the moment this data is
1698      still used, though.  We'd need a way to tell hp-symtab-read.c
1699      whether or not to load the LNTT. */
1700   lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$");
1701   if (!lntt_section)
1702     return;
1703
1704   LNTT (objfile)
1705     = obstack_alloc (&objfile->objfile_obstack,
1706                      bfd_section_size (objfile->obfd, lntt_section));
1707
1708   bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile),
1709                          0, bfd_section_size (objfile->obfd, lntt_section));
1710
1711   LNTT_SYMCOUNT (objfile)
1712     = bfd_section_size (objfile->obfd, lntt_section)
1713     / sizeof (struct dntt_type_block);
1714
1715   /* Read in data from the $SLT$ subspace.  $SLT$ contains information
1716      on source line numbers.  */
1717   slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$");
1718   if (!slt_section)
1719     return;
1720
1721   SLT (objfile) =
1722     obstack_alloc (&objfile->objfile_obstack,
1723                    bfd_section_size (objfile->obfd, slt_section));
1724
1725   bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile),
1726                           0, bfd_section_size (objfile->obfd, slt_section));
1727
1728   /* Read in data from the $VT$ subspace.  $VT$ contains things like
1729      names and constants.  Keep track of the number of symbols in the VT.  */
1730   vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$");
1731   if (!vt_section)
1732     return;
1733
1734   VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section);
1735
1736   VT (objfile) =
1737     (char *) obstack_alloc (&objfile->objfile_obstack,
1738                             VT_SIZE (objfile));
1739
1740   bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile),
1741                             0, VT_SIZE (objfile));
1742 }
1743
1744 /* Scan and build partial symbols for a symbol file.
1745
1746    The minimal symbol table (either SOM or HP a.out) has already been
1747    read in; all we need to do is setup partial symbols based on the
1748    native debugging information.
1749
1750    Note that the minimal table is produced by the linker, and has
1751    only global routines in it; the psymtab is based on compiler-
1752    generated debug information and has non-global
1753    routines in it as well as files and class information.
1754
1755    We assume hpread_symfile_init has been called to initialize the
1756    symbol reader's private data structures.
1757
1758    MAINLINE is true if we are reading the main symbol table (as
1759    opposed to a shared lib or dynamically loaded file). */
1760
1761 void
1762 hpread_build_psymtabs (struct objfile *objfile, int mainline)
1763 {
1764
1765 #ifdef DUMPING
1766   /* Turn this on to get debugging output. */
1767   static int dumping = 0;
1768 #endif
1769
1770   char *namestring;
1771   int past_first_source_file = 0;
1772   struct cleanup *old_chain;
1773
1774   int hp_symnum, symcount, i;
1775   int scan_start = 0;
1776
1777   union dnttentry *dn_bufp;
1778   unsigned long valu;
1779   char *p;
1780   int texthigh = 0;
1781   int have_name = 0;
1782
1783   /* Current partial symtab */
1784   struct partial_symtab *pst;
1785
1786   /* List of current psymtab's include files */
1787   char **psymtab_include_list;
1788   int includes_allocated;
1789   int includes_used;
1790
1791   /* Index within current psymtab dependency list */
1792   struct partial_symtab **dependency_list;
1793   int dependencies_used, dependencies_allocated;
1794
1795   /* Just in case the stabs reader left turds lying around.  */
1796   free_pending_blocks ();
1797   make_cleanup (really_free_pendings, 0);
1798
1799   pst = (struct partial_symtab *) 0;
1800
1801   /* We shouldn't use alloca, instead use malloc/free.  Doing so avoids
1802      a number of problems with cross compilation and creating useless holes
1803      in the stack when we have to allocate new entries.  FIXME.  */
1804
1805   includes_allocated = 30;
1806   includes_used = 0;
1807   psymtab_include_list = (char **) alloca (includes_allocated *
1808                                            sizeof (char *));
1809
1810   dependencies_allocated = 30;
1811   dependencies_used = 0;
1812   dependency_list =
1813     (struct partial_symtab **) alloca (dependencies_allocated *
1814                                        sizeof (struct partial_symtab *));
1815
1816   old_chain = make_cleanup_free_objfile (objfile);
1817
1818   last_source_file = 0;
1819
1820 #ifdef QUICK_LOOK_UP
1821   {
1822     /* Begin code for new-style loading of quick look-up tables. */
1823
1824     /* elz: this checks whether the file has beeen processed by pxdb.
1825        If not we would like to try to read the psymbols in
1826        anyway, but it turns out to be not so easy. So this could
1827        actually be commented out, but I leave it in, just in case
1828        we decide to add support for non-pxdb-ed stuff in the future. */
1829     PXDB_header pxdb_header;
1830     int found_modules_in_program;
1831
1832     if (hpread_get_header (objfile, &pxdb_header))
1833       {
1834         /* Build a minimal table.  No types, no global variables,
1835            no include files.... */
1836 #ifdef DUMPING
1837         if (dumping)
1838           printf ("\nNew method for %s\n", objfile->name);
1839 #endif
1840
1841         /* elz: quick_traverse returns true if it found
1842            some modules in the main source file, other
1843            than those in end.c
1844            In C and C++, all the files have MODULES entries
1845            in the LNTT, and the quick table traverse is all
1846            based on finding these MODULES entries. Without
1847            those it cannot work.
1848            It happens that F77 programs don't have MODULES
1849            so the quick traverse gets confused. F90 programs
1850            have modules, and the quick method still works.
1851            So, if modules (other than those in end.c) are
1852            not found we give up on the quick table stuff,
1853            and fall back on the slower method  */
1854         found_modules_in_program = hpread_quick_traverse (objfile,
1855                                                           GNTT (objfile),
1856                                                           VT (objfile),
1857                                                           &pxdb_header);
1858
1859         discard_cleanups (old_chain);
1860
1861         /* Set up to scan the global section of the LNTT.
1862
1863            This field is not always correct: if there are
1864            no globals, it will point to the last record in
1865            the regular LNTT, which is usually an END MODULE.
1866
1867            Since it might happen that there could be a file
1868            with just one global record, there's no way to
1869            tell other than by looking at the record, so that's
1870            done below. */
1871         if (found_modules_in_program)
1872           scan_start = pxdb_header.globals;
1873       }
1874 #ifdef DUMPING
1875     else
1876       {
1877         if (dumping)
1878           printf ("\nGoing on to old method for %s\n", objfile->name);
1879       }
1880 #endif
1881   }
1882 #endif /* QUICK_LOOK_UP */
1883
1884   /* Make two passes, one over the GNTT symbols, the other for the
1885      LNTT symbols.
1886
1887      JB comment: above isn't true--they only make one pass, over
1888      the LNTT.  */
1889   for (i = 0; i < 1; i++)
1890     {
1891       int within_function = 0;
1892
1893       if (i)
1894         symcount = GNTT_SYMCOUNT (objfile);
1895       else
1896         symcount = LNTT_SYMCOUNT (objfile);
1897
1898
1899       for (hp_symnum = scan_start; hp_symnum < symcount; hp_symnum++)
1900         {
1901           QUIT;
1902           if (i)
1903             dn_bufp = hpread_get_gntt (hp_symnum, objfile);
1904           else
1905             dn_bufp = hpread_get_lntt (hp_symnum, objfile);
1906
1907           if (dn_bufp->dblock.extension)
1908             continue;
1909
1910           /* Only handle things which are necessary for minimal symbols.
1911              everything else is ignored.  */
1912           switch (dn_bufp->dblock.kind)
1913             {
1914             case DNTT_TYPE_SRCFILE:
1915               {
1916 #ifdef QUICK_LOOK_UP
1917                 if (scan_start == hp_symnum
1918                     && symcount == hp_symnum + 1)
1919                   {
1920                     /* If there are NO globals in an executable,
1921                        PXDB's index to the globals will point to
1922                        the last record in the file, which
1923                        could be this record. (this happened for F77 libraries)
1924                        ignore it and be done! */
1925                     continue;
1926                   }
1927 #endif /* QUICK_LOOK_UP */
1928
1929                 /* A source file of some kind.  Note this may simply
1930                    be an included file.  */
1931                 set_namestring (dn_bufp, &namestring, objfile);
1932
1933                 /* Check if this is the source file we are already working
1934                    with.  */
1935                 if (pst && !strcmp (namestring, pst->filename))
1936                   continue;
1937
1938                 /* Check if this is an include file, if so check if we have
1939                    already seen it.  Add it to the include list */
1940                 p = strrchr (namestring, '.');
1941                 if (!strcmp (p, ".h"))
1942                   {
1943                     int j, found;
1944
1945                     found = 0;
1946                     for (j = 0; j < includes_used; j++)
1947                       if (!strcmp (namestring, psymtab_include_list[j]))
1948                         {
1949                           found = 1;
1950                           break;
1951                         }
1952                     if (found)
1953                       continue;
1954
1955                     /* Add it to the list of includes seen so far and
1956                        allocate more include space if necessary.  */
1957                     psymtab_include_list[includes_used++] = namestring;
1958                     if (includes_used >= includes_allocated)
1959                       {
1960                         char **orig = psymtab_include_list;
1961
1962                         psymtab_include_list = (char **)
1963                           alloca ((includes_allocated *= 2) *
1964                                   sizeof (char *));
1965                         memcpy (psymtab_include_list, orig,
1966                                 includes_used * sizeof (char *));
1967                       }
1968                     continue;
1969                   }
1970
1971                 if (pst)
1972                   {
1973                     if (!have_name)
1974                       {
1975                         pst->filename = (char *)
1976                           obstack_alloc (&pst->objfile->objfile_obstack,
1977                                          strlen (namestring) + 1);
1978                         strcpy (pst->filename, namestring);
1979                         have_name = 1;
1980                         continue;
1981                       }
1982                     continue;
1983                   }
1984
1985                 /* This is a bonafide new source file.
1986                    End the current partial symtab and start a new one.  */
1987
1988                 if (pst && past_first_source_file)
1989                   {
1990                     hpread_end_psymtab (pst, psymtab_include_list,
1991                                         includes_used,
1992                                         (hp_symnum
1993                                          * sizeof (struct dntt_type_block)),
1994                                         texthigh,
1995                                         dependency_list, dependencies_used);
1996                     pst = (struct partial_symtab *) 0;
1997                     includes_used = 0;
1998                     dependencies_used = 0;
1999                   }
2000                 else
2001                   past_first_source_file = 1;
2002
2003                 valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
2004                 valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2005                 pst = hpread_start_psymtab (objfile,
2006                                             namestring, valu,
2007                                             (hp_symnum
2008                                          * sizeof (struct dntt_type_block)),
2009                                             objfile->global_psymbols.next,
2010                                             objfile->static_psymbols.next);
2011                 texthigh = valu;
2012                 have_name = 1;
2013                 continue;
2014               }
2015
2016             case DNTT_TYPE_MODULE:
2017               /* A source file.  It's still unclear to me what the
2018                  real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
2019                  is supposed to be.  */
2020
2021               /* First end the previous psymtab */
2022               if (pst)
2023                 {
2024                   hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2025                                       ((hp_symnum - 1)
2026                                        * sizeof (struct dntt_type_block)),
2027                                       texthigh,
2028                                       dependency_list, dependencies_used);
2029                   pst = (struct partial_symtab *) 0;
2030                   includes_used = 0;
2031                   dependencies_used = 0;
2032                   have_name = 0;
2033                 }
2034
2035               /* Now begin a new module and a new psymtab for it */
2036               set_namestring (dn_bufp, &namestring, objfile);
2037               valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
2038               valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2039               if (!pst)
2040                 {
2041                   pst = hpread_start_psymtab (objfile,
2042                                               namestring, valu,
2043                                               (hp_symnum
2044                                          * sizeof (struct dntt_type_block)),
2045                                               objfile->global_psymbols.next,
2046                                               objfile->static_psymbols.next);
2047                   texthigh = valu;
2048                   have_name = 0;
2049                 }
2050               continue;
2051
2052             case DNTT_TYPE_FUNCTION:
2053             case DNTT_TYPE_ENTRY:
2054               /* The beginning of a function.  DNTT_TYPE_ENTRY may also denote
2055                  a secondary entry point.  */
2056               valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2057                                                        SECT_OFF_TEXT (objfile));
2058               if (valu > texthigh)
2059                 texthigh = valu;
2060               valu = dn_bufp->dfunc.lowaddr +
2061                 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2062               set_namestring (dn_bufp, &namestring, objfile);
2063               if (dn_bufp->dfunc.global)
2064                 add_psymbol_to_list (namestring, strlen (namestring),
2065                                      VAR_DOMAIN, LOC_BLOCK,
2066                                      &objfile->global_psymbols, valu,
2067                                      0, language_unknown, objfile);
2068               else
2069                 add_psymbol_to_list (namestring, strlen (namestring),
2070                                      VAR_DOMAIN, LOC_BLOCK,
2071                                      &objfile->static_psymbols, valu,
2072                                      0, language_unknown, objfile);
2073               within_function = 1;
2074               continue;
2075
2076             case DNTT_TYPE_DOC_FUNCTION:
2077               valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2078                                                           SECT_OFF_TEXT (objfile));
2079               if (valu > texthigh)
2080                 texthigh = valu;
2081               valu = dn_bufp->ddocfunc.lowaddr +
2082                 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2083               set_namestring (dn_bufp, &namestring, objfile);
2084               if (dn_bufp->ddocfunc.global)
2085                 add_psymbol_to_list (namestring, strlen (namestring),
2086                                      VAR_DOMAIN, LOC_BLOCK,
2087                                      &objfile->global_psymbols, valu,
2088                                      0, language_unknown, objfile);
2089               else
2090                 add_psymbol_to_list (namestring, strlen (namestring),
2091                                      VAR_DOMAIN, LOC_BLOCK,
2092                                      &objfile->static_psymbols, valu,
2093                                      0, language_unknown, objfile);
2094               within_function = 1;
2095               continue;
2096
2097             case DNTT_TYPE_BEGIN:
2098             case DNTT_TYPE_END:
2099               /* We don't check MODULE end here, because there can be
2100                  symbols beyond the module end which properly belong to the
2101                  current psymtab -- so we wait till the next MODULE start */
2102
2103
2104 #ifdef QUICK_LOOK_UP
2105               if (scan_start == hp_symnum
2106                   && symcount == hp_symnum + 1)
2107                 {
2108                   /* If there are NO globals in an executable,
2109                      PXDB's index to the globals will point to
2110                      the last record in the file, which is
2111                      probably an END MODULE, i.e. this record.
2112                      ignore it and be done! */
2113                   continue;
2114                 }
2115 #endif /* QUICK_LOOK_UP */
2116
2117               /* Scope block begin/end.  We only care about function
2118                  and file blocks right now.  */
2119
2120               if ((dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) ||
2121                   (dn_bufp->dend.endkind == DNTT_TYPE_DOC_FUNCTION))
2122                 within_function = 0;
2123               continue;
2124
2125             case DNTT_TYPE_SVAR:
2126             case DNTT_TYPE_DVAR:
2127             case DNTT_TYPE_TYPEDEF:
2128             case DNTT_TYPE_TAGDEF:
2129               {
2130                 /* Variables, typedefs an the like.  */
2131                 enum address_class storage;
2132                 domain_enum domain;
2133
2134                 /* Don't add locals to the partial symbol table.  */
2135                 if (within_function
2136                     && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR
2137                         || dn_bufp->dblock.kind == DNTT_TYPE_DVAR))
2138                   continue;
2139
2140                 /* TAGDEFs go into the structure domain.  */
2141                 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF)
2142                   domain = STRUCT_DOMAIN;
2143                 else
2144                   domain = VAR_DOMAIN;
2145
2146                 /* What kind of "storage" does this use?  */
2147                 if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR)
2148                   storage = LOC_STATIC;
2149                 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR
2150                          && dn_bufp->ddvar.regvar)
2151                   storage = LOC_REGISTER;
2152                 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR)
2153                   storage = LOC_LOCAL;
2154                 else
2155                   storage = LOC_UNDEF;
2156
2157                 set_namestring (dn_bufp, &namestring, objfile);
2158                 if (!pst)
2159                   {
2160                     pst = hpread_start_psymtab (objfile,
2161                                                 "globals", 0,
2162                                                 (hp_symnum
2163                                          * sizeof (struct dntt_type_block)),
2164                                               objfile->global_psymbols.next,
2165                                              objfile->static_psymbols.next);
2166                   }
2167
2168                 /* Compute address of the data symbol */
2169                 valu = dn_bufp->dsvar.location;
2170                 /* Relocate in case it's in a shared library */
2171                 if (storage == LOC_STATIC)
2172                   valu += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2173
2174                 /* Luckily, dvar, svar, typedef, and tagdef all
2175                    have their "global" bit in the same place, so it works
2176                    (though it's bad programming practice) to reference
2177                    "dsvar.global" even though we may be looking at
2178                    any of the above four types. */
2179                 if (dn_bufp->dsvar.global)
2180                   {
2181                     add_psymbol_to_list (namestring, strlen (namestring),
2182                                          domain, storage,
2183                                          &objfile->global_psymbols,
2184                                          valu,
2185                                          0, language_unknown, objfile);
2186                   }
2187                 else
2188                   {
2189                     add_psymbol_to_list (namestring, strlen (namestring),
2190                                          domain, storage,
2191                                          &objfile->static_psymbols,
2192                                          valu,
2193                                          0, language_unknown, objfile);
2194                   }
2195
2196                 /* For TAGDEF's, the above code added the tagname to the
2197                    struct domain. This will cause tag "t" to be found
2198                    on a reference of the form "(struct t) x". But for
2199                    C++ classes, "t" will also be a typename, which we
2200                    want to find on a reference of the form "ptype t".
2201                    Therefore, we also add "t" to the var domain.
2202                    Do the same for enum's due to the way aCC generates
2203                    debug info for these (see more extended comment
2204                    in hp-symtab-read.c).
2205                    We do the same for templates, so that "ptype t"
2206                    where "t" is a template also works. */
2207                 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF &&
2208                   dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
2209                   {
2210                     int global = dn_bufp->dtag.global;
2211                     /* Look ahead to see if it's a C++ class */
2212                     dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
2213                     if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
2214                         dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
2215                         dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
2216                       {
2217                         if (global)
2218                           {
2219                             add_psymbol_to_list (namestring, strlen (namestring),
2220                                                  VAR_DOMAIN, storage,
2221                                                  &objfile->global_psymbols,
2222                                                  dn_bufp->dsvar.location,
2223                                               0, language_unknown, objfile);
2224                           }
2225                         else
2226                           {
2227                             add_psymbol_to_list (namestring, strlen (namestring),
2228                                                  VAR_DOMAIN, storage,
2229                                                  &objfile->static_psymbols,
2230                                                  dn_bufp->dsvar.location,
2231                                               0, language_unknown, objfile);
2232                           }
2233                       }
2234                   }
2235               }
2236               continue;
2237
2238             case DNTT_TYPE_MEMENUM:
2239             case DNTT_TYPE_CONST:
2240               /* Constants and members of enumerated types.  */
2241               set_namestring (dn_bufp, &namestring, objfile);
2242               if (!pst)
2243                 {
2244                   pst = hpread_start_psymtab (objfile,
2245                                               "globals", 0,
2246                                               (hp_symnum
2247                                          * sizeof (struct dntt_type_block)),
2248                                               objfile->global_psymbols.next,
2249                                               objfile->static_psymbols.next);
2250                 }
2251               if (dn_bufp->dconst.global)
2252                 add_psymbol_to_list (namestring, strlen (namestring),
2253                                      VAR_DOMAIN, LOC_CONST,
2254                                      &objfile->global_psymbols, 0,
2255                                      0, language_unknown, objfile);
2256               else
2257                 add_psymbol_to_list (namestring, strlen (namestring),
2258                                      VAR_DOMAIN, LOC_CONST,
2259                                      &objfile->static_psymbols, 0,
2260                                      0, language_unknown, objfile);
2261               continue;
2262             default:
2263               continue;
2264             }
2265         }
2266     }
2267
2268   /* End any pending partial symbol table. */
2269   if (pst)
2270     {
2271       hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2272                           hp_symnum * sizeof (struct dntt_type_block),
2273                           0, dependency_list, dependencies_used);
2274     }
2275
2276   discard_cleanups (old_chain);
2277 }
2278
2279 /* Perform any local cleanups required when we are done with a particular
2280    objfile.  I.E, we are in the process of discarding all symbol information
2281    for an objfile, freeing up all memory held for it, and unlinking the
2282    objfile struct from the global list of known objfiles. */
2283
2284 void
2285 hpread_symfile_finish (struct objfile *objfile)
2286 {
2287   if (objfile->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   deprecated_hp_som_som_object_present = 1;     /* Indicate we've processed an HP SOM SOM file */
2879
2880   return end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
2881 }
2882 \f
2883
2884
2885
2886 /* Convert basic types from HP debug format into GDB internal format.  */
2887
2888 static int
2889 hpread_type_translate (dnttpointer typep)
2890 {
2891   if (!typep.dntti.immediate)
2892     {
2893       error ("error in hpread_type_translate\n.");
2894       return FT_VOID;
2895     }
2896
2897   switch (typep.dntti.type)
2898     {
2899     case HP_TYPE_BOOLEAN:
2900     case HP_TYPE_BOOLEAN_S300_COMPAT:
2901     case HP_TYPE_BOOLEAN_VAX_COMPAT:
2902       return FT_BOOLEAN;
2903     case HP_TYPE_CHAR:          /* C signed char, C++ plain char */
2904
2905     case HP_TYPE_WIDE_CHAR:
2906       return FT_CHAR;
2907     case HP_TYPE_INT:
2908       if (typep.dntti.bitlength <= 8)
2909         return FT_SIGNED_CHAR;  /* C++ signed char */
2910       if (typep.dntti.bitlength <= 16)
2911         return FT_SHORT;
2912       if (typep.dntti.bitlength <= 32)
2913         return FT_INTEGER;
2914       return FT_LONG_LONG;
2915     case HP_TYPE_LONG:
2916       if (typep.dntti.bitlength <= 8)
2917         return FT_SIGNED_CHAR;  /* C++ signed char. */
2918       return FT_LONG;
2919     case HP_TYPE_UNSIGNED_LONG:
2920       if (typep.dntti.bitlength <= 8)
2921         return FT_UNSIGNED_CHAR;        /* C/C++ unsigned char */
2922       if (typep.dntti.bitlength <= 16)
2923         return FT_UNSIGNED_SHORT;
2924       if (typep.dntti.bitlength <= 32)
2925         return FT_UNSIGNED_LONG;
2926       return FT_UNSIGNED_LONG_LONG;
2927     case HP_TYPE_UNSIGNED_INT:
2928       if (typep.dntti.bitlength <= 8)
2929         return FT_UNSIGNED_CHAR;
2930       if (typep.dntti.bitlength <= 16)
2931         return FT_UNSIGNED_SHORT;
2932       if (typep.dntti.bitlength <= 32)
2933         return FT_UNSIGNED_INTEGER;
2934       return FT_UNSIGNED_LONG_LONG;
2935     case HP_TYPE_REAL:
2936     case HP_TYPE_REAL_3000:
2937     case HP_TYPE_DOUBLE:
2938       if (typep.dntti.bitlength == 64)
2939         return FT_DBL_PREC_FLOAT;
2940       if (typep.dntti.bitlength == 128)
2941         return FT_EXT_PREC_FLOAT;
2942       return FT_FLOAT;
2943     case HP_TYPE_COMPLEX:
2944     case HP_TYPE_COMPLEXS3000:
2945       if (typep.dntti.bitlength == 128)
2946         return FT_DBL_PREC_COMPLEX;
2947       if (typep.dntti.bitlength == 192)
2948         return FT_EXT_PREC_COMPLEX;
2949       return FT_COMPLEX;
2950     case HP_TYPE_VOID:
2951       return FT_VOID;
2952     case HP_TYPE_STRING200:
2953     case HP_TYPE_LONGSTRING200:
2954     case HP_TYPE_FTN_STRING_SPEC:
2955     case HP_TYPE_MOD_STRING_SPEC:
2956     case HP_TYPE_MOD_STRING_3000:
2957     case HP_TYPE_FTN_STRING_S300_COMPAT:
2958     case HP_TYPE_FTN_STRING_VAX_COMPAT:
2959       return FT_STRING;
2960     case HP_TYPE_TEMPLATE_ARG:
2961       return FT_TEMPLATE_ARG;
2962     case HP_TYPE_TEXT:
2963     case HP_TYPE_FLABEL:
2964     case HP_TYPE_PACKED_DECIMAL:
2965     case HP_TYPE_ANYPOINTER:
2966     case HP_TYPE_GLOBAL_ANYPOINTER:
2967     case HP_TYPE_LOCAL_ANYPOINTER:
2968     default:
2969       warning ("hpread_type_translate: unhandled type code.\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->objfile_obstack,
3131                                              sizeof (struct symbol));
3132       memset (sym, 0, sizeof (struct symbol));
3133       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3134                                         &objfile->objfile_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->objfile_obstack,
3239                                              sizeof (struct symbol));
3240       (void) memset (sym, 0, sizeof (struct symbol));
3241       DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3242                                         &objfile->objfile_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           SYMBOL_VALUE (sym)
3256             += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
3257
3258           /* This is likely a pass-by-invisible reference parameter,
3259              Hack on the symbol class to make GDB happy.  */
3260           /* ??rehrauer: This appears to be broken w/r/t to passing
3261              C values of type float and struct.  Perhaps this ought
3262              to be highighted as a special case, but for now, just
3263              allowing these to be LOC_ARGs seems to work fine.
3264            */
3265 #if 0
3266           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3267 #endif
3268         }
3269       else
3270         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3271
3272       /* Get its type.  */
3273       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3274       /* Add it to the symbol list.  */
3275       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3276        * called on FPARAM symbols from the process_one_debug_symbol()
3277        * level... so parameters are getting added twice! (this shows
3278        * up in the symbol dump you get from "maint print symbols ...").
3279        * Note 2 (RT) I took out the processing of FPARAM from the
3280        * process_one_debug_symbol() level, so at the moment parameters are only
3281        * being processed here. This seems to have no ill effect.
3282        */
3283       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3284          each fparam on the local_symbols list from here.  Now we use the
3285          local_list to which fparams are added below, and set the param_symbols
3286          global to point to that at the end of this routine. */
3287       /* elz: I added this new list of symbols which is local to the function.
3288          this list is the one which is actually used to build the type for the
3289          function rather than the gloabal list pointed to by symlist.
3290          Using a global list to keep track of the parameters is wrong, because
3291          this function is called recursively if one parameter happend to be
3292          a function itself with more parameters in it. Adding parameters to the
3293          same global symbol list would not work!
3294          Actually it did work in case of cc compiled programs where you do
3295          not check the parameter lists of the arguments. */
3296       add_symbol_to_list (sym, &local_list);
3297
3298     }
3299
3300   /* If type was read in earlier, don't bother with modifying
3301      the type struct */
3302   if (!record_args)
3303     goto finish;
3304
3305   /* Note how many parameters we found.  */
3306   TYPE_NFIELDS (type) = nsyms;
3307   TYPE_FIELDS (type) = (struct field *)
3308     obstack_alloc (&objfile->objfile_obstack,
3309                    sizeof (struct field) * nsyms);
3310
3311   /* Find the symbols for the parameters and
3312      use them to fill parameter-type information into the function-type.
3313      The parameter symbols can be found in the local_list that we just put them on. */
3314   /* Note that we preserve the order of the parameters, so
3315      that in something like "enum {FOO, LAST_THING=FOO}" we print
3316      FOO, not LAST_THING.  */
3317
3318   /* get the parameters types from the local list not the global list
3319      so that the type can be correctly constructed for functions which
3320      have function as parameters */
3321   for (syms = local_list, n = 0; syms; syms = syms->next)
3322     {
3323       int j = 0;
3324       for (j = 0; j < syms->nsyms; j++, n++)
3325         {
3326           struct symbol *xsym = syms->symbol[j];
3327           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3328           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3329           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3330           TYPE_FIELD_BITSIZE (type, n) = 0;
3331           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3332         }
3333     }
3334   /* Mark it as having been processed */
3335   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3336
3337   /* Check whether we need to fix-up a class type with this function's type */
3338   if (fixup_class && (fixup_method == type))
3339     {
3340       fixup_class_method_type (fixup_class, fixup_method, objfile);
3341       fixup_class = NULL;
3342       fixup_method = NULL;
3343     }
3344
3345   /* Set the param list of this level of the context stack
3346      to our local list.  Do this only if this function was
3347      called for creating a new block, and not if it was called
3348      simply to get the function type. This prevents recursive
3349      invocations from trashing param_symbols. */
3350 finish:
3351   if (newblock)
3352     param_symbols = local_list;
3353
3354   return type;
3355 }
3356
3357
3358 /* Read and internalize a native DOC function debug symbol.  */
3359 /* This is almost identical to hpread_read_function_type(), except
3360  * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3361  * Since debug information for DOC functions is more likely to be
3362  * volatile, please leave it this way.
3363  */
3364 static struct type *
3365 hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3366                                struct objfile *objfile, int newblock)
3367 {
3368   struct pending *syms;
3369   struct pending *local_list = NULL;
3370   int nsyms = 0;
3371   struct type *type;
3372   dnttpointer param;
3373   union dnttentry *paramp;
3374   char *name;
3375   long n;
3376   struct symbol *sym;
3377   int record_args = 1;
3378
3379   /* See if we've already read in this type.  */
3380   type = hpread_alloc_type (hp_type, objfile);
3381   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3382     {
3383       record_args = 0;          /* already read in, don't modify type */
3384     }
3385   else
3386     {
3387       struct type *type1 = NULL;
3388       /* Nope, so read it in and store it away.  */
3389       if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3390           dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3391         type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval,
3392                                                           objfile));
3393       /* NOTE: cagney/2003-03-29: Oh, no not again.  TYPE1 is
3394          potentially left undefined here.  Assert it isn't and hope
3395          the assert never fails ...  */
3396       gdb_assert (type1 != NULL);
3397
3398       replace_type (type, type1);
3399
3400       /* Mark it -- in the middle of processing */
3401       TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3402     }
3403
3404   /* Now examine each parameter noting its type, location, and a
3405      wealth of other information.  */
3406   if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3407       dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3408     param = dn_bufp->ddocfunc.firstparam;
3409   while (param.word && param.word != DNTTNIL)
3410     {
3411       paramp = hpread_get_lntt (param.dnttp.index, objfile);
3412       nsyms++;
3413       param = paramp->dfparam.nextparam;
3414
3415       /* Get the name.  */
3416       name = VT (objfile) + paramp->dfparam.name;
3417       sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
3418                                              sizeof (struct symbol));
3419       (void) memset (sym, 0, sizeof (struct symbol));
3420       DEPRECATED_SYMBOL_NAME (sym) = name;
3421
3422       /* Figure out where it lives.  */
3423       if (paramp->dfparam.regparam)
3424         SYMBOL_CLASS (sym) = LOC_REGPARM;
3425       else if (paramp->dfparam.indirect)
3426         SYMBOL_CLASS (sym) = LOC_REF_ARG;
3427       else
3428         SYMBOL_CLASS (sym) = LOC_ARG;
3429       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
3430       if (paramp->dfparam.copyparam)
3431         {
3432           SYMBOL_VALUE (sym) = paramp->dfparam.location;
3433           SYMBOL_VALUE (sym)
3434             += hpread_adjust_stack_address(CURRENT_FUNCTION_VALUE (objfile));
3435
3436           /* This is likely a pass-by-invisible reference parameter,
3437              Hack on the symbol class to make GDB happy.  */
3438           /* ??rehrauer: This appears to be broken w/r/t to passing
3439              C values of type float and struct.  Perhaps this ought
3440              to be highighted as a special case, but for now, just
3441              allowing these to be LOC_ARGs seems to work fine.
3442            */
3443 #if 0
3444           SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3445 #endif
3446         }
3447       else
3448         SYMBOL_VALUE (sym) = paramp->dfparam.location;
3449
3450       /* Get its type.  */
3451       SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3452       /* Add it to the symbol list.  */
3453       /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3454        * called on FPARAM symbols from the process_one_debug_symbol()
3455        * level... so parameters are getting added twice! (this shows
3456        * up in the symbol dump you get from "maint print symbols ...").
3457        * Note 2 (RT) I took out the processing of FPARAM from the
3458        * process_one_debug_symbol() level, so at the moment parameters are only
3459        * being processed here. This seems to have no ill effect.
3460        */
3461       /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3462          each fparam on the local_symbols list from here.  Now we use the
3463          local_list to which fparams are added below, and set the param_symbols
3464          global to point to that at the end of this routine. */
3465
3466       /* elz: I added this new list of symbols which is local to the function.
3467          this list is the one which is actually used to build the type for the
3468          function rather than the gloabal list pointed to by symlist.
3469          Using a global list to keep track of the parameters is wrong, because
3470          this function is called recursively if one parameter happend to be
3471          a function itself with more parameters in it. Adding parameters to the
3472          same global symbol list would not work!
3473          Actually it did work in case of cc compiled programs where you do not check the
3474          parameter lists of the arguments.  */
3475       add_symbol_to_list (sym, &local_list);
3476     }
3477
3478   /* If type was read in earlier, don't bother with modifying
3479      the type struct */
3480   if (!record_args)
3481     goto finish;
3482
3483   /* Note how many parameters we found.  */
3484   TYPE_NFIELDS (type) = nsyms;
3485   TYPE_FIELDS (type) = (struct field *)
3486     obstack_alloc (&objfile->objfile_obstack,
3487                    sizeof (struct field) * nsyms);
3488
3489   /* Find the symbols for the parameters and
3490      use them to fill parameter-type information into the function-type.
3491      The parameter symbols can be found in the local_list that we just put them on. */
3492   /* Note that we preserve the order of the parameters, so
3493      that in something like "enum {FOO, LAST_THING=FOO}" we print
3494      FOO, not LAST_THING.  */
3495
3496   /* get the parameters types from the local list not the global list
3497      so that the type can be correctly constructed for functions which
3498      have function as parameters
3499    */
3500   for (syms = local_list, n = 0; syms; syms = syms->next)
3501     {
3502       int j = 0;
3503       for (j = 0; j < syms->nsyms; j++, n++)
3504         {
3505           struct symbol *xsym = syms->symbol[j];
3506           TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3507           TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3508           TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3509           TYPE_FIELD_BITSIZE (type, n) = 0;
3510           TYPE_FIELD_STATIC_KIND (type, n) = 0;
3511         }
3512     }
3513
3514   /* Mark it as having been processed */
3515   TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3516
3517   /* Check whether we need to fix-up a class type with this function's type */
3518   if (fixup_class && (fixup_method == type))
3519     {
3520       fixup_class_method_type (fixup_class, fixup_method, objfile);
3521       fixup_class = NULL;
3522       fixup_method = NULL;
3523     }
3524
3525   /* Set the param list of this level of the context stack
3526      to our local list.  Do this only if this function was
3527      called for creating a new block, and not if it was called
3528      simply to get the function type. This prevents recursive
3529      invocations from trashing param_symbols. */
3530 finish:
3531   if (newblock)
3532     param_symbols = local_list;
3533
3534   return type;
3535 }
3536
3537
3538
3539 /* A file-level variable which keeps track of the current-template
3540  * being processed. Set in hpread_read_struct_type() while processing
3541  * a template type. Referred to in hpread_get_nth_templ_arg().
3542  * Yes, this is a kludge, but it arises from the kludge that already
3543  * exists in symtab.h, namely the fact that they encode
3544  * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3545  * bitlength n. This means that deep in processing fundamental types
3546  * I need to ask the question "what template am I in the middle of?".
3547  * The alternative to stuffing a global would be to pass an argument
3548  * down the chain of calls just for this purpose.
3549  *
3550  * There may be problems handling nested templates... tough.
3551  */
3552 static struct type *current_template = NULL;
3553
3554 /* Read in and internalize a structure definition.
3555  * This same routine is called for struct, union, and class types.
3556  * Also called for templates, since they build a very similar
3557  * type entry as for class types.
3558  */
3559
3560 static struct type *
3561 hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3562                          struct objfile *objfile)
3563 {
3564   /* The data members get linked together into a list of struct nextfield's */
3565   struct nextfield
3566     {
3567       struct nextfield *next;
3568       struct field field;
3569       unsigned char attributes; /* store visibility and virtuality info */
3570 #define ATTR_VIRTUAL 1
3571 #define ATTR_PRIVATE 2
3572 #define ATTR_PROTECT 3
3573     };
3574
3575
3576   /* The methods get linked together into a list of struct next_fn_field's */
3577   struct next_fn_field
3578     {
3579       struct next_fn_field *next;
3580       struct fn_fieldlist field;
3581       struct fn_field fn_field;
3582       int num_fn_fields;
3583     };
3584
3585   /* The template args get linked together into a list of struct next_template's */
3586   struct next_template
3587     {
3588       struct next_template *next;
3589       struct template_arg arg;
3590     };
3591
3592   /* The template instantiations get linked together into a list of these... */
3593   struct next_instantiation
3594     {
3595       struct next_instantiation *next;
3596       struct type *t;
3597     };
3598
3599   struct type *type;
3600   struct type *baseclass;
3601   struct type *memtype;
3602   struct nextfield *list = 0, *tmp_list = 0;
3603   struct next_fn_field *fn_list = 0;
3604   struct next_fn_field *fn_p;
3605   struct next_template *t_new, *t_list = 0;
3606   struct nextfield *new;
3607   struct next_fn_field *fn_new;
3608   struct next_instantiation *i_new, *i_list = 0;
3609   int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0;
3610   int n_base_classes = 0, n_templ_args = 0;
3611   int ninstantiations = 0;
3612   dnttpointer field, fn_field, parent;
3613   union dnttentry *fieldp, *fn_fieldp, *parentp;
3614   int i;
3615   int static_member = 0;
3616   int const_member = 0;
3617   int volatile_member = 0;
3618   unsigned long vtbl_offset;
3619   int need_bitvectors = 0;
3620   char *method_name = NULL;
3621   char *method_alias = NULL;
3622
3623
3624   /* Is it something we've already dealt with?  */
3625   type = hpread_alloc_type (hp_type, objfile);
3626   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
3627       (TYPE_CODE (type) == TYPE_CODE_UNION) ||
3628       (TYPE_CODE (type) == TYPE_CODE_CLASS) ||
3629       (TYPE_CODE (type) == TYPE_CODE_TEMPLATE))
3630     return type;
3631
3632   /* Get the basic type correct.  */
3633   if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3634     {
3635       TYPE_CODE (type) = TYPE_CODE_STRUCT;
3636       TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
3637     }
3638   else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3639     {
3640       TYPE_CODE (type) = TYPE_CODE_UNION;
3641       TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
3642     }
3643   else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3644     {
3645       TYPE_CODE (type) = TYPE_CODE_CLASS;
3646       TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8;
3647
3648       /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3649        * rather than &cplus_struct_default.
3650        */
3651       allocate_cplus_struct_type (type);
3652
3653       /* Fill in declared-type.
3654        * (The C++ compiler will emit TYPE_CODE_CLASS
3655        * for all 3 of "class", "struct"
3656        * "union", and we have to look at the "class_decl" field if we
3657        * want to know how it was really declared)
3658        */
3659       /* (0==class, 1==union, 2==struct) */
3660       TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl;
3661     }
3662   else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3663     {
3664       /* Get the basic type correct.  */
3665       TYPE_CODE (type) = TYPE_CODE_TEMPLATE;
3666       allocate_cplus_struct_type (type);
3667       TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE;
3668     }
3669   else
3670     return type;
3671
3672
3673   TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3674
3675   /* For classes, read the parent list.
3676    * Question (RT): Do we need to do this for templates also?
3677    */
3678   if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3679     {
3680
3681       /* First read the parent-list (classes from which we derive fields) */
3682       parent = dn_bufp->dclass.parentlist;
3683       while (parent.word && parent.word != DNTTNIL)
3684         {
3685           parentp = hpread_get_lntt (parent.dnttp.index, objfile);
3686
3687           /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3688
3689           /* Get space to record the next field/data-member. */
3690           new = (struct nextfield *) alloca (sizeof (struct nextfield));
3691           memset (new, 0, sizeof (struct nextfield));
3692           new->next = list;
3693           list = new;
3694
3695           FIELD_BITSIZE (list->field) = 0;
3696           FIELD_STATIC_KIND (list->field) = 0;
3697
3698           /* The "classname" field is actually a DNTT pointer to the base class */
3699           baseclass = hpread_type_lookup (parentp->dinheritance.classname,
3700                                           objfile);
3701           FIELD_TYPE (list->field) = baseclass;
3702
3703           list->field.name = type_name_no_tag (FIELD_TYPE (list->field));
3704
3705           list->attributes = 0;
3706
3707           /* Check for virtuality of base, and set the
3708            * offset of the base subobject within the object.
3709            * (Offset set to -1 for virtual bases (for now).)
3710            */
3711           if (parentp->dinheritance.Virtual)
3712             {
3713               B_SET (&(list->attributes), ATTR_VIRTUAL);
3714               parentp->dinheritance.offset = -1;
3715             }
3716           else
3717             FIELD_BITPOS (list->field) = parentp->dinheritance.offset;
3718
3719           /* Check visibility */
3720           switch (parentp->dinheritance.visibility)
3721             {
3722             case 1:
3723               B_SET (&(list->attributes), ATTR_PROTECT);
3724               break;
3725             case 2:
3726               B_SET (&(list->attributes), ATTR_PRIVATE);
3727               break;
3728             }
3729
3730           n_base_classes++;
3731           nfields++;
3732
3733           parent = parentp->dinheritance.next;
3734         }
3735     }
3736
3737   /* For templates, read the template argument list.
3738    * This must be done before processing the member list, because
3739    * the member list may refer back to this. E.g.:
3740    *   template <class T1, class T2> class q2 {
3741    *     public:
3742    *     T1 a;
3743    *     T2 b;
3744    *   };
3745    * We need to read the argument list "T1", "T2" first.
3746    */
3747   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3748     {
3749       /* Kludge alert: This stuffs a global "current_template" which
3750        * is referred to by hpread_get_nth_templ_arg(). The global
3751        * is cleared at the end of this routine.
3752        */
3753       current_template = type;
3754
3755       /* Read in the argument list */
3756       field = dn_bufp->dtemplate.arglist;
3757       while (field.word && field.word != DNTTNIL)
3758         {
3759           /* Get this template argument */
3760           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3761           if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG)
3762             {
3763               warning ("Invalid debug info: Template argument entry is of wrong kind");
3764               break;
3765             }
3766           /* Bump the count */
3767           n_templ_args++;
3768           /* Allocate and fill in a struct next_template */
3769           t_new = (struct next_template *) alloca (sizeof (struct next_template));
3770           memset (t_new, 0, 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                   memset (fn_new, 0, sizeof (struct next_fn_field));
3912                   fn_new->next = fn_list;
3913                   fn_list = fn_new;
3914
3915                   /* Fill in the fields of the struct nextfield */
3916
3917                   /* Record the (unmangled) method name */
3918                   fn_list->field.name = method_name;
3919                   /* Initial space for overloaded methods */
3920                   /* Note: xmalloc is used; this will persist after this routine exits */
3921                   fn_list->field.fn_fields = (struct fn_field *) xmalloc (5 * (sizeof (struct fn_field)));
3922                   fn_list->field.length = 1;    /* Init # of overloaded instances */
3923                   fn_list->num_fn_fields = 5;   /* # of entries for which space allocated */
3924                   fn_p = fn_list;
3925                   ix = 0;       /* array index for fn_field */
3926                   /* Bump the total count of the distinctly named methods */
3927                   n_fn_fields++;
3928                 }
3929               else
3930                 /* Another overloaded instance of an already seen method name */
3931                 {
3932                   if (++(fn_p->field.length) > fn_p->num_fn_fields)
3933                     {
3934                       /* Increase space allocated for overloaded instances */
3935                       fn_p->field.fn_fields
3936                         = (struct fn_field *) xrealloc (fn_p->field.fn_fields,
3937                       (fn_p->num_fn_fields + 5) * sizeof (struct fn_field));
3938                       fn_p->num_fn_fields += 5;
3939                     }
3940                   ix = fn_p->field.length - 1;  /* array index for fn_field */
3941                 }
3942
3943               /* "physname" is intended to be the name of this overloaded instance. */
3944               if ((fn_fieldp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
3945                   method_alias &&
3946                   *method_alias)        /* not a null string */
3947                 fn_p->field.fn_fields[ix].physname = method_alias;
3948               else
3949                 fn_p->field.fn_fields[ix].physname = method_name;
3950               /* What's expected here is the function type */
3951               /* But mark it as NULL if the method was incompletely processed
3952                  We'll fix this up later when the method is fully processed */
3953               if (TYPE_INCOMPLETE (memtype))
3954                 fn_p->field.fn_fields[ix].type = NULL;
3955               else
3956                 fn_p->field.fn_fields[ix].type = memtype;
3957
3958               /* For virtual functions, fill in the voffset field with the
3959                * virtual table offset. (This is just copied over from the
3960                * SOM record; not sure if it is what GDB expects here...).
3961                * But if the function is a static method, set it to 1.
3962                *
3963                * Note that we have to add 1 because 1 indicates a static
3964                * method, and 0 indicates a non-static, non-virtual method */
3965
3966               if (static_member)
3967                 fn_p->field.fn_fields[ix].voffset = VOFFSET_STATIC;
3968               else
3969                 fn_p->field.fn_fields[ix].voffset = vtbl_offset ? vtbl_offset + 1 : 0;
3970
3971               /* Also fill in the fcontext field with the current
3972                * class. (The latter isn't quite right: should be the baseclass
3973                * that defines the virtual function... Note we do have
3974                * a variable "baseclass" that we could stuff into the fcontext
3975                * field, but "baseclass" isn't necessarily right either,
3976                * since the virtual function could have been defined more
3977                * than one level up).
3978                */
3979
3980               if (vtbl_offset != 0)
3981                 fn_p->field.fn_fields[ix].fcontext = type;
3982               else
3983                 fn_p->field.fn_fields[ix].fcontext = NULL;
3984
3985               /* Other random fields pertaining to this method */
3986               fn_p->field.fn_fields[ix].is_const = const_member;
3987               fn_p->field.fn_fields[ix].is_volatile = volatile_member;  /* ?? */
3988               switch (fieldp->dgenfield.visibility)
3989                 {
3990                 case 1:
3991                   fn_p->field.fn_fields[ix].is_protected = 1;
3992                   fn_p->field.fn_fields[ix].is_private = 0;
3993                   break;
3994                 case 2:
3995                   fn_p->field.fn_fields[ix].is_protected = 0;
3996                   fn_p->field.fn_fields[ix].is_private = 1;
3997                   break;
3998                 default:        /* public */
3999                   fn_p->field.fn_fields[ix].is_protected = 0;
4000                   fn_p->field.fn_fields[ix].is_private = 0;
4001                 }
4002               fn_p->field.fn_fields[ix].is_stub = 0;
4003
4004               /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
4005                  if the class points to the FUNCTION, there is usually separate
4006                  code for the method; but if we have a MEMFUNC, the method has
4007                  been inlined (and there is usually no FUNCTION entry)
4008                  FIXME Not sure if this test is accurate. pai/1997-08-22 */
4009               if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
4010                   (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC))
4011                 fn_p->field.fn_fields[ix].is_inlined = 1;
4012               else
4013                 fn_p->field.fn_fields[ix].is_inlined = 0;
4014
4015               fn_p->field.fn_fields[ix].dummy = 0;
4016
4017               /* Bump the total count of the member functions */
4018               n_fn_fields_total++;
4019
4020             }
4021           else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4022             {
4023               /* This case is for static data members of classes */
4024
4025               /* pai:: FIXME -- check that "staticmem" bit is set */
4026
4027               /* Get space to record this static member */
4028               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4029               memset (new, 0, sizeof (struct nextfield));
4030               new->next = list;
4031               list = new;
4032
4033               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4034               SET_FIELD_PHYSNAME (list->field, 0);      /* initialize to empty */
4035               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4036
4037               FIELD_TYPE (list->field) = memtype;
4038               list->attributes = 0;
4039               switch (fieldp->dgenfield.visibility)
4040                 {
4041                 case 1:
4042                   B_SET (&(list->attributes), ATTR_PROTECT);
4043                   break;
4044                 case 2:
4045                   B_SET (&(list->attributes), ATTR_PRIVATE);
4046                   break;
4047                 }
4048               nfields++;
4049             }
4050
4051           else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD)
4052             {
4053               /* FIELDs follow GENFIELDs for fields of anonymous unions.
4054                  Code below is replicated from the case for FIELDs further
4055                  below, except that fieldp is replaced by fn_fieldp */
4056               if (!fn_fieldp->dfield.a_union)
4057                 warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
4058               /* Get space to record the next field/data-member. */
4059               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4060               memset (new, 0, sizeof (struct nextfield));
4061               new->next = list;
4062               list = new;
4063
4064               list->field.name = VT (objfile) + fn_fieldp->dfield.name;
4065               FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset;
4066               if (fn_fieldp->dfield.bitlength % 8)
4067                 list->field.bitsize = fn_fieldp->dfield.bitlength;
4068               else
4069                 list->field.bitsize = 0;
4070
4071               memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile);
4072               list->field.type = memtype;
4073               list->attributes = 0;
4074               switch (fn_fieldp->dfield.visibility)
4075                 {
4076                 case 1:
4077                   B_SET (&(list->attributes), ATTR_PROTECT);
4078                   break;
4079                 case 2:
4080                   B_SET (&(list->attributes), ATTR_PRIVATE);
4081                   break;
4082                 }
4083               nfields++;
4084             }
4085           else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4086             {
4087               /* Field of anonymous union; union is not inside a class */
4088               if (!fn_fieldp->dsvar.a_union)
4089                 warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
4090               /* Get space to record the next field/data-member. */
4091               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4092               memset (new, 0, sizeof (struct nextfield));
4093               new->next = list;
4094               list = new;
4095
4096               list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4097               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4098               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4099               FIELD_STATIC_KIND (list->field) = 0;
4100               memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4101               list->field.type = memtype;
4102               list->attributes = 0;
4103               /* No info to set visibility -- always public */
4104               nfields++;
4105             }
4106           else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR)
4107             {
4108               /* Field of anonymous union; union is not inside a class */
4109               if (!fn_fieldp->ddvar.a_union)
4110                 warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
4111               /* Get space to record the next field/data-member. */
4112               new = (struct nextfield *) alloca (sizeof (struct nextfield));
4113               memset (new, 0, sizeof (struct nextfield));
4114               new->next = list;
4115               list = new;
4116
4117               list->field.name = VT (objfile) + fn_fieldp->ddvar.name;
4118               FIELD_BITPOS (list->field) = 0;   /* FIXME is this always true? */
4119               FIELD_BITSIZE (list->field) = 0;  /* use length from type */
4120               FIELD_STATIC_KIND (list->field) = 0;
4121               memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile);
4122               list->field.type = memtype;
4123               list->attributes = 0;
4124               /* No info to set visibility -- always public */
4125               nfields++;
4126             }
4127           else
4128             {                   /* Not a method, nor a static data member, nor an anon union field */
4129
4130               /* This case is for miscellaneous type entries (local enums,
4131                  local function templates, etc.) that can be present
4132                  inside a class. */
4133
4134               /* Enums -- will be handled by other code that takes care
4135                  of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4136                  it's not clear we could have handled them here at all. */
4137               /* FUNC_TEMPLATE: is handled by other code (?). */
4138               /* MEMACCESS: modified access for inherited member. Not
4139                  sure what to do with this, ignoriing it at present. */
4140
4141               /* What other entries can appear following a GENFIELD which
4142                  we do not handle above?  (MODIFIER, VFUNC handled above.) */
4143
4144               if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) &&
4145                   (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) &&
4146                   (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE))
4147                 warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
4148                          fn_fieldp->dblock.kind);
4149             }
4150           /* walk to the next FIELD or GENFIELD */
4151           field = fieldp->dgenfield.nextfield;
4152
4153         }
4154       else if (fieldp->dblock.kind == DNTT_TYPE_FIELD)
4155         {
4156
4157           /* Ordinary structure/union/class field */
4158           struct type *anon_union_type;
4159
4160           /* Get space to record the next field/data-member. */
4161           new = (struct nextfield *) alloca (sizeof (struct nextfield));
4162           memset (new, 0, sizeof (struct nextfield));
4163           new->next = list;
4164           list = new;
4165
4166           list->field.name = VT (objfile) + fieldp->dfield.name;
4167
4168
4169           /* A FIELD by itself (without a GENFIELD) can also be a static
4170              member.  Mark it as static with a physname of NULL.
4171              fix_static_member_physnames will assign the physname later. */
4172           if (fieldp->dfield.staticmem)
4173             {
4174               SET_FIELD_PHYSNAME (list->field, NULL);
4175               FIELD_BITPOS (list->field) = 0;
4176               FIELD_BITSIZE (list->field) = 0;
4177             }
4178           else
4179             /* Non-static data member */
4180             {
4181               FIELD_STATIC_KIND (list->field) = 0;
4182               FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
4183               if (fieldp->dfield.bitlength % 8)
4184                 FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
4185               else
4186                 FIELD_BITSIZE (list->field) = 0;
4187             }
4188
4189           memtype = hpread_type_lookup (fieldp->dfield.type, objfile);
4190           FIELD_TYPE (list->field) = memtype;
4191           list->attributes = 0;
4192           switch (fieldp->dfield.visibility)
4193             {
4194             case 1:
4195               B_SET (&(list->attributes), ATTR_PROTECT);
4196               break;
4197             case 2:
4198               B_SET (&(list->attributes), ATTR_PRIVATE);
4199               break;
4200             }
4201           nfields++;
4202
4203
4204           /* Note 1: First, we have to check if the current field is an anonymous
4205              union. If it is, then *its* fields are threaded along in the
4206              nextfield chain. :-( This was supposed to help debuggers, but is
4207              really just a nuisance since we deal with anonymous unions anyway by
4208              checking that the name is null.  So anyway, we skip over the fields
4209              of the anonymous union. pai/1997-08-22 */
4210           /* Note 2: In addition, the bitoffsets for the fields of the anon union
4211              are relative to the enclosing struct, *NOT* relative to the anon
4212              union!  This is an even bigger nuisance -- we have to go in and munge
4213              the anon union's type information appropriately. pai/1997-08-22 */
4214
4215           /* Both tasks noted above are done by a separate function.  This takes us
4216              to the next FIELD or GENFIELD, skipping anon unions, and recursively
4217              processing intermediate types. */
4218           field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile);
4219
4220         }
4221       else
4222         {
4223           /* neither field nor genfield ?? is this possible?? */
4224           /* pai:: FIXME walk to the next -- how? */
4225           warning ("Internal error: unexpected DNTT kind %d encountered as field of struct",
4226                    fieldp->dblock.kind);
4227           warning ("Skipping remaining fields of struct");
4228           break;                /* get out of loop of fields */
4229         }
4230     }
4231
4232   /* If it's a template, read in the instantiation list */
4233   if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4234     {
4235       ninstantiations = 0;
4236       field = dn_bufp->dtemplate.expansions;
4237       while (field.word && field.word != DNTTNIL)
4238         {
4239           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4240
4241           /* The expansions or nextexp should point to a tagdef */
4242           if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF)
4243             break;
4244
4245           i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation));
4246           memset (i_new, 0, sizeof (struct next_instantiation));
4247           i_new->next = i_list;
4248           i_list = i_new;
4249           i_list->t = hpread_type_lookup (field, objfile);
4250           ninstantiations++;
4251
4252           /* And the "type" field of that should point to a class */
4253           field = fieldp->dtag.type;
4254           fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4255           if (fieldp->dblock.kind != DNTT_TYPE_CLASS)
4256             break;
4257
4258           /* Get the next expansion */
4259           field = fieldp->dclass.nextexp;
4260         }
4261     }
4262   TYPE_NINSTANTIATIONS (type) = ninstantiations;
4263   if (ninstantiations > 0)
4264     TYPE_INSTANTIATIONS (type) = (struct type **)
4265       obstack_alloc (&objfile->objfile_obstack, sizeof (struct type *) * ninstantiations);
4266   for (n = ninstantiations; i_list; i_list = i_list->next)
4267     {
4268       n -= 1;
4269       TYPE_INSTANTIATION (type, n) = i_list->t;
4270     }
4271
4272
4273   /* Copy the field-list to GDB's symbol table */
4274   TYPE_NFIELDS (type) = nfields;
4275   TYPE_N_BASECLASSES (type) = n_base_classes;
4276   TYPE_FIELDS (type) = (struct field *)
4277     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nfields);
4278   /* Copy the saved-up fields into the field vector.  */
4279   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4280     {
4281       n -= 1;
4282       TYPE_FIELD (type, n) = tmp_list->field;
4283     }
4284
4285   /* Copy the "function-field-list" (i.e., the list of member
4286    * functions in the class) to GDB's symbol table
4287    */
4288   TYPE_NFN_FIELDS (type) = n_fn_fields;
4289   TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total;
4290   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
4291     obstack_alloc (&objfile->objfile_obstack, sizeof (struct fn_fieldlist) * n_fn_fields);
4292   for (n = n_fn_fields; fn_list; fn_list = fn_list->next)
4293     {
4294       n -= 1;
4295       TYPE_FN_FIELDLIST (type, n) = fn_list->field;
4296     }
4297
4298   /* pai:: FIXME -- perhaps each bitvector should be created individually */
4299   for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4300     {
4301       n -= 1;
4302       if (tmp_list->attributes)
4303         {
4304           need_bitvectors = 1;
4305           break;
4306         }
4307     }
4308
4309   if (need_bitvectors)
4310     {
4311       /* pai:: this step probably redundant */
4312       ALLOCATE_CPLUS_STRUCT_TYPE (type);
4313
4314       TYPE_FIELD_VIRTUAL_BITS (type) =
4315         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4316       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields);
4317
4318       TYPE_FIELD_PRIVATE_BITS (type) =
4319         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4320       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
4321
4322       TYPE_FIELD_PROTECTED_BITS (type) =
4323         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4324       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
4325
4326       /* this field vector isn't actually used with HP aCC */
4327       TYPE_FIELD_IGNORE_BITS (type) =
4328         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4329       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
4330
4331       while (nfields-- > 0)
4332         {
4333           if (B_TST (&(list->attributes), ATTR_VIRTUAL))
4334             SET_TYPE_FIELD_VIRTUAL (type, nfields);
4335           if (B_TST (&(list->attributes), ATTR_PRIVATE))
4336             SET_TYPE_FIELD_PRIVATE (type, nfields);
4337           if (B_TST (&(list->attributes), ATTR_PROTECT))
4338             SET_TYPE_FIELD_PROTECTED (type, nfields);
4339
4340           list = list->next;
4341         }
4342     }
4343   else
4344     {
4345       TYPE_FIELD_VIRTUAL_BITS (type) = NULL;
4346       TYPE_FIELD_PROTECTED_BITS (type) = NULL;
4347       TYPE_FIELD_PRIVATE_BITS (type) = NULL;
4348     }
4349
4350   if (has_vtable (type))
4351     {
4352       /* Allocate space for class runtime information */
4353       TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info));
4354       /* Set flag for vtable */
4355       TYPE_VTABLE (type) = 1;
4356       /* The first non-virtual base class with a vtable. */
4357       TYPE_PRIMARY_BASE (type) = primary_base_class (type);
4358       /* The virtual base list. */
4359       TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type);
4360     }
4361   else
4362     TYPE_RUNTIME_PTR (type) = NULL;
4363
4364   /* If this is a local type (C++ - declared inside a function), record file name & line # */
4365   if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ ))
4366     {
4367       TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info));
4368       TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1);
4369       strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name);
4370       if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0))
4371         TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line;
4372       else
4373         TYPE_LOCALTYPE_LINE (type) = 0;
4374     }
4375   else
4376     TYPE_LOCALTYPE_PTR (type) = NULL;
4377
4378   /* Clear the global saying what template we are in the middle of processing */
4379   current_template = NULL;
4380
4381   return type;
4382 }
4383
4384 /* Adjust the physnames for each static member of a struct
4385    or class type to be something like "A::x"; then various
4386    other pieces of code that do a lookup_symbol on the phyname
4387    work correctly.
4388    TYPE is a pointer to the struct/class type
4389    NAME is a char * (string) which is the class/struct name
4390    Void return */
4391
4392 static void
4393 fix_static_member_physnames (struct type *type, char *class_name,
4394                              struct objfile *objfile)
4395 {
4396   int i;
4397
4398   /* We fix the member names only for classes or structs */
4399   if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
4400     return;
4401
4402   for (i = 0; i < TYPE_NFIELDS (type); i++)
4403     if (TYPE_FIELD_STATIC (type, i))
4404       {
4405         if (TYPE_FIELD_STATIC_PHYSNAME (type, i))
4406           return;               /* physnames are already set */
4407
4408         SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i],
4409                             obstack_alloc (&objfile->objfile_obstack,
4410              strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3));
4411         strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name);
4412         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::");
4413         strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i));
4414       }
4415 }
4416
4417 /* Fix-up the type structure for a CLASS so that the type entry
4418  * for a method (previously marked with a null type in hpread_read_struct_type()
4419  * is set correctly to METHOD.
4420  * OBJFILE is as for other such functions.
4421  * Void return. */
4422
4423 static void
4424 fixup_class_method_type (struct type *class, struct type *method,
4425                          struct objfile *objfile)
4426 {
4427   int i, j, k;
4428
4429   if (!class || !method || !objfile)
4430     return;
4431
4432   /* Only for types that have methods */
4433   if ((TYPE_CODE (class) != TYPE_CODE_CLASS) &&
4434       (TYPE_CODE (class) != TYPE_CODE_UNION))
4435     return;
4436
4437   /* Loop over all methods and find the one marked with a NULL type */
4438   for (i = 0; i < TYPE_NFN_FIELDS (class); i++)
4439     for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++)
4440       if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL)
4441         {
4442           /* Set the method type */
4443           TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method;
4444
4445           /* Break out of both loops -- only one method to fix up in a class */
4446           goto finish;
4447         }
4448
4449 finish:
4450   TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE;
4451 }
4452
4453
4454 /* If we're in the middle of processing a template, get a pointer
4455  * to the Nth template argument.
4456  * An example may make this clearer:
4457  *   template <class T1, class T2> class q2 {
4458  *     public:
4459  *     T1 a;
4460  *     T2 b;
4461  *   };
4462  * The type for "a" will be "first template arg" and
4463  * the type for "b" will be "second template arg".
4464  * We need to look these up in order to fill in "a" and "b"'s type.
4465  * This is called from hpread_type_lookup().
4466  */
4467 static struct type *
4468 hpread_get_nth_template_arg (struct objfile *objfile, int n)
4469 {
4470   if (current_template != NULL)
4471     return TYPE_TEMPLATE_ARG (current_template, n).type;
4472   else
4473     return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG);
4474 }
4475
4476 /* Read in and internalize a TEMPL_ARG (template arg) symbol.  */
4477
4478 static struct type *
4479 hpread_read_templ_arg_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4480                             struct objfile *objfile, char *name)
4481 {
4482   struct type *type;
4483
4484   /* See if it's something we've already deal with.  */
4485   type = hpread_alloc_type (hp_type, objfile);
4486   if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG)
4487     return type;
4488
4489   /* Nope.  Fill in the appropriate fields.  */
4490   TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG;
4491   TYPE_LENGTH (type) = 0;
4492   TYPE_NFIELDS (type) = 0;
4493   TYPE_NAME (type) = name;
4494   return type;
4495 }
4496
4497 /* Read in and internalize a set debug symbol.  */
4498
4499 static struct type *
4500 hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4501                       struct objfile *objfile)
4502 {
4503   struct type *type;
4504
4505   /* See if it's something we've already deal with.  */
4506   type = hpread_alloc_type (hp_type, objfile);
4507   if (TYPE_CODE (type) == TYPE_CODE_SET)
4508     return type;
4509
4510   /* Nope.  Fill in the appropriate fields.  */
4511   TYPE_CODE (type) = TYPE_CODE_SET;
4512   TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8;
4513   TYPE_NFIELDS (type) = 0;
4514   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype,
4515                                                 objfile);
4516   return type;
4517 }
4518
4519 /* Read in and internalize an array debug symbol.  */
4520
4521 static struct type *
4522 hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4523                         struct objfile *objfile)
4524 {
4525   struct type *type;
4526
4527   /* Allocate an array type symbol.
4528    * Why no check for already-read here, like in the other
4529    * hpread_read_xxx_type routines?  Because it kept us
4530    * from properly determining the size of the array!
4531    */
4532   type = hpread_alloc_type (hp_type, objfile);
4533
4534   TYPE_CODE (type) = TYPE_CODE_ARRAY;
4535
4536   /* Although the hp-symtab.h does not *require* this to be the case,
4537    * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4538    * I.e., express both array-length and element-length in bits,
4539    * or express both array-length and element-length in bytes.
4540    */
4541   if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) ||
4542         (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes)))
4543     {
4544       warning ("error in hpread_array_type.\n");
4545       return NULL;
4546     }
4547   else if (dn_bufp->darray.arraylength == 0x7fffffff)
4548     {
4549       /* The HP debug format represents char foo[]; as an array with
4550        * length 0x7fffffff.  Internally GDB wants to represent this
4551        *  as an array of length zero.
4552        */
4553       TYPE_LENGTH (type) = 0;
4554     }
4555   else if (dn_bufp->darray.arrayisbytes)
4556     TYPE_LENGTH (type) = dn_bufp->darray.arraylength;
4557   else                          /* arraylength is in bits */
4558     TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
4559
4560   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype,
4561                                                 objfile);
4562
4563   /* The one "field" is used to store the subscript type */
4564   /* Since C and C++ multi-dimensional arrays are simply represented
4565    * as: array of array of ..., we only need one subscript-type
4566    * per array. This subscript type is typically a subrange of integer.
4567    * If this gets extended to support languages like Pascal, then
4568    * we need to fix this to represent multi-dimensional arrays properly.
4569    */
4570   TYPE_NFIELDS (type) = 1;
4571   TYPE_FIELDS (type) = (struct field *)
4572     obstack_alloc (&objfile->objfile_obstack, sizeof (struct field));
4573   TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype,
4574                                                   objfile);
4575   return type;
4576 }
4577
4578 /* Read in and internalize a subrange debug symbol.  */
4579 static struct type *
4580 hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4581                            struct objfile *objfile)
4582 {
4583   struct type *type;
4584
4585   /* Is it something we've already dealt with.  */
4586   type = hpread_alloc_type (hp_type, objfile);
4587   if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4588     return type;
4589
4590   /* Nope, internalize it.  */
4591   TYPE_CODE (type) = TYPE_CODE_RANGE;
4592   TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
4593   TYPE_NFIELDS (type) = 2;
4594   TYPE_FIELDS (type)
4595     = (struct field *) obstack_alloc (&objfile->objfile_obstack,
4596                                       2 * sizeof (struct field));
4597
4598   if (dn_bufp->dsubr.dyn_low)
4599     TYPE_FIELD_BITPOS (type, 0) = 0;
4600   else
4601     TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound;
4602
4603   if (dn_bufp->dsubr.dyn_high)
4604     TYPE_FIELD_BITPOS (type, 1) = -1;
4605   else
4606     TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound;
4607   TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype,
4608                                                 objfile);
4609   return type;
4610 }
4611
4612 /* struct type * hpread_type_lookup(hp_type, objfile)
4613  *   Arguments:
4614  *     hp_type: A pointer into the DNTT specifying what type we
4615  *              are about to "look up"., or else [for fundamental types
4616  *              like int, float, ...] an "immediate" structure describing
4617  *              the type.
4618  *     objfile: ?
4619  *   Return value: A pointer to a "struct type" (representation of a
4620  *                 type in GDB's internal symbol table - see gdbtypes.h)
4621  *   Routine description:
4622  *     There are a variety of places when scanning the DNTT when we
4623  *     need to interpret a "type" field. The simplest and most basic
4624  *     example is when we're processing the symbol table record
4625  *     for a data symbol (a SVAR or DVAR record). That has
4626  *     a "type" field specifying the type of the data symbol. That
4627  *     "type" field is either an "immediate" type specification (for the
4628  *     fundamental types) or a DNTT pointer (for more complicated types).
4629  *     For the more complicated types, we may or may not have already
4630  *     processed the pointed-to type. (Multiple data symbols can of course
4631  *     share the same type).
4632  *     The job of hpread_type_lookup() is to process this "type" field.
4633  *     Most of the real work is done in subroutines. Here we interpret
4634  *     the immediate flag. If not immediate, chase the DNTT pointer to
4635  *     find our way to the SOM record describing the type, switch on
4636  *     the SOM kind, and then call an appropriate subroutine depending
4637  *     on what kind of type we are constructing. (e.g., an array type,
4638  *     a struct/class type, etc).
4639  */
4640 static struct type *
4641 hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile)
4642 {
4643   union dnttentry *dn_bufp;
4644   struct type *tmp_type;
4645
4646   /* First see if it's a simple builtin type.  */
4647   if (hp_type.dntti.immediate)
4648     {
4649       /* If this is a template argument, the argument number is
4650        * encoded in the bitlength. All other cases, just return
4651        * GDB's representation of this fundamental type.
4652        */
4653       if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG)
4654         return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength);
4655       else
4656         return lookup_fundamental_type (objfile,
4657                                         hpread_type_translate (hp_type));
4658     }
4659
4660   /* Not a builtin type.  We'll have to read it in.  */
4661   if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile))
4662     dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile);
4663   else
4664     /* This is a fancy way of returning NULL */
4665     return lookup_fundamental_type (objfile, FT_VOID);
4666
4667   switch (dn_bufp->dblock.kind)
4668     {
4669     case DNTT_TYPE_SRCFILE:
4670     case DNTT_TYPE_MODULE:
4671     case DNTT_TYPE_ENTRY:
4672     case DNTT_TYPE_BEGIN:
4673     case DNTT_TYPE_END:
4674     case DNTT_TYPE_IMPORT:
4675     case DNTT_TYPE_LABEL:
4676     case DNTT_TYPE_FPARAM:
4677     case DNTT_TYPE_SVAR:
4678     case DNTT_TYPE_DVAR:
4679     case DNTT_TYPE_CONST:
4680     case DNTT_TYPE_MEMENUM:
4681     case DNTT_TYPE_VARIANT:
4682     case DNTT_TYPE_FILE:
4683     case DNTT_TYPE_WITH:
4684     case DNTT_TYPE_COMMON:
4685     case DNTT_TYPE_COBSTRUCT:
4686     case DNTT_TYPE_XREF:
4687     case DNTT_TYPE_SA:
4688     case DNTT_TYPE_MACRO:
4689     case DNTT_TYPE_BLOCKDATA:
4690     case DNTT_TYPE_CLASS_SCOPE:
4691     case DNTT_TYPE_MEMACCESS:
4692     case DNTT_TYPE_INHERITANCE:
4693     case DNTT_TYPE_OBJECT_ID:
4694     case DNTT_TYPE_FRIEND_CLASS:
4695     case DNTT_TYPE_FRIEND_FUNC:
4696       /* These are not types - something went wrong.  */
4697       /* This is a fancy way of returning NULL */
4698       return lookup_fundamental_type (objfile, FT_VOID);
4699
4700     case DNTT_TYPE_FUNCTION:
4701       /* We wind up here when dealing with class member functions
4702        * (called from hpread_read_struct_type(), i.e. when processing
4703        * the class definition itself).
4704        */
4705       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4706
4707     case DNTT_TYPE_DOC_FUNCTION:
4708       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4709
4710     case DNTT_TYPE_TYPEDEF:
4711       {
4712         /* A typedef - chase it down by making a recursive call */
4713         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4714                                                       objfile);
4715
4716         /* The following came from the base hpread.c that we inherited.
4717          * It is WRONG so I have commented it out. - RT
4718          *...
4719
4720          char *suffix;
4721          suffix = VT (objfile) + dn_bufp->dtype.name;
4722          TYPE_NAME (structtype) = suffix;
4723
4724          * ... further explanation ....
4725          *
4726          * What we have here is a typedef pointing to a typedef.
4727          * E.g.,
4728          * typedef int foo;
4729          * typedef foo fum;
4730          *
4731          * What we desire to build is (these are pictures
4732          * of "struct type"'s):
4733          *
4734          *  +---------+     +----------+     +------------+
4735          *  | typedef |     | typedef  |     | fund. type |
4736          *  |     type| ->  |      type| ->  |            |
4737          *  | "fum"   |     | "foo"    |     | "int"      |
4738          *  +---------+     +----------+     +------------+
4739          *
4740          * What this commented-out code is doing is smashing the
4741          * name of pointed-to-type to be the same as the pointed-from
4742          * type. So we wind up with something like:
4743          *
4744          *  +---------+     +----------+     +------------+
4745          *  | typedef |     | typedef  |     | fund. type |
4746          *  |     type| ->  |      type| ->  |            |
4747          *  | "fum"   |     | "fum"    |     | "fum"      |
4748          *  +---------+     +----------+     +------------+
4749          *
4750          */
4751
4752         return structtype;
4753       }
4754
4755     case DNTT_TYPE_TAGDEF:
4756       {
4757         /* Just a little different from above.  We have to tack on
4758          * an identifier of some kind (struct, union, enum, class, etc).
4759          */
4760         struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4761                                                       objfile);
4762         char *prefix, *suffix;
4763         suffix = VT (objfile) + dn_bufp->dtype.name;
4764
4765         /* Lookup the next type in the list.  It should be a structure,
4766          * union, class, enum, or template type.
4767          * We will need to attach that to our name.
4768          */
4769         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
4770           dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
4771         else
4772           {
4773             complaint (&symfile_complaints, "error in hpread_type_lookup().");
4774             return NULL;
4775           }
4776
4777         if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
4778           {
4779             prefix = "struct ";
4780           }
4781         else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
4782           {
4783             prefix = "union ";
4784           }
4785         else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
4786           {
4787             /* Further field for CLASS saying how it was really declared */
4788             /* 0==class, 1==union, 2==struct */
4789             if (dn_bufp->dclass.class_decl == 0)
4790               prefix = "class ";
4791             else if (dn_bufp->dclass.class_decl == 1)
4792               prefix = "union ";
4793             else if (dn_bufp->dclass.class_decl == 2)
4794               prefix = "struct ";
4795             else
4796               prefix = "";
4797           }
4798         else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM)
4799           {
4800             prefix = "enum ";
4801           }
4802         else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4803           {
4804             prefix = "template ";
4805           }
4806         else
4807           {
4808             prefix = "";
4809           }
4810
4811         /* Build the correct name.  */
4812         TYPE_NAME (structtype)
4813           = (char *) obstack_alloc (&objfile->objfile_obstack,
4814                                     strlen (prefix) + strlen (suffix) + 1);
4815         TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix);
4816         TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix);
4817         TYPE_TAG_NAME (structtype) = suffix;
4818
4819         /* For classes/structs, we have to set the static member "physnames"
4820            to point to strings like "Class::Member" */
4821         if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT)
4822           fix_static_member_physnames (structtype, suffix, objfile);
4823
4824         return structtype;
4825       }
4826
4827     case DNTT_TYPE_POINTER:
4828       /* Pointer type - call a routine in gdbtypes.c that constructs
4829        * the appropriate GDB type.
4830        */
4831       return make_pointer_type (
4832                                  hpread_type_lookup (dn_bufp->dptr.pointsto,
4833                                                      objfile),
4834                                  NULL);
4835
4836     case DNTT_TYPE_REFERENCE:
4837       /* C++ reference type - call a routine in gdbtypes.c that constructs
4838        * the appropriate GDB type.
4839        */
4840       return make_reference_type (
4841                            hpread_type_lookup (dn_bufp->dreference.pointsto,
4842                                                objfile),
4843                                    NULL);
4844
4845     case DNTT_TYPE_ENUM:
4846       return hpread_read_enum_type (hp_type, dn_bufp, objfile);
4847     case DNTT_TYPE_SET:
4848       return hpread_read_set_type (hp_type, dn_bufp, objfile);
4849     case DNTT_TYPE_SUBRANGE:
4850       return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
4851     case DNTT_TYPE_ARRAY:
4852       return hpread_read_array_type (hp_type, dn_bufp, objfile);
4853     case DNTT_TYPE_STRUCT:
4854     case DNTT_TYPE_UNION:
4855       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4856     case DNTT_TYPE_FIELD:
4857       return hpread_type_lookup (dn_bufp->dfield.type, objfile);
4858
4859     case DNTT_TYPE_FUNCTYPE:
4860       /* Here we want to read the function SOMs and return a
4861        * type for it. We get here, for instance, when processing
4862        * pointer-to-function type.
4863        */
4864       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4865
4866     case DNTT_TYPE_PTRMEM:
4867       /* Declares a C++ pointer-to-data-member type.
4868        * The "pointsto" field defines the class,
4869        * while the "memtype" field defines the pointed-to-type.
4870        */
4871       {
4872         struct type *ptrmemtype;
4873         struct type *class_type;
4874         struct type *memtype;
4875         memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4876                                       objfile),
4877           class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4878                                            objfile),
4879           ptrmemtype = alloc_type (objfile);
4880         smash_to_member_type (ptrmemtype, class_type, memtype);
4881         return make_pointer_type (ptrmemtype, NULL);
4882       }
4883       break;
4884
4885     case DNTT_TYPE_PTRMEMFUNC:
4886       /* Defines a C++ pointer-to-function-member type.
4887        * The "pointsto" field defines the class,
4888        * while the "memtype" field defines the pointed-to-type.
4889        */
4890       {
4891         struct type *ptrmemtype;
4892         struct type *class_type;
4893         struct type *functype;
4894         struct type *retvaltype;
4895         int nargs;
4896         int i;
4897         class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4898                                          objfile);
4899         functype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4900                                        objfile);
4901         retvaltype = TYPE_TARGET_TYPE (functype);
4902         nargs = TYPE_NFIELDS (functype);
4903         ptrmemtype = alloc_type (objfile);
4904
4905         smash_to_method_type (ptrmemtype, class_type, retvaltype,
4906                               TYPE_FIELDS (functype),
4907                               TYPE_NFIELDS (functype),
4908                               0);
4909         return make_pointer_type (ptrmemtype, NULL);
4910       }
4911       break;
4912
4913     case DNTT_TYPE_CLASS:
4914       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4915
4916     case DNTT_TYPE_GENFIELD:
4917       /* Chase pointer from GENFIELD to FIELD, and make recursive
4918        * call on that.
4919        */
4920       return hpread_type_lookup (dn_bufp->dgenfield.field, objfile);
4921
4922     case DNTT_TYPE_VFUNC:
4923       /* C++ virtual function.
4924        * We get here in the course of processing a class type which
4925        * contains virtual functions. Just go through another level
4926        * of indirection to get to the pointed-to function SOM.
4927        */
4928       return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile);
4929
4930     case DNTT_TYPE_MODIFIER:
4931       /* Check the modifiers and then just make a recursive call on
4932        * the "type" pointed to by the modifier DNTT.
4933        *
4934        * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4935        * "m_void" modifiers?  Is static_flag really needed here?
4936        * (m_static used for methods of classes, elsewhere).
4937        */
4938       tmp_type = make_cv_type (dn_bufp->dmodifier.m_const,
4939                                dn_bufp->dmodifier.m_volatile,
4940                       hpread_type_lookup (dn_bufp->dmodifier.type, objfile),
4941                                0);
4942       return tmp_type;
4943
4944
4945     case DNTT_TYPE_MEMFUNC:
4946       /* Member function. Treat like a function.
4947        * I think we get here in the course of processing a
4948        * pointer-to-member-function type...
4949        */
4950       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4951
4952     case DNTT_TYPE_DOC_MEMFUNC:
4953       return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4954
4955     case DNTT_TYPE_TEMPLATE:
4956       /* Template - sort of the header for a template definition,
4957        * which like a class, points to a member list and also points
4958        * to a TEMPLATE_ARG list of type-arguments.
4959        */
4960       return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4961
4962     case DNTT_TYPE_TEMPLATE_ARG:
4963       {
4964         char *name;
4965         /* The TEMPLATE record points to an argument list of
4966          * TEMPLATE_ARG records, each of which describes one
4967          * of the type-arguments.
4968          */
4969         name = VT (objfile) + dn_bufp->dtempl_arg.name;
4970         return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name);
4971       }
4972
4973     case DNTT_TYPE_FUNC_TEMPLATE:
4974       /* We wind up here when processing a TEMPLATE type,
4975        * if the template has member function(s).
4976        * Treat it like a FUNCTION.
4977        */
4978       return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4979
4980     case DNTT_TYPE_LINK:
4981       /* The LINK record is used to link up templates with instantiations.
4982        * There is no type associated with the LINK record per se.
4983        */
4984       return lookup_fundamental_type (objfile, FT_VOID);
4985
4986       /* Also not yet handled... */
4987       /* case DNTT_TYPE_DYN_ARRAY_DESC: */
4988       /* case DNTT_TYPE_DESC_SUBRANGE: */
4989       /* case DNTT_TYPE_BEGIN_EXT: */
4990       /* case DNTT_TYPE_INLN: */
4991       /* case DNTT_TYPE_INLN_LIST: */
4992       /* case DNTT_TYPE_ALIAS: */
4993     default:
4994       /* A fancy way of returning NULL */
4995       return lookup_fundamental_type (objfile, FT_VOID);
4996     }
4997 }
4998
4999 static sltpointer
5000 hpread_record_lines (struct subfile *subfile, sltpointer s_idx,
5001                      sltpointer e_idx, struct objfile *objfile,
5002                      CORE_ADDR offset)
5003 {
5004   union sltentry *sl_bufp;
5005
5006   while (s_idx <= e_idx)
5007     {
5008       sl_bufp = hpread_get_slt (s_idx, objfile);
5009       /* Only record "normal" entries in the SLT.  */
5010       if (sl_bufp->snorm.sltdesc == SLT_NORMAL
5011           || sl_bufp->snorm.sltdesc == SLT_EXIT)
5012         record_line (subfile, sl_bufp->snorm.line,
5013                      sl_bufp->snorm.address + offset);
5014       else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
5015         record_line (subfile, sl_bufp->snormoff.line,
5016                      sl_bufp->snormoff.address + offset);
5017       s_idx++;
5018     }
5019   return e_idx;
5020 }
5021
5022 /* Given a function "f" which is a member of a class, find
5023  * the classname that it is a member of. Used to construct
5024  * the name (e.g., "c::f") which GDB will put in the
5025  * "demangled name" field of the function's symbol.
5026  * Called from hpread_process_one_debug_symbol()
5027  * If "f" is not a member function, return NULL.
5028  */
5029 static char *
5030 class_of (struct type *functype)
5031 {
5032   struct type *first_param_type;
5033   char *first_param_name;
5034   struct type *pointed_to_type;
5035   char *class_name;
5036
5037   /* Check that the function has a first argument "this",
5038    * and that "this" is a pointer to a class. If not,
5039    * functype is not a member function, so return NULL.
5040    */
5041   if (TYPE_NFIELDS (functype) == 0)
5042     return NULL;
5043   first_param_name = TYPE_FIELD_NAME (functype, 0);
5044   if (first_param_name == NULL)
5045     return NULL;                /* paranoia */
5046   if (strcmp (first_param_name, "this"))
5047     return NULL;
5048   first_param_type = TYPE_FIELD_TYPE (functype, 0);
5049   if (first_param_type == NULL)
5050     return NULL;                /* paranoia */
5051   if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR)
5052     return NULL;
5053
5054   /* Get the thing that "this" points to, check that
5055    * it's a class, and get its class name.
5056    */
5057   pointed_to_type = TYPE_TARGET_TYPE (first_param_type);
5058   if (pointed_to_type == NULL)
5059     return NULL;                /* paranoia */
5060   if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS)
5061     return NULL;
5062   class_name = TYPE_NAME (pointed_to_type);
5063   if (class_name == NULL)
5064     return NULL;                /* paranoia */
5065
5066   /* The class name may be of the form "class c", in which case
5067    * we want to strip off the leading "class ".
5068    */
5069   if (strncmp (class_name, "class ", 6) == 0)
5070     class_name += 6;
5071
5072   return class_name;
5073 }
5074
5075 /* Internalize one native debug symbol.
5076  * Called in a loop from hpread_expand_symtab().
5077  * Arguments:
5078  *   dn_bufp:
5079  *   name:
5080  *   section_offsets:
5081  *   objfile:
5082  *   text_offset:
5083  *   text_size:
5084  *   filename:
5085  *   index:             Index of this symbol
5086  *   at_module_boundary_p Pointer to boolean flag to control caller's loop.
5087  */
5088
5089 static void
5090 hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name,
5091                                  struct section_offsets *section_offsets,
5092                                  struct objfile *objfile, CORE_ADDR text_offset,
5093                                  int text_size, char *filename, int index,
5094                                  int *at_module_boundary_p)
5095 {
5096   unsigned long desc;
5097   int type;
5098   CORE_ADDR valu;
5099   int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
5100   int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
5101   union dnttentry *dn_temp;
5102   dnttpointer hp_type;
5103   struct symbol *sym;
5104   struct context_stack *new;
5105   char *class_scope_name;
5106
5107   /* Allocate one GDB debug symbol and fill in some default values. */
5108   sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5109                                          sizeof (struct symbol));
5110   memset (sym, 0, sizeof (struct symbol));
5111   DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->objfile_obstack);
5112   SYMBOL_LANGUAGE (sym) = language_auto;
5113   SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5114   SYMBOL_LINE (sym) = 0;
5115   SYMBOL_VALUE (sym) = 0;
5116   SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5117
5118   /* Just a trick in case the SOM debug symbol is a type definition.
5119    * There are routines that are set up to build a GDB type symbol, given
5120    * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5121    * This allows us to call those same routines.
5122    */
5123   hp_type.dnttp.extension = 1;
5124   hp_type.dnttp.immediate = 0;
5125   hp_type.dnttp.global = 0;
5126   hp_type.dnttp.index = index;
5127
5128   /* This "type" is the type of SOM record.
5129    * Switch on SOM type.
5130    */
5131   type = dn_bufp->dblock.kind;
5132   switch (type)
5133     {
5134     case DNTT_TYPE_SRCFILE:
5135       /* This type of symbol indicates from which source file or
5136        * include file any following data comes. It may indicate:
5137        *
5138        * o   The start of an entirely new source file (and thus
5139        *     a new module)
5140        *
5141        * o   The start of a different source file due to #include
5142        *
5143        * o   The end of an include file and the return to the original
5144        *     file. Thus if "foo.c" includes "bar.h", we see first
5145        *     a SRCFILE for foo.c, then one for bar.h, and then one for
5146        *     foo.c again.
5147        *
5148        * If it indicates the start of a new module then we must
5149        * finish the symbol table of the previous module
5150        * (if any) and start accumulating a new symbol table.
5151        */
5152
5153       valu = text_offset;
5154       if (!last_source_file)
5155         {
5156           /*
5157            * A note on "last_source_file": this is a char* pointing
5158            * to the actual file name.  "start_symtab" sets it,
5159            * "end_symtab" clears it.
5160            *
5161            * So if "last_source_file" is NULL, then either this is
5162            * the first record we are looking at, or a previous call
5163            * to "end_symtab()" was made to close out the previous
5164            * module.  Since we're now quitting the scan loop when we
5165            * see a MODULE END record, we should never get here, except
5166            * in the case that we're not using the quick look-up tables
5167            * and have to use the old system as a fall-back.
5168            */
5169           start_symtab (name, NULL, valu);
5170           record_debugformat ("HP");
5171           SL_INDEX (objfile) = dn_bufp->dsfile.address;
5172         }
5173
5174       else
5175         {
5176           /* Either a new include file, or a SRCFILE record
5177            * saying we are back in the main source (or out of
5178            * a nested include file) again.
5179            */
5180           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5181                                                     SL_INDEX (objfile),
5182                                                     dn_bufp->dsfile.address,
5183                                                     objfile, offset);
5184         }
5185
5186       /* A note on "start_subfile".  This routine will check
5187        * the name we pass it and look for an existing subfile
5188        * of that name.  There's thus only one sub-file for the
5189        * actual source (e.g. for "foo.c" in foo.c), despite the
5190        * fact that we'll see lots of SRCFILE entries for foo.c
5191        * inside foo.c.
5192        */
5193       start_subfile (name, NULL);
5194       break;
5195
5196     case DNTT_TYPE_MODULE:
5197       /*
5198        * We no longer ignore DNTT_TYPE_MODULE symbols.  The module
5199        * represents the meaningful semantic structure of a compilation
5200        * unit.  We expect to start the psymtab-to-symtab expansion
5201        * looking at a MODULE entry, and to end it at the corresponding
5202        * END MODULE entry.
5203        *
5204        *--Begin outdated comments
5205        *
5206        * This record signifies the start of a new source module
5207        * In C/C++ there is no explicit "module" construct in the language,
5208        * but each compilation unit is implicitly a module and they
5209        * do emit the DNTT_TYPE_MODULE records.
5210        * The end of the module is marked by a matching DNTT_TYPE_END record.
5211        *
5212        * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5213        * is it notices the DNTT_TYPE_END record for the previous
5214        * module (see comments under DNTT_TYPE_END case), and then treats
5215        * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5216        * (i.e., it makes a start_symtab() call).
5217        * This scheme seems a little convoluted, but I'll leave it
5218        * alone on the principle "if it ain't broke don't fix
5219        * it". (RT).
5220        *
5221        *-- End outdated comments
5222        */
5223
5224       valu = text_offset;
5225       if (!last_source_file)
5226         {
5227           /* Start of a new module. We know this because "last_source_file"
5228            * is NULL, which can only happen the first time or if we just
5229            * made a call to end_symtab() to close out the previous module.
5230            */
5231           start_symtab (name, NULL, valu);
5232           SL_INDEX (objfile) = dn_bufp->dmodule.address;
5233         }
5234       else
5235         {
5236           /* This really shouldn't happen if we're using the quick
5237            * look-up tables, as it would mean we'd scanned past an
5238            * END MODULE entry.  But if we're not using the tables,
5239            * we started the module on the SRCFILE entry, so it's ok.
5240            * For now, accept this.
5241            */
5242           /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5243            *           name );
5244            */
5245           *at_module_boundary_p = -1;
5246         }
5247
5248       start_subfile (name, NULL);
5249       break;
5250
5251     case DNTT_TYPE_FUNCTION:
5252     case DNTT_TYPE_ENTRY:
5253       /* A function or secondary entry point.  */
5254       valu = dn_bufp->dfunc.lowaddr + offset;
5255
5256       /* Record lines up to this point. */
5257       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5258                                                 SL_INDEX (objfile),
5259                                                 dn_bufp->dfunc.address,
5260                                                 objfile, offset);
5261
5262       WITHIN_FUNCTION (objfile) = 1;
5263       CURRENT_FUNCTION_VALUE (objfile) = valu;
5264
5265       /* Stack must be empty now.  */
5266       if (context_stack_depth != 0)
5267         lbrac_unmatched_complaint (symnum);
5268       new = push_context (0, valu);
5269
5270       /* Built a type for the function. This includes processing
5271        * the symbol records for the function parameters.
5272        */
5273       SYMBOL_CLASS (sym) = LOC_BLOCK;
5274       SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1);
5275
5276       /* All functions in C++ have prototypes.  For C we don't have enough
5277          information in the debug info.  */
5278       if (SYMBOL_LANGUAGE (sym) == language_cplus)
5279         TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
5280
5281       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5282        * (if any), which we get from the "alias" field of the SOM record
5283        * if that exists.
5284        */
5285       if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5286           dn_bufp->dfunc.alias &&       /* has an alias */
5287           *(char *) (VT (objfile) + dn_bufp->dfunc.alias))      /* not a null string */
5288         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias;
5289       else
5290         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5291
5292       /* Special hack to get around HP compilers' insistence on
5293        * reporting "main" as "_MAIN_" for C/C++ */
5294       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5295           (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0))
5296         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5297
5298       /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5299        * be the demangled name.
5300        */
5301       if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5302         {
5303           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5304            * calling the demangler in libiberty (cplus_demangle()) to
5305            * do the job. This generally does the job, even though
5306            * it's intended for the GNU compiler and not the aCC compiler
5307            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5308            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5309            * Generally, we don't want params when we display
5310            * a demangled name, but when I took out the DMGL_PARAMS,
5311            * some things broke, so I'm leaving it in here, and
5312            * working around the issue in stack.c. - RT
5313            */
5314           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack);
5315           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) &&
5316               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5317             {
5318
5319               /* Well, the symbol name is mangled, but the
5320                * demangler in libiberty failed so the demangled
5321                * field is still NULL. Try to
5322                * do the job ourselves based on the "name" field
5323                * in the SOM record. A complication here is that
5324                * the name field contains only the function name
5325                * (like "f"), whereas we want the class qualification
5326                * (as in "c::f"). Try to reconstruct that.
5327                */
5328               char *basename;
5329               char *classname;
5330               char *dem_name;
5331               basename = VT (objfile) + dn_bufp->dfunc.name;
5332               classname = class_of (SYMBOL_TYPE (sym));
5333               if (classname)
5334                 {
5335                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5336                   strcpy (dem_name, classname);
5337                   strcat (dem_name, "::");
5338                   strcat (dem_name, basename);
5339                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5340                   SYMBOL_LANGUAGE (sym) = language_cplus;
5341                 }
5342             }
5343         }
5344
5345       /* Add the function symbol to the list of symbols in this blockvector */
5346       if (dn_bufp->dfunc.global)
5347         add_symbol_to_list (sym, &global_symbols);
5348       else
5349         add_symbol_to_list (sym, &file_symbols);
5350       new->name = sym;
5351
5352       /* Search forward to the next BEGIN and also read
5353        * in the line info up to that point.
5354        * Not sure why this is needed.
5355        * In HP FORTRAN this code is harmful since there
5356        * may not be a BEGIN after the FUNCTION.
5357        * So I made it C/C++ specific. - RT
5358        */
5359       if (dn_bufp->dfunc.language == HP_LANGUAGE_C ||
5360           dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5361         {
5362           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5363             {
5364               dn_bufp = hpread_get_lntt (++index, objfile);
5365               if (dn_bufp->dblock.extension)
5366                 continue;
5367             }
5368           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5369                                                     SL_INDEX (objfile),
5370                                                     dn_bufp->dbegin.address,
5371                                                     objfile, offset);
5372           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5373         }
5374       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5375       break;
5376
5377     case DNTT_TYPE_DOC_FUNCTION:
5378       valu = dn_bufp->ddocfunc.lowaddr + offset;
5379
5380       /* Record lines up to this point. */
5381       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5382                                                 SL_INDEX (objfile),
5383                                                 dn_bufp->ddocfunc.address,
5384                                                 objfile, offset);
5385
5386       WITHIN_FUNCTION (objfile) = 1;
5387       CURRENT_FUNCTION_VALUE (objfile) = valu;
5388       /* Stack must be empty now.  */
5389       if (context_stack_depth != 0)
5390         lbrac_unmatched_complaint (symnum);
5391       new = push_context (0, valu);
5392
5393       /* Built a type for the function. This includes processing
5394        * the symbol records for the function parameters.
5395        */
5396       SYMBOL_CLASS (sym) = LOC_BLOCK;
5397       SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1);
5398
5399       /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5400        * (if any), which we get from the "alias" field of the SOM record
5401        * if that exists.
5402        */
5403       if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5404           dn_bufp->ddocfunc.alias &&    /* has an alias */
5405           *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias))   /* not a null string */
5406         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias;
5407       else
5408         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5409
5410       /* Special hack to get around HP compilers' insistence on
5411        * reporting "main" as "_MAIN_" for C/C++ */
5412       if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5413           (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0))
5414         DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5415
5416       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5417         {
5418
5419           /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5420            * calling the demangler in libiberty (cplus_demangle()) to
5421            * do the job. This generally does the job, even though
5422            * it's intended for the GNU compiler and not the aCC compiler
5423            * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5424            * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5425            * Generally, we don't want params when we display
5426            * a demangled name, but when I took out the DMGL_PARAMS,
5427            * some things broke, so I'm leaving it in here, and
5428            * working around the issue in stack.c. - RT
5429            */
5430           SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack);
5431
5432           if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) &&
5433               (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5434             {
5435
5436               /* Well, the symbol name is mangled, but the
5437                * demangler in libiberty failed so the demangled
5438                * field is still NULL. Try to
5439                * do the job ourselves based on the "name" field
5440                * in the SOM record. A complication here is that
5441                * the name field contains only the function name
5442                * (like "f"), whereas we want the class qualification
5443                * (as in "c::f"). Try to reconstruct that.
5444                */
5445               char *basename;
5446               char *classname;
5447               char *dem_name;
5448               basename = VT (objfile) + dn_bufp->ddocfunc.name;
5449               classname = class_of (SYMBOL_TYPE (sym));
5450               if (classname)
5451                 {
5452                   dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5453                   strcpy (dem_name, classname);
5454                   strcat (dem_name, "::");
5455                   strcat (dem_name, basename);
5456                   SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5457                   SYMBOL_LANGUAGE (sym) = language_cplus;
5458                 }
5459             }
5460         }
5461
5462       /* Add the function symbol to the list of symbols in this blockvector */
5463       if (dn_bufp->ddocfunc.global)
5464         add_symbol_to_list (sym, &global_symbols);
5465       else
5466         add_symbol_to_list (sym, &file_symbols);
5467       new->name = sym;
5468
5469       /* Search forward to the next BEGIN and also read
5470        * in the line info up to that point.
5471        * Not sure why this is needed.
5472        * In HP FORTRAN this code is harmful since there
5473        * may not be a BEGIN after the FUNCTION.
5474        * So I made it C/C++ specific. - RT
5475        */
5476       if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C ||
5477           dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5478         {
5479           while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5480             {
5481               dn_bufp = hpread_get_lntt (++index, objfile);
5482               if (dn_bufp->dblock.extension)
5483                 continue;
5484             }
5485           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5486                                                     SL_INDEX (objfile),
5487                                                     dn_bufp->dbegin.address,
5488                                                     objfile, offset);
5489           SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5490         }
5491       record_line (current_subfile, SYMBOL_LINE (sym), valu);
5492       break;
5493
5494     case DNTT_TYPE_BEGIN:
5495       /* Begin a new scope. */
5496       if (context_stack_depth == 1 /* this means we're at function level */  &&
5497           context_stack[0].name != NULL /* this means it's a function */  &&
5498           context_stack[0].depth == 0   /* this means it's the first BEGIN
5499                                            we've seen after the FUNCTION */
5500         )
5501         {
5502           /* This is the first BEGIN after a FUNCTION.
5503            * We ignore this one, since HP compilers always insert
5504            * at least one BEGIN, i.e. it's:
5505            *
5506            *     FUNCTION
5507            *     argument symbols
5508            *     BEGIN
5509            *     local symbols
5510            *        (possibly nested BEGIN ... END's if there are inner { } blocks)
5511            *     END
5512            *     END
5513            *
5514            * By ignoring this first BEGIN, the local symbols get treated
5515            * as belonging to the function scope, and "print func::local_sym"
5516            * works (which is what we want).
5517            */
5518
5519           /* All we do here is increase the depth count associated with
5520            * the FUNCTION entry in the context stack. This ensures that
5521            * the next BEGIN we see (if any), representing a real nested { }
5522            * block, will get processed.
5523            */
5524
5525           context_stack[0].depth++;
5526
5527         }
5528       else
5529         {
5530
5531           /* Record lines up to this SLT pointer. */
5532           SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5533                                                     SL_INDEX (objfile),
5534                                                     dn_bufp->dbegin.address,
5535                                                     objfile, offset);
5536           /* Calculate start address of new scope */
5537           valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
5538           valu += offset;       /* Relocate for dynamic loading */
5539           /* We use the scope start DNTT index as nesting depth identifier! */
5540           desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile);
5541           new = push_context (desc, valu);
5542         }
5543       break;
5544
5545     case DNTT_TYPE_END:
5546       /* End a scope.  */
5547
5548       /* Valid end kinds are:
5549        *  MODULE
5550        *  FUNCTION
5551        *  WITH
5552        *  COMMON
5553        *  BEGIN
5554        *  CLASS_SCOPE
5555        */
5556
5557       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5558                                                 SL_INDEX (objfile),
5559                                                 dn_bufp->dend.address,
5560                                                 objfile, offset);
5561       switch (dn_bufp->dend.endkind)
5562         {
5563         case DNTT_TYPE_MODULE:
5564           /* Ending a module ends the symbol table for that module.
5565            * Calling end_symtab() has the side effect of clearing the
5566            * last_source_file pointer, which in turn signals
5567            * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5568            * record as a module-begin.
5569            */
5570           valu = text_offset + text_size + offset;
5571
5572           /* Tell our caller that we're done with expanding the
5573            * debug information for a module.
5574            */
5575           *at_module_boundary_p = 1;
5576
5577           /* Don't do this, as our caller will do it!
5578
5579            *      (void) end_symtab (valu, objfile, 0);
5580            */
5581           break;
5582
5583         case DNTT_TYPE_FUNCTION:
5584           /* Ending a function, well, ends the function's scope.  */
5585           dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
5586                                      objfile);
5587           valu = dn_temp->dfunc.hiaddr + offset;
5588           /* Insert func params into local list */
5589           merge_symbol_lists (&param_symbols, &local_symbols);
5590           new = pop_context ();
5591           /* Make a block for the local symbols within.  */
5592           finish_block (new->name, &local_symbols, new->old_blocks,
5593                         new->start_addr, valu, objfile);
5594           WITHIN_FUNCTION (objfile) = 0;        /* This may have to change for Pascal */
5595           local_symbols = new->locals;
5596           param_symbols = new->params;
5597           break;
5598
5599         case DNTT_TYPE_BEGIN:
5600           if (context_stack_depth == 1 &&
5601               context_stack[0].name != NULL &&
5602               context_stack[0].depth == 1)
5603             {
5604               /* This is the END corresponding to the
5605                * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5606                */
5607               context_stack[0].depth--;
5608             }
5609           else
5610             {
5611               /* Ending a local scope.  */
5612               valu = hpread_get_location (dn_bufp->dend.address, objfile);
5613               /* Why in the hell is this needed?  */
5614               valu += offset + 9;       /* Relocate for dynamic loading */
5615               new = pop_context ();
5616               desc = dn_bufp->dend.beginscope.dnttp.index;
5617               if (desc != new->depth)
5618                 lbrac_mismatch_complaint (symnum);
5619
5620               /* Make a block for the local symbols within.  */
5621               finish_block (new->name, &local_symbols, new->old_blocks,
5622                             new->start_addr, valu, objfile);
5623               local_symbols = new->locals;
5624               param_symbols = new->params;
5625             }
5626           break;
5627
5628         case DNTT_TYPE_WITH:
5629           /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5630            * we can ignore the DNTT_TYPE_END that ends it.
5631            */
5632           break;
5633
5634         case DNTT_TYPE_COMMON:
5635           /* End a FORTRAN common block. We don't currently handle these */
5636           complaint (&symfile_complaints,
5637                      "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n");
5638           break;
5639
5640         case DNTT_TYPE_CLASS_SCOPE:
5641
5642           /* pai: FIXME Not handling nested classes for now -- must
5643              * maintain a stack */
5644           class_scope_name = NULL;
5645
5646 #if 0
5647           /* End a class scope */
5648           valu = hpread_get_location (dn_bufp->dend.address, objfile);
5649           /* Why in the hell is this needed?  */
5650           valu += offset + 9;   /* Relocate for dynamic loading */
5651           new = pop_context ();
5652           desc = dn_bufp->dend.beginscope.dnttp.index;
5653           if (desc != new->depth)
5654             lbrac_mismatch_complaint ((char *) symnum);
5655           /* Make a block for the local symbols within.  */
5656           finish_block (new->name, &local_symbols, new->old_blocks,
5657                         new->start_addr, valu, objfile);
5658           local_symbols = new->locals;
5659           param_symbols = new->params;
5660 #endif
5661           break;
5662
5663         default:
5664           complaint (&symfile_complaints,
5665                      "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.");
5666           break;
5667         }
5668       break;
5669
5670       /* DNTT_TYPE_IMPORT is not handled */
5671
5672     case DNTT_TYPE_LABEL:
5673       SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
5674       break;
5675
5676     case DNTT_TYPE_FPARAM:
5677       /* Function parameters.  */
5678       /* Note 1: This code was present in the 4.16 sources, and then
5679          removed, because fparams are handled in
5680          hpread_read_function_type().  However, while fparam symbols
5681          are indeed handled twice, this code here cannot be removed
5682          because then they don't get added to the local symbol list of
5683          the function's code block, which leads to a failure to look
5684          up locals, "this"-relative member names, etc.  So I've put
5685          this code back in. pai/1997-07-21 */
5686       /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5687          in hpread_read_function_type(), so FPARAMS had to be handled
5688          here.  I changed the location to be the appropriate argument
5689          kinds rather than LOC_LOCAL. pai/1997-08-08 */
5690       /* Note 3: Well, the fix in Note 2 above broke argument printing
5691          in traceback frames, and further it makes assumptions about the
5692          order of the FPARAM entries from HP compilers (cc and aCC in particular
5693          generate them in reverse orders -- fixing one breaks for the other).
5694          So I've added code in hpread_read_function_type() to add fparams
5695          to a param_symbols list for the current context level.  These are
5696          then merged into local_symbols when a function end is reached.
5697          pai/1997-08-11 */
5698
5699       break;                    /* do nothing; handled in hpread_read_function_type() */
5700
5701 #if 0                           /* Old code */
5702       if (dn_bufp->dfparam.regparam)
5703         SYMBOL_CLASS (sym) = LOC_REGISTER;
5704       else if (dn_bufp->dfparam.indirect)
5705         SYMBOL_CLASS (sym) = LOC_REF_ARG;
5706       else
5707         SYMBOL_CLASS (sym) = LOC_ARG;
5708       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5709       if (dn_bufp->dfparam.copyparam)
5710         {
5711           SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5712           SYMBOL_VALUE (sym)
5713             += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
5714         }
5715       else
5716         SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5717       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
5718       add_symbol_to_list (sym, &fparam_symbols);
5719       break;
5720 #endif
5721
5722     case DNTT_TYPE_SVAR:
5723       /* Static variables.  */
5724       SYMBOL_CLASS (sym) = LOC_STATIC;
5725
5726       /* Note: There is a case that arises with globals in shared
5727        * libraries where we need to set the address to LOC_INDIRECT.
5728        * This case is if you have a global "g" in one library, and
5729        * it is referenced "extern <type> g;" in another library.
5730        * If we're processing the symbols for the referencing library,
5731        * we'll see a global "g", but in this case the address given
5732        * in the symbol table contains a pointer to the real "g".
5733        * We use the storage class LOC_INDIRECT to indicate this. RT
5734        */
5735       if (is_in_import_list (DEPRECATED_SYMBOL_NAME (sym), objfile))
5736         SYMBOL_CLASS (sym) = LOC_INDIRECT;
5737
5738       SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset;
5739       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
5740
5741       if (dn_bufp->dsvar.global)
5742         add_symbol_to_list (sym, &global_symbols);
5743
5744       else if (WITHIN_FUNCTION (objfile))
5745         add_symbol_to_list (sym, &local_symbols);
5746
5747       else
5748         add_symbol_to_list (sym, &file_symbols);
5749
5750       if (dn_bufp->dsvar.thread_specific)
5751         {
5752           /* Thread-local variable.
5753            */
5754           SYMBOL_CLASS (sym) = LOC_HP_THREAD_LOCAL_STATIC;
5755           SYMBOL_BASEREG (sym) = HPPA_CR27_REGNUM;
5756
5757           if (objfile->flags & OBJF_SHARED)
5758             {
5759               /*
5760                * This variable is not only thread local but
5761                * in a shared library.
5762                *
5763                * Alas, the shared lib structures are private
5764                * to "somsolib.c".  But C lets us point to one.
5765                */
5766               struct so_list *so;
5767               struct hppa_objfile_private *priv;
5768
5769               priv = (struct hppa_objfile_private *)
5770                 objfile_data (objfile, hppa_objfile_priv_data);
5771               if (priv == NULL)
5772                 error ("Internal error in reading shared library information.");
5773
5774               so = ((struct hppa_objfile_private *) priv)->so_info;
5775               if (so == NULL)
5776                 error ("Internal error in reading shared library information.");
5777
5778               /* Thread-locals in shared libraries do NOT have the
5779                * standard offset ("data_offset"), so we re-calculate
5780                * where to look for this variable, using a call-back
5781                * to interpret the private shared-library data.
5782                */
5783               SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location +
5784                 so_lib_thread_start_addr (so);
5785             }
5786         }
5787       break;
5788
5789     case DNTT_TYPE_DVAR:
5790       /* Dynamic variables.  */
5791       if (dn_bufp->ddvar.regvar)
5792         SYMBOL_CLASS (sym) = LOC_REGISTER;
5793       else
5794         SYMBOL_CLASS (sym) = LOC_LOCAL;
5795
5796       SYMBOL_VALUE (sym) = dn_bufp->ddvar.location;
5797       SYMBOL_VALUE (sym)
5798         += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile));
5799       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
5800       if (dn_bufp->ddvar.global)
5801         add_symbol_to_list (sym, &global_symbols);
5802       else if (WITHIN_FUNCTION (objfile))
5803         add_symbol_to_list (sym, &local_symbols);
5804       else
5805         add_symbol_to_list (sym, &file_symbols);
5806       break;
5807
5808     case DNTT_TYPE_CONST:
5809       /* A constant (pascal?).  */
5810       SYMBOL_CLASS (sym) = LOC_CONST;
5811       SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
5812       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
5813       if (dn_bufp->dconst.global)
5814         add_symbol_to_list (sym, &global_symbols);
5815       else if (WITHIN_FUNCTION (objfile))
5816         add_symbol_to_list (sym, &local_symbols);
5817       else
5818         add_symbol_to_list (sym, &file_symbols);
5819       break;
5820
5821     case DNTT_TYPE_TYPEDEF:
5822       /* A typedef. We do want to process these, since a name is
5823        * added to the domain for the typedef'ed name.
5824        */
5825       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5826       SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5827       if (dn_bufp->dtype.global)
5828         add_symbol_to_list (sym, &global_symbols);
5829       else if (WITHIN_FUNCTION (objfile))
5830         add_symbol_to_list (sym, &local_symbols);
5831       else
5832         add_symbol_to_list (sym, &file_symbols);
5833       break;
5834
5835     case DNTT_TYPE_TAGDEF:
5836       {
5837         int global = dn_bufp->dtag.global;
5838         /* Structure, union, enum, template, or class tag definition */
5839         /* We do want to process these, since a name is
5840          * added to the domain for the tag name (and if C++ class,
5841          * for the typename also).
5842          */
5843         SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5844
5845         /* The tag contains in its "type" field a pointer to the
5846          * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5847          * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5848          * record that actually defines the type.
5849          */
5850         SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5851         TYPE_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5852         TYPE_TAG_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym);
5853         if (dn_bufp->dtag.global)
5854           add_symbol_to_list (sym, &global_symbols);
5855         else if (WITHIN_FUNCTION (objfile))
5856           add_symbol_to_list (sym, &local_symbols);
5857         else
5858           add_symbol_to_list (sym, &file_symbols);
5859
5860         /* If this is a C++ class, then we additionally
5861          * need to define a typedef for the
5862          * class type. E.g., so that the name "c" becomes visible as
5863          * a type name when the user says "class c { ... }".
5864          * In order to figure this out, we need to chase down the "type"
5865          * field to get to the DNTT_TYPE_CLASS record.
5866          *
5867          * We also add the typename for ENUM. Though this isn't
5868          * strictly correct, it is necessary because of the debug info
5869          * generated by the aCC compiler, in which we cannot
5870          * distinguish between:
5871          *   enum e { ... };
5872          * and
5873          *   typedef enum { ... } e;
5874          * I.e., the compiler emits the same debug info for the above
5875          * two cases, in both cases "e" appearing as a tagdef.
5876          * Therefore go ahead and generate the typename so that
5877          * "ptype e" will work in the above cases.
5878          *
5879          * We also add the typename for TEMPLATE, so as to allow "ptype t"
5880          * when "t" is a template name.
5881          */
5882         if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
5883           dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
5884         else
5885           {
5886             complaint (&symfile_complaints, "error processing class tagdef");
5887             return;
5888           }
5889         if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
5890             dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
5891             dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
5892           {
5893             struct symbol *newsym;
5894
5895             newsym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
5896                                                     sizeof (struct symbol));
5897             memset (newsym, 0, sizeof (struct symbol));
5898             DEPRECATED_SYMBOL_NAME (newsym) = name;
5899             SYMBOL_LANGUAGE (newsym) = language_auto;
5900             SYMBOL_DOMAIN (newsym) = VAR_DOMAIN;
5901             SYMBOL_LINE (newsym) = 0;
5902             SYMBOL_VALUE (newsym) = 0;
5903             SYMBOL_CLASS (newsym) = LOC_TYPEDEF;
5904             SYMBOL_TYPE (newsym) = sym->type;
5905             if (global)
5906               add_symbol_to_list (newsym, &global_symbols);
5907             else if (WITHIN_FUNCTION (objfile))
5908               add_symbol_to_list (newsym, &local_symbols);
5909             else
5910               add_symbol_to_list (newsym, &file_symbols);
5911           }
5912       }
5913       break;
5914
5915     case DNTT_TYPE_POINTER:
5916       /* Declares a pointer type. Should not be necessary to do anything
5917        * with the type at this level; these are processed
5918        * at the hpread_type_lookup() level.
5919        */
5920       break;
5921
5922     case DNTT_TYPE_ENUM:
5923       /* Declares an enum type. Should not be necessary to do anything
5924        * with the type at this level; these are processed
5925        * at the hpread_type_lookup() level.
5926        */
5927       break;
5928
5929     case DNTT_TYPE_MEMENUM:
5930       /* Member of enum */
5931       /* Ignored at this level, but hpread_read_enum_type() will take
5932        * care of walking the list of enumeration members.
5933        */
5934       break;
5935
5936     case DNTT_TYPE_SET:
5937       /* Declares a set type. Should not be necessary to do anything
5938        * with the type at this level; these are processed
5939        * at the hpread_type_lookup() level.
5940        */
5941       break;
5942
5943     case DNTT_TYPE_SUBRANGE:
5944       /* Declares a subrange type. Should not be necessary to do anything
5945        * with the type at this level; these are processed
5946        * at the hpread_type_lookup() level.
5947        */
5948       break;
5949
5950     case DNTT_TYPE_ARRAY:
5951       /* Declares an array type. Should not be necessary to do anything
5952        * with the type at this level; these are processed
5953        * at the hpread_type_lookup() level.
5954        */
5955       break;
5956
5957     case DNTT_TYPE_STRUCT:
5958     case DNTT_TYPE_UNION:
5959       /* Declares an struct/union type.
5960        * Should not be necessary to do anything
5961        * with the type at this level; these are processed
5962        * at the hpread_type_lookup() level.
5963        */
5964       break;
5965
5966     case DNTT_TYPE_FIELD:
5967       /* Structure/union/class field */
5968       /* Ignored at this level, but hpread_read_struct_type() will take
5969        * care of walking the list of structure/union/class members.
5970        */
5971       break;
5972
5973       /* DNTT_TYPE_VARIANT is not handled by GDB */
5974
5975       /* DNTT_TYPE_FILE is not handled by GDB */
5976
5977     case DNTT_TYPE_FUNCTYPE:
5978       /* Function type */
5979       /* Ignored at this level, handled within hpread_type_lookup() */
5980       break;
5981
5982     case DNTT_TYPE_WITH:
5983       /* This is emitted within methods to indicate "with <class>"
5984        * scoping rules (i.e., indicate that the class data members
5985        * are directly visible).
5986        * However, since GDB already infers this by looking at the
5987        * "this" argument, interpreting the DNTT_TYPE_WITH
5988        * symbol record is unnecessary.
5989        */
5990       break;
5991
5992     case DNTT_TYPE_COMMON:
5993       /* FORTRAN common. Not yet handled. */
5994       complaint (&symfile_complaints,
5995                  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.");
5996       break;
5997
5998       /* DNTT_TYPE_COBSTRUCT is not handled by GDB.  */
5999       /* DNTT_TYPE_XREF is not handled by GDB.  */
6000       /* DNTT_TYPE_SA is not handled by GDB.  */
6001       /* DNTT_TYPE_MACRO is not handled by GDB */
6002
6003     case DNTT_TYPE_BLOCKDATA:
6004       /* Not sure what this is - part of FORTRAN support maybe?
6005        * Anyway, not yet handled.
6006        */
6007       complaint (&symfile_complaints,
6008                  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.");
6009       break;
6010
6011     case DNTT_TYPE_CLASS_SCOPE:
6012
6013
6014
6015       /* The compiler brackets member functions with a CLASS_SCOPE/END
6016        * pair of records, presumably to put them in a different scope
6017        * from the module scope where they are normally defined.
6018        * E.g., in the situation:
6019        *   void f() { ... }
6020        *   void c::f() { ...}
6021        * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
6022        * This causes "break f" at the module level to pick the
6023        * the file-level function f(), not the member function
6024        * (which needs to be referenced via "break c::f").
6025        *
6026        * Here we record the class name to generate the demangled names of
6027        * member functions later.
6028        *
6029        * FIXME Not being used now for anything -- cplus_demangle seems
6030        * enough for getting the class-qualified names of functions. We
6031        * may need this for handling nested classes and types.  */
6032
6033       /* pai: FIXME Not handling nested classes for now -- need to
6034        * maintain a stack */
6035
6036       dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile);
6037       if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF)
6038         class_scope_name = VT (objfile) + dn_temp->dtag.name;
6039       else
6040         class_scope_name = NULL;
6041
6042 #if 0
6043
6044       /* Begin a new scope.  */
6045       SL_INDEX (objfile) = hpread_record_lines (current_subfile,
6046                                                 SL_INDEX (objfile),
6047                                               dn_bufp->dclass_scope.address,
6048                                                 objfile, offset);
6049       valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile);
6050       valu += offset;           /* Relocate for dynamic loading */
6051       desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile);
6052       /* We use the scope start DNTT index as the nesting depth identifier! */
6053       new = push_context (desc, valu);
6054 #endif
6055       break;
6056
6057     case DNTT_TYPE_REFERENCE:
6058       /* Declares a C++ reference type. Should not be necessary to do anything
6059        * with the type at this level; these are processed
6060        * at the hpread_type_lookup() level.
6061        */
6062       break;
6063
6064     case DNTT_TYPE_PTRMEM:
6065       /* Declares a C++ pointer-to-data-member type. This does not
6066        * need to be handled at this level; being a type description it
6067        * is instead handled at the hpread_type_lookup() level.
6068        */
6069       break;
6070
6071     case DNTT_TYPE_PTRMEMFUNC:
6072       /* Declares a C++ pointer-to-function-member type. This does not
6073        * need to be handled at this level; being a type description it
6074        * is instead handled at the hpread_type_lookup() level.
6075        */
6076       break;
6077
6078     case DNTT_TYPE_CLASS:
6079       /* Declares a class type.
6080        * Should not be necessary to do anything
6081        * with the type at this level; these are processed
6082        * at the hpread_type_lookup() level.
6083        */
6084       break;
6085
6086     case DNTT_TYPE_GENFIELD:
6087       /* I believe this is used for class member functions */
6088       /* Ignored at this level, but hpread_read_struct_type() will take
6089        * care of walking the list of class members.
6090        */
6091       break;
6092
6093     case DNTT_TYPE_VFUNC:
6094       /* Virtual function */
6095       /* This does not have to be handled at this level; handled in
6096        * the course of processing class symbols.
6097        */
6098       break;
6099
6100     case DNTT_TYPE_MEMACCESS:
6101       /* DDE ignores this symbol table record.
6102        * It has something to do with "modified access" to class members.
6103        * I'll assume we can safely ignore it too.
6104        */
6105       break;
6106
6107     case DNTT_TYPE_INHERITANCE:
6108       /* These don't have to be handled here, since they are handled
6109        * within hpread_read_struct_type() in the process of constructing
6110        * a class type.
6111        */
6112       break;
6113
6114     case DNTT_TYPE_FRIEND_CLASS:
6115     case DNTT_TYPE_FRIEND_FUNC:
6116       /* These can safely be ignored, as GDB doesn't need this
6117        * info. DDE only uses it in "describe". We may later want
6118        * to extend GDB's "ptype" to give this info, but for now
6119        * it seems safe enough to ignore it.
6120        */
6121       break;
6122
6123     case DNTT_TYPE_MODIFIER:
6124       /* Intended to supply "modified access" to a type */
6125       /* From the way DDE handles this, it looks like it always
6126        * modifies a type. Therefore it is safe to ignore it at this
6127        * level, and handle it in hpread_type_lookup().
6128        */
6129       break;
6130
6131     case DNTT_TYPE_OBJECT_ID:
6132       /* Just ignore this - that's all DDE does */
6133       break;
6134
6135     case DNTT_TYPE_MEMFUNC:
6136       /* Member function */
6137       /* This does not have to be handled at this level; handled in
6138        * the course of processing class symbols.
6139        */
6140       break;
6141
6142     case DNTT_TYPE_DOC_MEMFUNC:
6143       /* Member function */
6144       /* This does not have to be handled at this level; handled in
6145        * the course of processing class symbols.
6146        */
6147       break;
6148
6149     case DNTT_TYPE_TEMPLATE:
6150       /* Template - sort of the header for a template definition,
6151        * which like a class, points to a member list and also points
6152        * to a TEMPLATE_ARG list of type-arguments.
6153        * We do not need to process TEMPLATE records at this level though.
6154        */
6155       break;
6156
6157     case DNTT_TYPE_TEMPLATE_ARG:
6158       /* The TEMPLATE record points to an argument list of
6159        * TEMPLATE_ARG records, each of which describes one
6160        * of the type-arguments.
6161        * We do not need to process TEMPLATE_ARG records at this level though.
6162        */
6163       break;
6164
6165     case DNTT_TYPE_FUNC_TEMPLATE:
6166       /* This will get emitted for member functions of templates.
6167        * But we don't need to process this record at this level though,
6168        * we will process it in the course of processing a TEMPLATE
6169        * record.
6170        */
6171       break;
6172
6173     case DNTT_TYPE_LINK:
6174       /* The LINK record is used to link up templates with instantiations. */
6175       /* It is not clear why this is needed, and furthermore aCC does
6176        * not appear to generate this, so I think we can safely ignore it. - RT
6177        */
6178       break;
6179
6180       /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6181       /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6182       /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6183       /* DNTT_TYPE_INLN is not handled by GDB */
6184       /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6185       /* DNTT_TYPE_ALIAS is not handled by GDB */
6186
6187     default:
6188       break;
6189     }
6190 }
6191
6192 /* Get nesting depth for a DNTT entry.
6193  * DN_BUFP points to a DNTT entry.
6194  * OBJFILE is the object file.
6195  * REPORT_NESTED is a flag; if 0, real nesting depth is
6196  * reported, if it is 1, the function simply returns a
6197  * non-zero value if the nesting depth is anything > 0.
6198  *
6199  * Return value is an integer.  0 => not a local type / name
6200  * positive return => type or name is local to some
6201  * block or function.
6202  */
6203
6204
6205 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6206    this function now returns 0 right away. It was taking too much time
6207    at start up. Now, though, the local types are not handled correctly.
6208  */
6209
6210
6211 static int
6212 hpread_get_scope_depth (union dnttentry *dn_bufp, struct objfile *objfile,
6213                         int report_nested)
6214 {
6215   int index;
6216   union dnttentry *dn_tmp;
6217   short depth = 0;
6218 /****************************/
6219   return 0;
6220 /****************************/
6221
6222   index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block));
6223
6224   while (--index >= 0)
6225     {
6226       dn_tmp = hpread_get_lntt (index, objfile);
6227       switch (dn_tmp->dblock.kind)
6228         {
6229         case DNTT_TYPE_MODULE:
6230           return depth;
6231         case DNTT_TYPE_END:
6232           /* index is signed int; dnttp.index is 29-bit unsigned int! */
6233           index = (int) dn_tmp->dend.beginscope.dnttp.index;
6234           break;
6235         case DNTT_TYPE_BEGIN:
6236         case DNTT_TYPE_FUNCTION:
6237         case DNTT_TYPE_DOC_FUNCTION:
6238         case DNTT_TYPE_WITH:
6239         case DNTT_TYPE_COMMON:
6240         case DNTT_TYPE_CLASS_SCOPE:
6241           depth++;
6242           if (report_nested)
6243             return 1;
6244           break;
6245         default:
6246           break;
6247         }
6248     }
6249   return depth;
6250 }
6251
6252 /* Adjust the bitoffsets for all fields of an anonymous union of
6253    type TYPE by negative BITS.  This handles HP aCC's hideous habit
6254    of giving members of anonymous unions bit offsets relative to the
6255    enclosing structure instead of relative to the union itself. */
6256
6257 static void
6258 hpread_adjust_bitoffsets (struct type *type, int bits)
6259 {
6260   int i;
6261
6262   /* This is done only for unions; caller had better check that
6263      it is an anonymous one. */
6264   if (TYPE_CODE (type) != TYPE_CODE_UNION)
6265     return;
6266
6267   /* Adjust each field; since this is a union, there are no base
6268      classes. Also no static membes.  Also, no need for recursion as
6269      the members of this union if themeselves structs or unions, have
6270      the correct bitoffsets; if an anonymous union is a member of this
6271      anonymous union, the code in hpread_read_struct_type() will
6272      adjust for that. */
6273
6274   for (i = 0; i < TYPE_NFIELDS (type); i++)
6275     TYPE_FIELD_BITPOS (type, i) -= bits;
6276 }
6277
6278 /* Return the adjustment necessary to make for addresses on the stack
6279    as presented by hpread.c.
6280
6281    This is necessary because of the stack direction on the PA and the
6282    bizarre way in which someone (?) decided they wanted to handle
6283    frame pointerless code in GDB.  */
6284 int
6285 hpread_adjust_stack_address (CORE_ADDR func_addr)
6286 {
6287   struct unwind_table_entry *u;
6288
6289   u = find_unwind_entry (func_addr);
6290   if (!u)
6291     return 0;
6292   else
6293     return u->Total_frame_size << 3;
6294 }
6295
6296 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6297    classes, we have to chase through a chain of threaded FIELD entries.
6298    If we encounter an anonymous union in the chain, we must recursively skip over
6299    that too.
6300
6301    This function does a "next" in the chain of FIELD entries, but transparently
6302    skips over anonymous unions' fields (recursively).
6303
6304    Inputs are the number of times to do "next" at the top level, the dnttpointer
6305    (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6306    and the ubiquitous objfile parameter. (Note: FIELDP is a **.)  Return value
6307    is a dnttpointer for the new field after all the skipped ones */
6308
6309 static dnttpointer
6310 hpread_get_next_skip_over_anon_unions (int skip_fields, dnttpointer field,
6311                                        union dnttentry **fieldp,
6312                                        struct objfile *objfile)
6313 {
6314   struct type *anon_type;
6315   int i;
6316   int bitoffset;
6317   char *name;
6318
6319   for (i = 0; i < skip_fields; i++)
6320     {
6321       /* Get type of item we're looking at now; recursively processes the types
6322          of these intermediate items we skip over, so they aren't lost. */
6323       anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile);
6324       anon_type = CHECK_TYPEDEF (anon_type);
6325       bitoffset = (*fieldp)->dfield.bitoffset;
6326       name = VT (objfile) + (*fieldp)->dfield.name;
6327       /* First skip over one item to avoid stack death on recursion */
6328       field = (*fieldp)->dfield.nextfield;
6329       *fieldp = hpread_get_lntt (field.dnttp.index, objfile);
6330       /* Do we have another anonymous union? If so, adjust the bitoffsets
6331          of its members and skip over its members. */
6332       if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) &&
6333           (!name || DEPRECATED_STREQ (name, "")))
6334         {
6335           hpread_adjust_bitoffsets (anon_type, bitoffset);
6336           field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile);
6337         }
6338     }
6339   return field;
6340 }