OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [hp-symtab-read.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Read hp debug symbols and convert to internal format, for GDB.
2
   Copyright 1993, 1996 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.
20
 
21
   Written by the Center for Software Science at the University of Utah
22
   and by Cygnus Support.  */
23
 
24
/* Common include for hp-symtab-read.c and hp-psymtab-read.c.
25
 * Note this has nested includes for a bunch of stuff.
26
 */
27
#include "defs.h"
28
#include "symtab.h"
29
#include "gdbtypes.h"
30
#include "hpread.h"
31
#include "demangle.h"
32
#include "complaints.h"
33
 
34
 
35
 
36
 
37
static struct complaint hpread_unhandled_end_common_complaint =
38
{
39
  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n", 0, 0
40
};
41
 
42
static struct complaint hpread_unhandled_type_complaint =
43
{
44
  "hpread_type_translate: unhandled type code.", 0, 0
45
};
46
 
47
static struct complaint hpread_struct_complaint =
48
{
49
  "hpread_read_struct_type: expected SVAR type...", 0, 0
50
};
51
 
52
static struct complaint hpread_array_complaint =
53
{
54
  "error in hpread_array_type.", 0, 0
55
};
56
 
57
static struct complaint hpread_type_lookup_complaint =
58
{
59
  "error in hpread_type_lookup().", 0, 0
60
};
61
 
62
 
63
static struct complaint hpread_unexpected_end_complaint =
64
{
65
  "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.", 0, 0
66
};
67
 
68
static struct complaint hpread_tagdef_complaint =
69
{
70
  "error processing class tagdef", 0, 0
71
};
72
 
73
static struct complaint hpread_unhandled_common_complaint =
74
{
75
  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.", 0, 0
76
};
77
 
78
static struct complaint hpread_unhandled_blockdata_complaint =
79
{
80
  "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.", 0, 0
81
};
82
 
83
 
84
/* Forward procedure declarations */
85
 
86
static unsigned long hpread_get_scope_start
87
  PARAMS ((sltpointer, struct objfile *));
88
 
89
static unsigned long hpread_get_line
90
  PARAMS ((sltpointer, struct objfile *));
91
 
92
static CORE_ADDR hpread_get_location
93
  PARAMS ((sltpointer, struct objfile *));
94
 
95
static void hpread_psymtab_to_symtab_1
96
  PARAMS ((struct partial_symtab *));
97
 
98
void hpread_psymtab_to_symtab
99
  PARAMS ((struct partial_symtab *));
100
 
101
static struct symtab *hpread_expand_symtab
102
  PARAMS ((struct objfile *, int, int, CORE_ADDR, int,
103
           struct section_offsets *, char *));
104
 
105
static int hpread_type_translate
106
  PARAMS ((dnttpointer));
107
 
108
static struct type **hpread_lookup_type
109
  PARAMS ((dnttpointer, struct objfile *));
110
 
111
static struct type *hpread_alloc_type
112
  PARAMS ((dnttpointer, struct objfile *));
113
 
114
static struct type *hpread_read_enum_type
115
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *));
116
 
117
static struct type *hpread_read_function_type
118
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *, int));
119
 
120
static struct type *hpread_read_doc_function_type
121
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *, int));
122
 
123
static struct type *hpread_read_struct_type
124
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *));
125
 
126
static struct type *hpread_get_nth_template_arg
127
  PARAMS ((struct objfile *, int));
128
 
129
static struct type *hpread_read_templ_arg_type
130
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *, char *));
131
 
132
static struct type *hpread_read_set_type
133
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *));
134
 
135
static struct type *hpread_read_array_type
136
  PARAMS ((dnttpointer, union dnttentry * dn_bufp, struct objfile * objfile));
137
 
138
static struct type *hpread_read_subrange_type
139
  PARAMS ((dnttpointer, union dnttentry *, struct objfile *));
140
 
141
static struct type *hpread_type_lookup
142
  PARAMS ((dnttpointer, struct objfile *));
143
 
144
static sltpointer hpread_record_lines
145
  PARAMS ((struct subfile *, sltpointer, sltpointer,
146
           struct objfile *, CORE_ADDR));
147
 
148
static void hpread_process_one_debug_symbol
149
  PARAMS ((union dnttentry *, char *, struct section_offsets *,
150
           struct objfile *, CORE_ADDR, int, char *, int, int *));
151
 
152
static int hpread_get_scope_depth
153
  PARAMS ((union dnttentry *, struct objfile *, int));
154
 
155
static void fix_static_member_physnames
156
  PARAMS ((struct type *, char *, struct objfile *));
157
 
158
static void fixup_class_method_type
159
  PARAMS ((struct type *, struct type *, struct objfile *));
160
 
161
static void hpread_adjust_bitoffsets PARAMS ((struct type *, int));
162
 
163
static dnttpointer hpread_get_next_skip_over_anon_unions
164
  PARAMS ((int, dnttpointer, union dnttentry **, struct objfile *));
165
 
166
/* Global to indicate presence of HP-compiled objects,
167
   in particular, SOM executable file with SOM debug info
168
   Defined in symtab.c, used in hppa-tdep.c. */
169
extern int hp_som_som_object_present;
170
 
171
/* Static used to indicate a class type that requires a
172
   fix-up of one of its method types */
173
static struct type *fixup_class = NULL;
174
 
175
/* Static used to indicate the method type that is to be
176
   used to fix-up the type for fixup_class */
177
static struct type *fixup_method = NULL;
178
 
179
 
180
 
181
/* Get the nesting depth for the source line identified by INDEX.  */
182
 
183
static unsigned long
184
hpread_get_scope_start (index, objfile)
185
     sltpointer index;
186
     struct objfile *objfile;
187
{
188
  union sltentry *sl_bufp;
189
 
190
  sl_bufp = hpread_get_slt (index, objfile);
191
  return sl_bufp->sspec.backptr.dnttp.index;
192
}
193
 
194
/* Get the source line number the the line identified by INDEX.  */
195
 
196
static unsigned long
197
hpread_get_line (index, objfile)
198
     sltpointer index;
199
     struct objfile *objfile;
200
{
201
  union sltentry *sl_bufp;
202
 
203
  sl_bufp = hpread_get_slt (index, objfile);
204
  return sl_bufp->snorm.line;
205
}
206
 
207
/* Find the code address associated with a given sltpointer */
208
 
209
static CORE_ADDR
210
hpread_get_location (index, objfile)
211
     sltpointer index;
212
     struct objfile *objfile;
213
{
214
  union sltentry *sl_bufp;
215
  int i;
216
 
217
  /* code location of special sltentrys is determined from context */
218
  sl_bufp = hpread_get_slt (index, objfile);
219
 
220
  if (sl_bufp->snorm.sltdesc == SLT_END)
221
    {
222
      /* find previous normal sltentry and get address */
223
      for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
224
                   (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
225
                   (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
226
        sl_bufp = hpread_get_slt (index - i, objfile);
227
      if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
228
        return sl_bufp->snormoff.address;
229
      else
230
        return sl_bufp->snorm.address;
231
    }
232
 
233
  /* find next normal sltentry and get address */
234
  for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
235
               (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
236
               (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
237
    sl_bufp = hpread_get_slt (index + i, objfile);
238
  if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
239
    return sl_bufp->snormoff.address;
240
  else
241
    return sl_bufp->snorm.address;
242
}
243
 
244
 
245
/* Return 1 if an HP debug symbol of type KIND has a name associated with
246
 * it, else return 0. (This function is not currently used, but I'll
247
 * leave it here in case it proves useful later on. - RT).
248
 */
249
 
250
int
251
hpread_has_name (kind)
252
     enum dntt_entry_type kind;
253
{
254
  switch (kind)
255
    {
256
    case DNTT_TYPE_SRCFILE:
257
    case DNTT_TYPE_MODULE:
258
    case DNTT_TYPE_FUNCTION:
259
    case DNTT_TYPE_DOC_FUNCTION:
260
    case DNTT_TYPE_ENTRY:
261
    case DNTT_TYPE_IMPORT:
262
    case DNTT_TYPE_LABEL:
263
    case DNTT_TYPE_FPARAM:
264
    case DNTT_TYPE_SVAR:
265
    case DNTT_TYPE_DVAR:
266
    case DNTT_TYPE_CONST:
267
    case DNTT_TYPE_TYPEDEF:
268
    case DNTT_TYPE_TAGDEF:
269
    case DNTT_TYPE_MEMENUM:
270
    case DNTT_TYPE_FIELD:
271
    case DNTT_TYPE_SA:
272
    case DNTT_TYPE_BLOCKDATA:
273
    case DNTT_TYPE_MEMFUNC:
274
    case DNTT_TYPE_DOC_MEMFUNC:
275
      return 1;
276
 
277
    case DNTT_TYPE_BEGIN:
278
    case DNTT_TYPE_END:
279
    case DNTT_TYPE_POINTER:
280
    case DNTT_TYPE_ENUM:
281
    case DNTT_TYPE_SET:
282
    case DNTT_TYPE_ARRAY:
283
    case DNTT_TYPE_STRUCT:
284
    case DNTT_TYPE_UNION:
285
    case DNTT_TYPE_VARIANT:
286
    case DNTT_TYPE_FILE:
287
    case DNTT_TYPE_FUNCTYPE:
288
    case DNTT_TYPE_SUBRANGE:
289
    case DNTT_TYPE_WITH:
290
    case DNTT_TYPE_COMMON:
291
    case DNTT_TYPE_COBSTRUCT:
292
    case DNTT_TYPE_XREF:
293
    case DNTT_TYPE_MACRO:
294
    case DNTT_TYPE_CLASS_SCOPE:
295
    case DNTT_TYPE_REFERENCE:
296
    case DNTT_TYPE_PTRMEM:
297
    case DNTT_TYPE_PTRMEMFUNC:
298
    case DNTT_TYPE_CLASS:
299
    case DNTT_TYPE_GENFIELD:
300
    case DNTT_TYPE_VFUNC:
301
    case DNTT_TYPE_MEMACCESS:
302
    case DNTT_TYPE_INHERITANCE:
303
    case DNTT_TYPE_FRIEND_CLASS:
304
    case DNTT_TYPE_FRIEND_FUNC:
305
    case DNTT_TYPE_MODIFIER:
306
    case DNTT_TYPE_OBJECT_ID:
307
    case DNTT_TYPE_TEMPLATE:
308
    case DNTT_TYPE_TEMPLATE_ARG:
309
    case DNTT_TYPE_FUNC_TEMPLATE:
310
    case DNTT_TYPE_LINK:
311
      /* DNTT_TYPE_DYN_ARRAY_DESC ? */
312
      /* DNTT_TYPE_DESC_SUBRANGE ? */
313
      /* DNTT_TYPE_BEGIN_EXT ? */
314
      /* DNTT_TYPE_INLN ? */
315
      /* DNTT_TYPE_INLN_LIST ? */
316
      /* DNTT_TYPE_ALIAS ? */
317
    default:
318
      return 0;
319
    }
320
}
321
 
322
/* Do the dirty work of reading in the full symbol from a partial symbol
323
   table.  */
324
 
325
static void
326
hpread_psymtab_to_symtab_1 (pst)
327
     struct partial_symtab *pst;
328
{
329
  struct cleanup *old_chain;
330
  int i;
331
 
332
  /* Get out quick if passed junk.  */
333
  if (!pst)
334
    return;
335
 
336
  /* Complain if we've already read in this symbol table.  */
337
  if (pst->readin)
338
    {
339
      fprintf (stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
340
               pst->filename);
341
      return;
342
    }
343
 
344
  /* Read in all partial symtabs on which this one is dependent */
345
  for (i = 0; i < pst->number_of_dependencies; i++)
346
    if (!pst->dependencies[i]->readin)
347
      {
348
        /* Inform about additional files that need to be read in.  */
349
        if (info_verbose)
350
          {
351
            fputs_filtered (" ", gdb_stdout);
352
            wrap_here ("");
353
            fputs_filtered ("and ", gdb_stdout);
354
            wrap_here ("");
355
            printf_filtered ("%s...", pst->dependencies[i]->filename);
356
            wrap_here ("");     /* Flush output */
357
            gdb_flush (gdb_stdout);
358
          }
359
        hpread_psymtab_to_symtab_1 (pst->dependencies[i]);
360
      }
361
 
362
  /* If it's real...  */
363
  if (LDSYMLEN (pst))
364
    {
365
      /* Init stuff necessary for reading in symbols */
366
      buildsym_init ();
367
      old_chain = make_cleanup (really_free_pendings, 0);
368
 
369
      pst->symtab =
370
        hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst),
371
                              pst->textlow, pst->texthigh - pst->textlow,
372
                              pst->section_offsets, pst->filename);
373
      sort_symtab_syms (pst->symtab);
374
 
375
      do_cleanups (old_chain);
376
    }
377
 
378
  pst->readin = 1;
379
}
380
 
381
/* Read in all of the symbols for a given psymtab for real.
382
   Be verbose about it if the user wants that.  */
383
 
384
void
385
hpread_psymtab_to_symtab (pst)
386
     struct partial_symtab *pst;
387
{
388
  /* Get out quick if given junk.  */
389
  if (!pst)
390
    return;
391
 
392
  /* Sanity check.  */
393
  if (pst->readin)
394
    {
395
      fprintf (stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
396
               pst->filename);
397
      return;
398
    }
399
 
400
  /* elz: setting the flag to indicate that the code of the target
401
     was compiled using an HP compiler (aCC, cc)
402
     the processing_acc_compilation variable is declared in the
403
     file buildsym.h, the HP_COMPILED_TARGET is defined to be equal
404
     to 3 in the file tm_hppa.h */
405
 
406
  processing_gcc_compilation = 0;
407
 
408
  if (LDSYMLEN (pst) || pst->number_of_dependencies)
409
    {
410
      /* Print the message now, before reading the string table,
411
         to avoid disconcerting pauses.  */
412
      if (info_verbose)
413
        {
414
          printf_filtered ("Reading in symbols for %s...", pst->filename);
415
          gdb_flush (gdb_stdout);
416
        }
417
 
418
      hpread_psymtab_to_symtab_1 (pst);
419
 
420
      /* Match with global symbols.  This only needs to be done once,
421
         after all of the symtabs and dependencies have been read in.   */
422
      scan_file_globals (pst->objfile);
423
 
424
      /* Finish up the debug error message.  */
425
      if (info_verbose)
426
        printf_filtered ("done.\n");
427
    }
428
}
429
 
430
/* Read in a defined section of a specific object file's symbols.
431
 
432
   DESC is the file descriptor for the file, positioned at the
433
   beginning of the symtab
434
   SYM_OFFSET is the offset within the file of
435
   the beginning of the symbols we want to read
436
   SYM_SIZE is the size of the symbol info to read in.
437
   TEXT_OFFSET is the beginning of the text segment we are reading symbols for
438
   TEXT_SIZE is the size of the text segment read in.
439
   SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
440
 
441
static struct symtab *
442
hpread_expand_symtab (objfile, sym_offset, sym_size, text_offset, text_size,
443
                      section_offsets, filename)
444
     struct objfile *objfile;
445
     int sym_offset;
446
     int sym_size;
447
     CORE_ADDR text_offset;
448
     int text_size;
449
     struct section_offsets *section_offsets;
450
     char *filename;
451
{
452
  char *namestring;
453
  union dnttentry *dn_bufp;
454
  unsigned max_symnum;
455
  int at_module_boundary = 0;
456
  /* 1 => at end, -1 => at beginning */
457
 
458
  int sym_index = sym_offset / sizeof (struct dntt_type_block);
459
 
460
  current_objfile = objfile;
461
  subfile_stack = 0;
462
 
463
  last_source_file = 0;
464
 
465
  /* Demangling style -- if EDG style already set, don't change it,
466
     as HP style causes some problems with the KAI EDG compiler */
467
  if (current_demangling_style != edg_demangling)
468
    {
469
      /* Otherwise, ensure that we are using HP style demangling */
470
      set_demangling_style (HP_DEMANGLING_STYLE_STRING);
471
    }
472
 
473
  dn_bufp = hpread_get_lntt (sym_index, objfile);
474
  if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) ||
475
        (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE)))
476
    {
477
      start_symtab ("globals", NULL, 0);
478
      record_debugformat ("HP");
479
    }
480
 
481
  /* The psymtab builder (hp-psymtab-read.c) is the one that
482
   * determined the "sym_size" argument (i.e. how many DNTT symbols
483
   * are in this symtab), which we use to compute "max_symnum"
484
   * (point in DNTT to which we read).
485
   *
486
   * Perhaps this should be changed so that
487
   * process_one_debug_symbol() "knows" when
488
   * to stop reading (based on reading from the MODULE to the matching
489
   * END), and take out this reliance on a #-syms being passed in...
490
   * (I'm worried about the reliability of this number). But I'll
491
   * leave it as-is, for now. - RT
492
   *
493
   * The change above has been made. I've left the "for" loop control
494
   * in to prepare for backing this out again. -JB
495
   */
496
  max_symnum = sym_size / sizeof (struct dntt_type_block);
497
  /* No reason to multiply on pst side and divide on sym side... FIXME */
498
 
499
  /* Read in and process each debug symbol within the specified range.
500
   */
501
  for (symnum = 0;
502
       symnum < max_symnum;
503
       symnum++)
504
    {
505
      QUIT;                     /* Allow this to be interruptable */
506
      dn_bufp = hpread_get_lntt (sym_index + symnum, objfile);
507
 
508
      if (dn_bufp->dblock.extension)
509
        continue;
510
 
511
      /* Yow!  We call SET_NAMESTRING on things without names!  */
512
      SET_NAMESTRING (dn_bufp, &namestring, objfile);
513
 
514
      hpread_process_one_debug_symbol (dn_bufp, namestring, section_offsets,
515
                                       objfile, text_offset, text_size,
516
                                       filename, symnum + sym_index,
517
                                       &at_module_boundary
518
        );
519
 
520
      /* OLD COMMENTS: This routine is only called for psts.  All psts
521
       * correspond to MODULES.  If we ever do lazy-reading of globals
522
       * from the LNTT, then there will be a pst which ends when the
523
       * LNTT ends, and not at an END MODULE entry.  Then we'll have
524
       * to re-visit this break.
525
 
526
       if( at_end_of_module )
527
       break;
528
 
529
       */
530
 
531
      /* We no longer break out of the loop when we reach the end of a
532
         module. The reason is that with CTTI, the compiler can generate
533
         function symbols (for template function instantiations) which are not
534
         in any module; typically they show up beyond a module's end, and
535
         before the next module's start.  We include them in the current
536
         module.  However, we still don't trust the MAX_SYMNUM value from
537
         the psymtab, so we break out if we enter a new module. */
538
 
539
      if (at_module_boundary == -1)
540
        break;
541
    }
542
 
543
  current_objfile = NULL;
544
  hp_som_som_object_present = 1;        /* Indicate we've processed an HP SOM SOM file */
545
 
546
  return end_symtab (text_offset + text_size, objfile, 0);
547
}
548
 
549
 
550
 
551
 
552
/* Convert basic types from HP debug format into GDB internal format.  */
553
 
554
static int
555
hpread_type_translate (typep)
556
     dnttpointer typep;
557
{
558
  if (!typep.dntti.immediate)
559
    {
560
      error ("error in hpread_type_translate\n.");
561
      return;
562
    }
563
 
564
  switch (typep.dntti.type)
565
    {
566
    case HP_TYPE_BOOLEAN:
567
    case HP_TYPE_BOOLEAN_S300_COMPAT:
568
    case HP_TYPE_BOOLEAN_VAX_COMPAT:
569
      return FT_BOOLEAN;
570
    case HP_TYPE_CHAR:          /* C signed char, C++ plain char */
571
 
572
    case HP_TYPE_WIDE_CHAR:
573
      return FT_CHAR;
574
    case HP_TYPE_INT:
575
      if (typep.dntti.bitlength <= 8)
576
        return FT_SIGNED_CHAR;  /* C++ signed char */
577
      if (typep.dntti.bitlength <= 16)
578
        return FT_SHORT;
579
      if (typep.dntti.bitlength <= 32)
580
        return FT_INTEGER;
581
      return FT_LONG_LONG;
582
    case HP_TYPE_LONG:
583
      if (typep.dntti.bitlength <= 8)
584
        return FT_SIGNED_CHAR;  /* C++ signed char. */
585
      return FT_LONG;
586
    case HP_TYPE_UNSIGNED_LONG:
587
      if (typep.dntti.bitlength <= 8)
588
        return FT_UNSIGNED_CHAR;        /* C/C++ unsigned char */
589
      if (typep.dntti.bitlength <= 16)
590
        return FT_UNSIGNED_SHORT;
591
      if (typep.dntti.bitlength <= 32)
592
        return FT_UNSIGNED_LONG;
593
      return FT_UNSIGNED_LONG_LONG;
594
    case HP_TYPE_UNSIGNED_INT:
595
      if (typep.dntti.bitlength <= 8)
596
        return FT_UNSIGNED_CHAR;
597
      if (typep.dntti.bitlength <= 16)
598
        return FT_UNSIGNED_SHORT;
599
      if (typep.dntti.bitlength <= 32)
600
        return FT_UNSIGNED_INTEGER;
601
      return FT_UNSIGNED_LONG_LONG;
602
    case HP_TYPE_REAL:
603
    case HP_TYPE_REAL_3000:
604
    case HP_TYPE_DOUBLE:
605
      if (typep.dntti.bitlength == 64)
606
        return FT_DBL_PREC_FLOAT;
607
      if (typep.dntti.bitlength == 128)
608
        return FT_EXT_PREC_FLOAT;
609
      return FT_FLOAT;
610
    case HP_TYPE_COMPLEX:
611
    case HP_TYPE_COMPLEXS3000:
612
      if (typep.dntti.bitlength == 128)
613
        return FT_DBL_PREC_COMPLEX;
614
      if (typep.dntti.bitlength == 192)
615
        return FT_EXT_PREC_COMPLEX;
616
      return FT_COMPLEX;
617
    case HP_TYPE_VOID:
618
      return FT_VOID;
619
    case HP_TYPE_STRING200:
620
    case HP_TYPE_LONGSTRING200:
621
    case HP_TYPE_FTN_STRING_SPEC:
622
    case HP_TYPE_MOD_STRING_SPEC:
623
    case HP_TYPE_MOD_STRING_3000:
624
    case HP_TYPE_FTN_STRING_S300_COMPAT:
625
    case HP_TYPE_FTN_STRING_VAX_COMPAT:
626
      return FT_STRING;
627
    case HP_TYPE_TEMPLATE_ARG:
628
      return FT_TEMPLATE_ARG;
629
    case HP_TYPE_TEXT:
630
    case HP_TYPE_FLABEL:
631
    case HP_TYPE_PACKED_DECIMAL:
632
    case HP_TYPE_ANYPOINTER:
633
    case HP_TYPE_GLOBAL_ANYPOINTER:
634
    case HP_TYPE_LOCAL_ANYPOINTER:
635
    default:
636
      warning ("hpread_type_translate: unhandled type code.\n");
637
      return FT_VOID;
638
    }
639
}
640
 
641
/* Given a position in the DNTT, return a pointer to the
642
 * already-built "struct type" (if any), for the type defined
643
 * at that position.
644
 */
645
 
646
static struct type **
647
hpread_lookup_type (hp_type, objfile)
648
     dnttpointer hp_type;
649
     struct objfile *objfile;
650
{
651
  unsigned old_len;
652
  int index = hp_type.dnttp.index;
653
  int size_changed = 0;
654
 
655
  /* The immediate flag indicates this doesn't actually point to
656
   * a type DNTT.
657
   */
658
  if (hp_type.dntti.immediate)
659
    return NULL;
660
 
661
  /* For each objfile, we maintain a "type vector".
662
   * This an array of "struct type *"'s with one pointer per DNTT index.
663
   * Given a DNTT index, we look in this array to see if we have
664
   * already processed this DNTT and if it is a type definition.
665
   * If so, then we can locate a pointer to the already-built
666
   * "struct type", and not build it again.
667
   *
668
   * The need for this arises because our DNTT-walking code wanders
669
   * around. In particular, it will encounter the same type multiple
670
   * times (once for each object of that type). We don't want to
671
   * built multiple "struct type"'s for the same thing.
672
   *
673
   * Having said this, I should point out that this type-vector is
674
   * an expensive way to keep track of this. If most DNTT entries are
675
   * 3 words, the type-vector will be 1/3 the size of the DNTT itself.
676
   * Alternative solutions:
677
   * - Keep a compressed or hashed table. Less memory, but more expensive
678
   *   to search and update.
679
   * - (Suggested by JB): Overwrite the DNTT entry itself
680
   *   with the info. Create a new type code "ALREADY_BUILT", and modify
681
   *   the DNTT to have that type code and point to the already-built entry.
682
   * -RT
683
   */
684
 
685
  if (index < LNTT_SYMCOUNT (objfile))
686
    {
687
      if (index >= TYPE_VECTOR_LENGTH (objfile))
688
        {
689
          old_len = TYPE_VECTOR_LENGTH (objfile);
690
 
691
          /* See if we need to allocate a type-vector. */
692
          if (old_len == 0)
693
            {
694
              TYPE_VECTOR_LENGTH (objfile) = LNTT_SYMCOUNT (objfile) + GNTT_SYMCOUNT (objfile);
695
              TYPE_VECTOR (objfile) = (struct type **)
696
                xmmalloc (objfile->md, TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *));
697
              memset (&TYPE_VECTOR (objfile)[old_len], 0,
698
                      (TYPE_VECTOR_LENGTH (objfile) - old_len) *
699
                      sizeof (struct type *));
700
            }
701
 
702
          /* See if we need to resize type-vector. With my change to
703
           * initially allocate a correct-size type-vector, this code
704
           * should no longer trigger.
705
           */
706
          while (index >= TYPE_VECTOR_LENGTH (objfile))
707
            {
708
              TYPE_VECTOR_LENGTH (objfile) *= 2;
709
              size_changed = 1;
710
            }
711
          if (size_changed)
712
            {
713
              TYPE_VECTOR (objfile) = (struct type **)
714
                xmrealloc (objfile->md,
715
                           (char *) TYPE_VECTOR (objfile),
716
                   (TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
717
 
718
              memset (&TYPE_VECTOR (objfile)[old_len], 0,
719
                      (TYPE_VECTOR_LENGTH (objfile) - old_len) *
720
                      sizeof (struct type *));
721
            }
722
 
723
        }
724
      return &TYPE_VECTOR (objfile)[index];
725
    }
726
  else
727
    return NULL;
728
}
729
 
730
/* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
731
   Note we'll just return the address of a GDB internal type if we already
732
   have it lying around.  */
733
 
734
static struct type *
735
hpread_alloc_type (hp_type, objfile)
736
     dnttpointer hp_type;
737
     struct objfile *objfile;
738
{
739
  struct type **type_addr;
740
 
741
  type_addr = hpread_lookup_type (hp_type, objfile);
742
  if (*type_addr == 0)
743
    {
744
      *type_addr = alloc_type (objfile);
745
 
746
      /* A hack - if we really are a C++ class symbol, then this default
747
       * will get overriden later on.
748
       */
749
      TYPE_CPLUS_SPECIFIC (*type_addr)
750
        = (struct cplus_struct_type *) &cplus_struct_default;
751
    }
752
 
753
  return *type_addr;
754
}
755
 
756
/* Read a native enumerated type and return it in GDB internal form.  */
757
 
758
static struct type *
759
hpread_read_enum_type (hp_type, dn_bufp, objfile)
760
     dnttpointer hp_type;
761
     union dnttentry *dn_bufp;
762
     struct objfile *objfile;
763
{
764
  struct type *type;
765
  struct pending **symlist, *osyms, *syms;
766
  struct pending *local_list = NULL;
767
  int o_nsyms, nsyms = 0;
768
  dnttpointer mem;
769
  union dnttentry *memp;
770
  char *name;
771
  long n;
772
  struct symbol *sym;
773
 
774
  /* Allocate a GDB type. If we've already read in this enum type,
775
   * it'll return the already built GDB type, so stop here.
776
   * (Note: I added this check, to conform with what's done for
777
   *  struct, union, class.
778
   *  I assume this is OK. - RT)
779
   */
780
  type = hpread_alloc_type (hp_type, objfile);
781
  if (TYPE_CODE (type) == TYPE_CODE_ENUM)
782
    return type;
783
 
784
  /* HP C supports "sized enums", where a specifier such as "short" or
785
     "char" can be used to get enums of different sizes. So don't assume
786
     an enum is always 4 bytes long. pai/1997-08-21 */
787
  TYPE_LENGTH (type) = dn_bufp->denum.bitlength / 8;
788
 
789
  symlist = &file_symbols;
790
  osyms = *symlist;
791
  o_nsyms = osyms ? osyms->nsyms : 0;
792
 
793
  /* Get a name for each member and add it to our list of members.
794
   * The list of "mem" SOM records we are walking should all be
795
   * SOM type DNTT_TYPE_MEMENUM (not checked).
796
   */
797
  mem = dn_bufp->denum.firstmem;
798
  while (mem.word && mem.word != DNTTNIL)
799
    {
800
      memp = hpread_get_lntt (mem.dnttp.index, objfile);
801
 
802
      name = VT (objfile) + memp->dmember.name;
803
      sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
804
                                             sizeof (struct symbol));
805
      memset (sym, 0, sizeof (struct symbol));
806
      SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
807
                                        &objfile->symbol_obstack);
808
      SYMBOL_CLASS (sym) = LOC_CONST;
809
      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
810
      SYMBOL_VALUE (sym) = memp->dmember.value;
811
      add_symbol_to_list (sym, symlist);
812
      nsyms++;
813
      mem = memp->dmember.nextmem;
814
    }
815
 
816
  /* Now that we know more about the enum, fill in more info.  */
817
  TYPE_CODE (type) = TYPE_CODE_ENUM;
818
  TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
819
  TYPE_NFIELDS (type) = nsyms;
820
  TYPE_FIELDS (type) = (struct field *)
821
    obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nsyms);
822
 
823
  /* Find the symbols for the members and put them into the type.
824
     The symbols can be found in the symlist that we put them on
825
     to cause them to be defined.  osyms contains the old value
826
     of that symlist; everything up to there was defined by us.
827
 
828
     Note that we preserve the order of the enum constants, so
829
     that in something like "enum {FOO, LAST_THING=FOO}" we print
830
     FOO, not LAST_THING.  */
831
  for (syms = *symlist, n = 0; syms; syms = syms->next)
832
    {
833
      int j = 0;
834
      if (syms == osyms)
835
        j = o_nsyms;
836
      for (; j < syms->nsyms; j++, n++)
837
        {
838
          struct symbol *xsym = syms->symbol[j];
839
          SYMBOL_TYPE (xsym) = type;
840
          TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
841
          TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
842
          TYPE_FIELD_BITSIZE (type, n) = 0;
843
        }
844
      if (syms == osyms)
845
        break;
846
    }
847
 
848
  return type;
849
}
850
 
851
/* Read and internalize a native function debug symbol.  */
852
 
853
static struct type *
854
hpread_read_function_type (hp_type, dn_bufp, objfile, newblock)
855
     dnttpointer hp_type;
856
     union dnttentry *dn_bufp;
857
     struct objfile *objfile;
858
     int newblock;
859
{
860
  struct type *type, *type1;
861
  struct pending *syms;
862
  struct pending *local_list = NULL;
863
  int nsyms = 0;
864
  dnttpointer param;
865
  union dnttentry *paramp;
866
  char *name;
867
  long n;
868
  struct symbol *sym;
869
  int record_args = 1;
870
 
871
  /* See if we've already read in this type.  */
872
  type = hpread_alloc_type (hp_type, objfile);
873
  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
874
    {
875
      record_args = 0;           /* already read in, don't modify type */
876
    }
877
  else
878
    {
879
      /* Nope, so read it in and store it away.  */
880
      if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
881
          dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
882
        type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval,
883
                                                          objfile));
884
      else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
885
        type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval,
886
                                                          objfile));
887
      else                      /* expect DNTT_TYPE_FUNC_TEMPLATE */
888
        type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval,
889
                                                          objfile));
890
      memcpy ((char *) type, (char *) type1, sizeof (struct type));
891
 
892
      /* Mark it -- in the middle of processing */
893
      TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
894
    }
895
 
896
  /* Now examine each parameter noting its type, location, and a
897
     wealth of other information.  */
898
  if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
899
      dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
900
    param = dn_bufp->dfunc.firstparam;
901
  else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
902
    param = dn_bufp->dfunctype.firstparam;
903
  else                          /* expect DNTT_TYPE_FUNC_TEMPLATE */
904
    param = dn_bufp->dfunc_template.firstparam;
905
  while (param.word && param.word != DNTTNIL)
906
    {
907
      paramp = hpread_get_lntt (param.dnttp.index, objfile);
908
      nsyms++;
909
      param = paramp->dfparam.nextparam;
910
 
911
      /* Get the name.  */
912
      name = VT (objfile) + paramp->dfparam.name;
913
      sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
914
                                             sizeof (struct symbol));
915
      (void) memset (sym, 0, sizeof (struct symbol));
916
      SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
917
                                        &objfile->symbol_obstack);
918
 
919
      /* Figure out where it lives.  */
920
      if (paramp->dfparam.regparam)
921
        SYMBOL_CLASS (sym) = LOC_REGPARM;
922
      else if (paramp->dfparam.indirect)
923
        SYMBOL_CLASS (sym) = LOC_REF_ARG;
924
      else
925
        SYMBOL_CLASS (sym) = LOC_ARG;
926
      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
927
      if (paramp->dfparam.copyparam)
928
        {
929
          SYMBOL_VALUE (sym) = paramp->dfparam.location;
930
#ifdef HPREAD_ADJUST_STACK_ADDRESS
931
          SYMBOL_VALUE (sym)
932
            += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
933
#endif
934
          /* This is likely a pass-by-invisible reference parameter,
935
             Hack on the symbol class to make GDB happy.  */
936
          /* ??rehrauer: This appears to be broken w/r/t to passing
937
             C values of type float and struct.  Perhaps this ought
938
             to be highighted as a special case, but for now, just
939
             allowing these to be LOC_ARGs seems to work fine.
940
           */
941
#if 0
942
          SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
943
#endif
944
        }
945
      else
946
        SYMBOL_VALUE (sym) = paramp->dfparam.location;
947
 
948
      /* Get its type.  */
949
      SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
950
      /* Add it to the symbol list.  */
951
      /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
952
       * called on FPARAM symbols from the process_one_debug_symbol()
953
       * level... so parameters are getting added twice! (this shows
954
       * up in the symbol dump you get from "maint print symbols ...").
955
       * Note 2 (RT) I took out the processing of FPARAM from the
956
       * process_one_debug_symbol() level, so at the moment parameters are only
957
       * being processed here. This seems to have no ill effect.
958
       */
959
      /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
960
         each fparam on the local_symbols list from here.  Now we use the
961
         local_list to which fparams are added below, and set the param_symbols
962
         global to point to that at the end of this routine. */
963
      /* elz: I added this new list of symbols which is local to the function.
964
         this list is the one which is actually used to build the type for the
965
         function rather than the gloabal list pointed to by symlist.
966
         Using a global list to keep track of the parameters is wrong, because
967
         this function is called recursively if one parameter happend to be
968
         a function itself with more parameters in it. Adding parameters to the
969
         same global symbol list would not work!
970
         Actually it did work in case of cc compiled programs where you do
971
         not check the parameter lists of the arguments. */
972
      add_symbol_to_list (sym, &local_list);
973
 
974
    }
975
 
976
  /* If type was read in earlier, don't bother with modifying
977
     the type struct */
978
  if (!record_args)
979
    goto finish;
980
 
981
  /* Note how many parameters we found.  */
982
  TYPE_NFIELDS (type) = nsyms;
983
  TYPE_FIELDS (type) = (struct field *)
984
    obstack_alloc (&objfile->type_obstack,
985
                   sizeof (struct field) * nsyms);
986
 
987
  /* Find the symbols for the parameters and
988
     use them to fill parameter-type information into the function-type.
989
     The parameter symbols can be found in the local_list that we just put them on. */
990
  /* Note that we preserve the order of the parameters, so
991
     that in something like "enum {FOO, LAST_THING=FOO}" we print
992
     FOO, not LAST_THING.  */
993
 
994
  /* get the parameters types from the local list not the global list
995
     so that the type can be correctly constructed for functions which
996
     have function as parameters */
997
  for (syms = local_list, n = 0; syms; syms = syms->next)
998
    {
999
      int j = 0;
1000
      for (j = 0; j < syms->nsyms; j++, n++)
1001
        {
1002
          struct symbol *xsym = syms->symbol[j];
1003
          TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
1004
          TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
1005
          TYPE_FIELD_BITPOS (type, n) = n;
1006
          TYPE_FIELD_BITSIZE (type, n) = 0;
1007
        }
1008
    }
1009
  /* Mark it as having been processed */
1010
  TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
1011
 
1012
  /* Check whether we need to fix-up a class type with this function's type */
1013
  if (fixup_class && (fixup_method == type))
1014
    {
1015
      fixup_class_method_type (fixup_class, fixup_method, objfile);
1016
      fixup_class = NULL;
1017
      fixup_method = NULL;
1018
    }
1019
 
1020
  /* Set the param list of this level of the context stack
1021
     to our local list.  Do this only if this function was
1022
     called for creating a new block, and not if it was called
1023
     simply to get the function type. This prevents recursive
1024
     invocations from trashing param_symbols. */
1025
finish:
1026
  if (newblock)
1027
    param_symbols = local_list;
1028
 
1029
  return type;
1030
}
1031
 
1032
 
1033
/* Read and internalize a native DOC function debug symbol.  */
1034
/* This is almost identical to hpread_read_function_type(), except
1035
 * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
1036
 * Since debug information for DOC functions is more likely to be
1037
 * volatile, please leave it this way.
1038
 */
1039
static struct type *
1040
hpread_read_doc_function_type (hp_type, dn_bufp, objfile, newblock)
1041
     dnttpointer hp_type;
1042
     union dnttentry *dn_bufp;
1043
     struct objfile *objfile;
1044
     int newblock;
1045
{
1046
  struct type *type, *type1;
1047
  struct pending *syms;
1048
  struct pending *local_list = NULL;
1049
  int nsyms = 0;
1050
  dnttpointer param;
1051
  union dnttentry *paramp;
1052
  char *name;
1053
  long n;
1054
  struct symbol *sym;
1055
  int record_args = 1;
1056
 
1057
  /* See if we've already read in this type.  */
1058
  type = hpread_alloc_type (hp_type, objfile);
1059
  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1060
    {
1061
      record_args = 0;           /* already read in, don't modify type */
1062
    }
1063
  else
1064
    {
1065
      /* Nope, so read it in and store it away.  */
1066
      if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
1067
          dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
1068
        type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval,
1069
                                                          objfile));
1070
      memcpy ((char *) type, (char *) type1, sizeof (struct type));
1071
 
1072
      /* Mark it -- in the middle of processing */
1073
      TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
1074
    }
1075
 
1076
  /* Now examine each parameter noting its type, location, and a
1077
     wealth of other information.  */
1078
  if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
1079
      dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
1080
    param = dn_bufp->ddocfunc.firstparam;
1081
  while (param.word && param.word != DNTTNIL)
1082
    {
1083
      paramp = hpread_get_lntt (param.dnttp.index, objfile);
1084
      nsyms++;
1085
      param = paramp->dfparam.nextparam;
1086
 
1087
      /* Get the name.  */
1088
      name = VT (objfile) + paramp->dfparam.name;
1089
      sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1090
                                             sizeof (struct symbol));
1091
      (void) memset (sym, 0, sizeof (struct symbol));
1092
      SYMBOL_NAME (sym) = name;
1093
 
1094
      /* Figure out where it lives.  */
1095
      if (paramp->dfparam.regparam)
1096
        SYMBOL_CLASS (sym) = LOC_REGPARM;
1097
      else if (paramp->dfparam.indirect)
1098
        SYMBOL_CLASS (sym) = LOC_REF_ARG;
1099
      else
1100
        SYMBOL_CLASS (sym) = LOC_ARG;
1101
      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1102
      if (paramp->dfparam.copyparam)
1103
        {
1104
          SYMBOL_VALUE (sym) = paramp->dfparam.location;
1105
#ifdef HPREAD_ADJUST_STACK_ADDRESS
1106
          SYMBOL_VALUE (sym)
1107
            += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
1108
#endif
1109
          /* This is likely a pass-by-invisible reference parameter,
1110
             Hack on the symbol class to make GDB happy.  */
1111
          /* ??rehrauer: This appears to be broken w/r/t to passing
1112
             C values of type float and struct.  Perhaps this ought
1113
             to be highighted as a special case, but for now, just
1114
             allowing these to be LOC_ARGs seems to work fine.
1115
           */
1116
#if 0
1117
          SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
1118
#endif
1119
        }
1120
      else
1121
        SYMBOL_VALUE (sym) = paramp->dfparam.location;
1122
 
1123
      /* Get its type.  */
1124
      SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
1125
      /* Add it to the symbol list.  */
1126
      /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
1127
       * called on FPARAM symbols from the process_one_debug_symbol()
1128
       * level... so parameters are getting added twice! (this shows
1129
       * up in the symbol dump you get from "maint print symbols ...").
1130
       * Note 2 (RT) I took out the processing of FPARAM from the
1131
       * process_one_debug_symbol() level, so at the moment parameters are only
1132
       * being processed here. This seems to have no ill effect.
1133
       */
1134
      /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
1135
         each fparam on the local_symbols list from here.  Now we use the
1136
         local_list to which fparams are added below, and set the param_symbols
1137
         global to point to that at the end of this routine. */
1138
 
1139
      /* elz: I added this new list of symbols which is local to the function.
1140
         this list is the one which is actually used to build the type for the
1141
         function rather than the gloabal list pointed to by symlist.
1142
         Using a global list to keep track of the parameters is wrong, because
1143
         this function is called recursively if one parameter happend to be
1144
         a function itself with more parameters in it. Adding parameters to the
1145
         same global symbol list would not work!
1146
         Actually it did work in case of cc compiled programs where you do not check the
1147
         parameter lists of the arguments.  */
1148
      add_symbol_to_list (sym, &local_list);
1149
    }
1150
 
1151
  /* If type was read in earlier, don't bother with modifying
1152
     the type struct */
1153
  if (!record_args)
1154
    goto finish;
1155
 
1156
  /* Note how many parameters we found.  */
1157
  TYPE_NFIELDS (type) = nsyms;
1158
  TYPE_FIELDS (type) = (struct field *)
1159
    obstack_alloc (&objfile->type_obstack,
1160
                   sizeof (struct field) * nsyms);
1161
 
1162
  /* Find the symbols for the parameters and
1163
     use them to fill parameter-type information into the function-type.
1164
     The parameter symbols can be found in the local_list that we just put them on. */
1165
  /* Note that we preserve the order of the parameters, so
1166
     that in something like "enum {FOO, LAST_THING=FOO}" we print
1167
     FOO, not LAST_THING.  */
1168
 
1169
  /* get the parameters types from the local list not the global list
1170
     so that the type can be correctly constructed for functions which
1171
     have function as parameters
1172
   */
1173
  for (syms = local_list, n = 0; syms; syms = syms->next)
1174
    {
1175
      int j = 0;
1176
      for (j = 0; j < syms->nsyms; j++, n++)
1177
        {
1178
          struct symbol *xsym = syms->symbol[j];
1179
          TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
1180
          TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
1181
          TYPE_FIELD_BITPOS (type, n) = n;
1182
          TYPE_FIELD_BITSIZE (type, n) = 0;
1183
        }
1184
    }
1185
 
1186
  /* Mark it as having been processed */
1187
  TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
1188
 
1189
  /* Check whether we need to fix-up a class type with this function's type */
1190
  if (fixup_class && (fixup_method == type))
1191
    {
1192
      fixup_class_method_type (fixup_class, fixup_method, objfile);
1193
      fixup_class = NULL;
1194
      fixup_method = NULL;
1195
    }
1196
 
1197
  /* Set the param list of this level of the context stack
1198
     to our local list.  Do this only if this function was
1199
     called for creating a new block, and not if it was called
1200
     simply to get the function type. This prevents recursive
1201
     invocations from trashing param_symbols. */
1202
finish:
1203
  if (newblock)
1204
    param_symbols = local_list;
1205
 
1206
  return type;
1207
}
1208
 
1209
 
1210
 
1211
/* A file-level variable which keeps track of the current-template
1212
 * being processed. Set in hpread_read_struct_type() while processing
1213
 * a template type. Referred to in hpread_get_nth_templ_arg().
1214
 * Yes, this is a kludge, but it arises from the kludge that already
1215
 * exists in symtab.h, namely the fact that they encode
1216
 * "template argument n" with fundamental type FT_TEMPLATE_ARG and
1217
 * bitlength n. This means that deep in processing fundamental types
1218
 * I need to ask the question "what template am I in the middle of?".
1219
 * The alternative to stuffing a global would be to pass an argument
1220
 * down the chain of calls just for this purpose.
1221
 *
1222
 * There may be problems handling nested templates... tough.
1223
 */
1224
static struct type *current_template = NULL;
1225
 
1226
/* Read in and internalize a structure definition.
1227
 * This same routine is called for struct, union, and class types.
1228
 * Also called for templates, since they build a very similar
1229
 * type entry as for class types.
1230
 */
1231
 
1232
static struct type *
1233
hpread_read_struct_type (hp_type, dn_bufp, objfile)
1234
     dnttpointer hp_type;
1235
     union dnttentry *dn_bufp;
1236
     struct objfile *objfile;
1237
{
1238
  /* The data members get linked together into a list of struct nextfield's */
1239
  struct nextfield
1240
    {
1241
      struct nextfield *next;
1242
      struct field field;
1243
      unsigned char attributes; /* store visibility and virtuality info */
1244
#define ATTR_VIRTUAL 1
1245
#define ATTR_PRIVATE 2
1246
#define ATTR_PROTECT 3
1247
    };
1248
 
1249
 
1250
  /* The methods get linked together into a list of struct next_fn_field's */
1251
  struct next_fn_field
1252
    {
1253
      struct next_fn_field *next;
1254
      struct fn_fieldlist field;
1255
      struct fn_field fn_field;
1256
      int num_fn_fields;
1257
    };
1258
 
1259
  /* The template args get linked together into a list of struct next_template's */
1260
  struct next_template
1261
    {
1262
      struct next_template *next;
1263
      struct template_arg arg;
1264
    };
1265
 
1266
  /* The template instantiations get linked together into a list of these... */
1267
  struct next_instantiation
1268
    {
1269
      struct next_instantiation *next;
1270
      struct type *t;
1271
    };
1272
 
1273
  struct type *type;
1274
  struct type *baseclass;
1275
  struct type *memtype;
1276
  struct nextfield *list = 0, *tmp_list = 0;
1277
  struct next_fn_field *fn_list = 0;
1278
  struct next_fn_field *fn_p;
1279
  struct next_template *t_new, *t_list = 0;
1280
  struct nextfield *new;
1281
  struct next_fn_field *fn_new;
1282
  struct next_instantiation *i_new, *i_list = 0;
1283
  int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0;
1284
  int n_base_classes = 0, n_templ_args = 0;
1285
  int ninstantiations = 0;
1286
  dnttpointer field, fn_field, parent;
1287
  union dnttentry *fieldp, *fn_fieldp, *parentp;
1288
  int i;
1289
  int static_member = 0;
1290
  int const_member = 0;
1291
  int volatile_member = 0;
1292
  unsigned long vtbl_offset;
1293
  int need_bitvectors = 0;
1294
  char *method_name = NULL;
1295
  char *method_alias = NULL;
1296
 
1297
 
1298
  /* Is it something we've already dealt with?  */
1299
  type = hpread_alloc_type (hp_type, objfile);
1300
  if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
1301
      (TYPE_CODE (type) == TYPE_CODE_UNION) ||
1302
      (TYPE_CODE (type) == TYPE_CODE_CLASS) ||
1303
      (TYPE_CODE (type) == TYPE_CODE_TEMPLATE))
1304
    return type;
1305
 
1306
  /* Get the basic type correct.  */
1307
  if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
1308
    {
1309
      TYPE_CODE (type) = TYPE_CODE_STRUCT;
1310
      TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
1311
    }
1312
  else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
1313
    {
1314
      TYPE_CODE (type) = TYPE_CODE_UNION;
1315
      TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
1316
    }
1317
  else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
1318
    {
1319
      TYPE_CODE (type) = TYPE_CODE_CLASS;
1320
      TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8;
1321
 
1322
      /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
1323
       * rather than &cplus_struct_default.
1324
       */
1325
      allocate_cplus_struct_type (type);
1326
 
1327
      /* Fill in declared-type.
1328
       * (The C++ compiler will emit TYPE_CODE_CLASS
1329
       * for all 3 of "class", "struct"
1330
       * "union", and we have to look at the "class_decl" field if we
1331
       * want to know how it was really declared)
1332
       */
1333
      /* (0==class, 1==union, 2==struct) */
1334
      TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl;
1335
    }
1336
  else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
1337
    {
1338
      /* Get the basic type correct.  */
1339
      TYPE_CODE (type) = TYPE_CODE_TEMPLATE;
1340
      allocate_cplus_struct_type (type);
1341
      TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE;
1342
    }
1343
  else
1344
    return type;
1345
 
1346
 
1347
  TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
1348
 
1349
  /* For classes, read the parent list.
1350
   * Question (RT): Do we need to do this for templates also?
1351
   */
1352
  if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
1353
    {
1354
 
1355
      /* First read the parent-list (classes from which we derive fields) */
1356
      parent = dn_bufp->dclass.parentlist;
1357
      while (parent.word && parent.word != DNTTNIL)
1358
        {
1359
          parentp = hpread_get_lntt (parent.dnttp.index, objfile);
1360
 
1361
          /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
1362
 
1363
          /* Get space to record the next field/data-member. */
1364
          new = (struct nextfield *) alloca (sizeof (struct nextfield));
1365
          new->next = list;
1366
          list = new;
1367
 
1368
          FIELD_BITSIZE (list->field) = 0;
1369
 
1370
          /* The "classname" field is actually a DNTT pointer to the base class */
1371
          baseclass = hpread_type_lookup (parentp->dinheritance.classname,
1372
                                          objfile);
1373
          FIELD_TYPE (list->field) = baseclass;
1374
 
1375
          list->field.name = type_name_no_tag (FIELD_TYPE (list->field));
1376
 
1377
          list->attributes = 0;
1378
 
1379
          /* Check for virtuality of base, and set the
1380
           * offset of the base subobject within the object.
1381
           * (Offset set to -1 for virtual bases (for now).)
1382
           */
1383
          if (parentp->dinheritance.Virtual)
1384
            {
1385
              B_SET (&(list->attributes), ATTR_VIRTUAL);
1386
              parentp->dinheritance.offset = -1;
1387
            }
1388
          else
1389
            FIELD_BITPOS (list->field) = parentp->dinheritance.offset;
1390
 
1391
          /* Check visibility */
1392
          switch (parentp->dinheritance.visibility)
1393
            {
1394
            case 1:
1395
              B_SET (&(list->attributes), ATTR_PROTECT);
1396
              break;
1397
            case 2:
1398
              B_SET (&(list->attributes), ATTR_PRIVATE);
1399
              break;
1400
            }
1401
 
1402
          n_base_classes++;
1403
          nfields++;
1404
 
1405
          parent = parentp->dinheritance.next;
1406
        }
1407
    }
1408
 
1409
  /* For templates, read the template argument list.
1410
   * This must be done before processing the member list, because
1411
   * the member list may refer back to this. E.g.:
1412
   *   template <class T1, class T2> class q2 {
1413
   *     public:
1414
   *     T1 a;
1415
   *     T2 b;
1416
   *   };
1417
   * We need to read the argument list "T1", "T2" first.
1418
   */
1419
  if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
1420
    {
1421
      /* Kludge alert: This stuffs a global "current_template" which
1422
       * is referred to by hpread_get_nth_templ_arg(). The global
1423
       * is cleared at the end of this routine.
1424
       */
1425
      current_template = type;
1426
 
1427
      /* Read in the argument list */
1428
      field = dn_bufp->dtemplate.arglist;
1429
      while (field.word && field.word != DNTTNIL)
1430
        {
1431
          /* Get this template argument */
1432
          fieldp = hpread_get_lntt (field.dnttp.index, objfile);
1433
          if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG)
1434
            {
1435
              warning ("Invalid debug info: Template argument entry is of wrong kind");
1436
              break;
1437
            }
1438
          /* Bump the count */
1439
          n_templ_args++;
1440
          /* Allocate and fill in a struct next_template */
1441
          t_new = (struct next_template *) alloca (sizeof (struct next_template));
1442
          t_new->next = t_list;
1443
          t_list = t_new;
1444
          t_list->arg.name = VT (objfile) + fieldp->dtempl_arg.name;
1445
          t_list->arg.type = hpread_read_templ_arg_type (field, fieldp,
1446
                                                 objfile, t_list->arg.name);
1447
          /* Walk to the next template argument */
1448
          field = fieldp->dtempl_arg.nextarg;
1449
        }
1450
    }
1451
 
1452
  TYPE_NTEMPLATE_ARGS (type) = n_templ_args;
1453
 
1454
  if (n_templ_args > 0)
1455
    TYPE_TEMPLATE_ARGS (type) = (struct template_arg *)
1456
      obstack_alloc (&objfile->type_obstack, sizeof (struct template_arg) * n_templ_args);
1457
  for (n = n_templ_args; t_list; t_list = t_list->next)
1458
    {
1459
      n -= 1;
1460
      TYPE_TEMPLATE_ARG (type, n) = t_list->arg;
1461
    }
1462
 
1463
  /* Next read in and internalize all the fields/members.  */
1464
  if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
1465
    field = dn_bufp->dstruct.firstfield;
1466
  else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
1467
    field = dn_bufp->dunion.firstfield;
1468
  else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
1469
    field = dn_bufp->dclass.memberlist;
1470
  else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
1471
    field = dn_bufp->dtemplate.memberlist;
1472
  else
1473
    field.word = DNTTNIL;
1474
 
1475
  while (field.word && field.word != DNTTNIL)
1476
    {
1477
      fieldp = hpread_get_lntt (field.dnttp.index, objfile);
1478
 
1479
      /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
1480
       * or a DNTT_TYPE_GENFIELD record.
1481
       */
1482
      vtbl_offset = 0;
1483
      static_member = 0;
1484
      const_member = 0;
1485
      volatile_member = 0;
1486
 
1487
      if (fieldp->dblock.kind == DNTT_TYPE_GENFIELD)
1488
        {
1489
 
1490
          /* The type will be GENFIELD if the field is a method or
1491
           * a static member (or some other cases -- see below)
1492
           */
1493
 
1494
          /* Follow a link to get to the record for the field. */
1495
          fn_field = fieldp->dgenfield.field;
1496
          fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
1497
 
1498
          /* Virtual funcs are indicated by a VFUNC which points to the
1499
           * real entry
1500
           */
1501
          if (fn_fieldp->dblock.kind == DNTT_TYPE_VFUNC)
1502
            {
1503
              vtbl_offset = fn_fieldp->dvfunc.vtbl_offset;
1504
              fn_field = fn_fieldp->dvfunc.funcptr;
1505
              fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
1506
            }
1507
 
1508
          /* A function's entry may be preceded by a modifier which
1509
           * labels it static/constant/volatile.
1510
           */
1511
          if (fn_fieldp->dblock.kind == DNTT_TYPE_MODIFIER)
1512
            {
1513
              static_member = fn_fieldp->dmodifier.m_static;
1514
              const_member = fn_fieldp->dmodifier.m_const;
1515
              volatile_member = fn_fieldp->dmodifier.m_volatile;
1516
              fn_field = fn_fieldp->dmodifier.type;
1517
              fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
1518
            }
1519
 
1520
          /* Check whether we have a method */
1521
          if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
1522
              (fn_fieldp->dblock.kind == DNTT_TYPE_FUNCTION) ||
1523
              (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) ||
1524
              (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_FUNCTION))
1525
            {
1526
              /* Method found */
1527
 
1528
              short ix = 0;
1529
 
1530
              /* Look up function type of method */
1531
              memtype = hpread_type_lookup (fn_field, objfile);
1532
 
1533
              /* Methods can be seen before classes in the SOM records.
1534
                 If we are processing this class because it's a parameter of a
1535
                 method, at this point the method's type is actually incomplete;
1536
                 we'll have to fix it up later; mark the class for this. */
1537
 
1538
              if (TYPE_INCOMPLETE (memtype))
1539
                {
1540
                  TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
1541
                  if (fixup_class)
1542
                    warning ("Two classes to fix up for method??  Type information may be incorrect for some classes.");
1543
                  if (fixup_method)
1544
                    warning ("Two methods to be fixed up at once?? Type information may be incorrect for some classes.");
1545
                  fixup_class = type;   /* remember this class has to be fixed up */
1546
                  fixup_method = memtype;       /* remember the method type to be used in fixup */
1547
                }
1548
 
1549
              /* HP aCC generates operator names without the "operator" keyword, and
1550
                 generates null strings as names for operators that are
1551
                 user-defined type conversions to basic types (e.g. operator int ()).
1552
                 So try to reconstruct name as best as possible. */
1553
 
1554
              method_name = (char *) (VT (objfile) + fn_fieldp->dfunc.name);
1555
              method_alias = (char *) (VT (objfile) + fn_fieldp->dfunc.alias);
1556
 
1557
              if (!method_name ||       /* no name */
1558
                  !*method_name ||      /* or null name */
1559
                  cplus_mangle_opname (method_name, DMGL_ANSI))         /* or name is an operator like "<" */
1560
                {
1561
                  char *tmp_name = cplus_demangle (method_alias, DMGL_ANSI);
1562
                  char *op_string = strstr (tmp_name, "operator");
1563
                  method_name = xmalloc (strlen (op_string) + 1);       /* don't overwrite VT! */
1564
                  strcpy (method_name, op_string);
1565
                }
1566
 
1567
              /* First check if a method of the same name has already been seen. */
1568
              fn_p = fn_list;
1569
              while (fn_p)
1570
                {
1571
                  if (STREQ (fn_p->field.name, method_name))
1572
                    break;
1573
                  fn_p = fn_p->next;
1574
                }
1575
 
1576
              /* If no such method was found, allocate a new entry in the list */
1577
              if (!fn_p)
1578
                {
1579
                  /* Get space to record this member function */
1580
                  /* Note: alloca used; this will disappear on routine exit */
1581
                  fn_new = (struct next_fn_field *) alloca (sizeof (struct next_fn_field));
1582
                  fn_new->next = fn_list;
1583
                  fn_list = fn_new;
1584
 
1585
                  /* Fill in the fields of the struct nextfield */
1586
 
1587
                  /* Record the (unmangled) method name */
1588
                  fn_list->field.name = method_name;
1589
                  /* Initial space for overloaded methods */
1590
                  /* Note: xmalloc is used; this will persist after this routine exits */
1591
                  fn_list->field.fn_fields = (struct fn_field *) xmalloc (5 * (sizeof (struct fn_field)));
1592
                  fn_list->field.length = 1;    /* Init # of overloaded instances */
1593
                  fn_list->num_fn_fields = 5;   /* # of entries for which space allocated */
1594
                  fn_p = fn_list;
1595
                  ix = 0;        /* array index for fn_field */
1596
                  /* Bump the total count of the distinctly named methods */
1597
                  n_fn_fields++;
1598
                }
1599
              else
1600
                /* Another overloaded instance of an already seen method name */
1601
                {
1602
                  if (++(fn_p->field.length) > fn_p->num_fn_fields)
1603
                    {
1604
                      /* Increase space allocated for overloaded instances */
1605
                      fn_p->field.fn_fields
1606
                        = (struct fn_field *) xrealloc (fn_p->field.fn_fields,
1607
                      (fn_p->num_fn_fields + 5) * sizeof (struct fn_field));
1608
                      fn_p->num_fn_fields += 5;
1609
                    }
1610
                  ix = fn_p->field.length - 1;  /* array index for fn_field */
1611
                }
1612
 
1613
              /* "physname" is intended to be the name of this overloaded instance. */
1614
              if ((fn_fieldp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
1615
                  method_alias &&
1616
                  *method_alias)        /* not a null string */
1617
                fn_p->field.fn_fields[ix].physname = method_alias;
1618
              else
1619
                fn_p->field.fn_fields[ix].physname = method_name;
1620
              /* What's expected here is the function type */
1621
              /* But mark it as NULL if the method was incompletely processed
1622
                 We'll fix this up later when the method is fully processed */
1623
              if (TYPE_INCOMPLETE (memtype))
1624
                {
1625
                  fn_p->field.fn_fields[ix].type = NULL;
1626
                  fn_p->field.fn_fields[ix].args = NULL;
1627
                }
1628
              else
1629
                {
1630
                  fn_p->field.fn_fields[ix].type = memtype;
1631
 
1632
                  /* The argument list */
1633
                  fn_p->field.fn_fields[ix].type->type_specific.arg_types =
1634
                    (struct type **) obstack_alloc (&objfile->type_obstack,
1635
                           sizeof (struct type *) * (memtype->nfields + 1));
1636
                  for (i = 0; i < memtype->nfields; i++)
1637
                    fn_p->field.fn_fields[ix].type->type_specific.arg_types[i] = memtype->fields[i].type;
1638
                  /* void termination */
1639
                  fn_p->field.fn_fields[ix].type->type_specific.arg_types[memtype->nfields] = builtin_type_void;
1640
 
1641
                  /* pai: It's not clear why this args field has to be set.  Perhaps
1642
                   * it should be eliminated entirely. */
1643
                  fn_p->field.fn_fields[ix].args =
1644
                    (struct type **) obstack_alloc (&objfile->type_obstack,
1645
                           sizeof (struct type *) * (memtype->nfields + 1));
1646
                  for (i = 0; i < memtype->nfields; i++)
1647
                    fn_p->field.fn_fields[ix].args[i] = memtype->fields[i].type;
1648
                  /* null-terminated, unlike arg_types above e */
1649
                  fn_p->field.fn_fields[ix].args[memtype->nfields] = NULL;
1650
                }
1651
              /* For virtual functions, fill in the voffset field with the
1652
               * virtual table offset. (This is just copied over from the
1653
               * SOM record; not sure if it is what GDB expects here...).
1654
               * But if the function is a static method, set it to 1.
1655
               *
1656
               * Note that we have to add 1 because 1 indicates a static
1657
               * method, and 0 indicates a non-static, non-virtual method */
1658
 
1659
              if (static_member)
1660
                fn_p->field.fn_fields[ix].voffset = VOFFSET_STATIC;
1661
              else
1662
                fn_p->field.fn_fields[ix].voffset = vtbl_offset ? vtbl_offset + 1 : 0;
1663
 
1664
              /* Also fill in the fcontext field with the current
1665
               * class. (The latter isn't quite right: should be the baseclass
1666
               * that defines the virtual function... Note we do have
1667
               * a variable "baseclass" that we could stuff into the fcontext
1668
               * field, but "baseclass" isn't necessarily right either,
1669
               * since the virtual function could have been defined more
1670
               * than one level up).
1671
               */
1672
 
1673
              if (vtbl_offset != 0)
1674
                fn_p->field.fn_fields[ix].fcontext = type;
1675
              else
1676
                fn_p->field.fn_fields[ix].fcontext = NULL;
1677
 
1678
              /* Other random fields pertaining to this method */
1679
              fn_p->field.fn_fields[ix].is_const = const_member;
1680
              fn_p->field.fn_fields[ix].is_volatile = volatile_member;  /* ?? */
1681
              switch (fieldp->dgenfield.visibility)
1682
                {
1683
                case 1:
1684
                  fn_p->field.fn_fields[ix].is_protected = 1;
1685
                  fn_p->field.fn_fields[ix].is_private = 0;
1686
                  break;
1687
                case 2:
1688
                  fn_p->field.fn_fields[ix].is_protected = 0;
1689
                  fn_p->field.fn_fields[ix].is_private = 1;
1690
                  break;
1691
                default:        /* public */
1692
                  fn_p->field.fn_fields[ix].is_protected = 0;
1693
                  fn_p->field.fn_fields[ix].is_private = 0;
1694
                }
1695
              fn_p->field.fn_fields[ix].is_stub = 0;
1696
 
1697
              /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
1698
                 if the class points to the FUNCTION, there is usually separate
1699
                 code for the method; but if we have a MEMFUNC, the method has
1700
                 been inlined (and there is usually no FUNCTION entry)
1701
                 FIXME Not sure if this test is accurate. pai/1997-08-22 */
1702
              if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
1703
                  (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC))
1704
                fn_p->field.fn_fields[ix].is_inlined = 1;
1705
              else
1706
                fn_p->field.fn_fields[ix].is_inlined = 0;
1707
 
1708
              fn_p->field.fn_fields[ix].dummy = 0;
1709
 
1710
              /* Bump the total count of the member functions */
1711
              n_fn_fields_total++;
1712
 
1713
            }
1714
          else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
1715
            {
1716
              /* This case is for static data members of classes */
1717
 
1718
              /* pai:: FIXME -- check that "staticmem" bit is set */
1719
 
1720
              /* Get space to record this static member */
1721
              new = (struct nextfield *) alloca (sizeof (struct nextfield));
1722
              new->next = list;
1723
              list = new;
1724
 
1725
              list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
1726
              FIELD_BITSIZE (list->field) = -1;         /* indicates static member */
1727
              SET_FIELD_PHYSNAME (list->field, 0);       /* initialize to empty */
1728
              memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
1729
 
1730
              FIELD_TYPE (list->field) = memtype;
1731
              list->attributes = 0;
1732
              switch (fieldp->dgenfield.visibility)
1733
                {
1734
                case 1:
1735
                  B_SET (&(list->attributes), ATTR_PROTECT);
1736
                  break;
1737
                case 2:
1738
                  B_SET (&(list->attributes), ATTR_PRIVATE);
1739
                  break;
1740
                }
1741
              nfields++;
1742
            }
1743
 
1744
          else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD)
1745
            {
1746
              /* FIELDs follow GENFIELDs for fields of anonymous unions.
1747
                 Code below is replicated from the case for FIELDs further
1748
                 below, except that fieldp is replaced by fn_fieldp */
1749
              if (!fn_fieldp->dfield.a_union)
1750
                warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
1751
              /* Get space to record the next field/data-member. */
1752
              new = (struct nextfield *) alloca (sizeof (struct nextfield));
1753
              new->next = list;
1754
              list = new;
1755
 
1756
              list->field.name = VT (objfile) + fn_fieldp->dfield.name;
1757
              FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset;
1758
              if (fn_fieldp->dfield.bitlength % 8)
1759
                list->field.bitsize = fn_fieldp->dfield.bitlength;
1760
              else
1761
                list->field.bitsize = 0;
1762
 
1763
              memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile);
1764
              list->field.type = memtype;
1765
              list->attributes = 0;
1766
              switch (fn_fieldp->dfield.visibility)
1767
                {
1768
                case 1:
1769
                  B_SET (&(list->attributes), ATTR_PROTECT);
1770
                  break;
1771
                case 2:
1772
                  B_SET (&(list->attributes), ATTR_PRIVATE);
1773
                  break;
1774
                }
1775
              nfields++;
1776
            }
1777
          else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
1778
            {
1779
              /* Field of anonymous union; union is not inside a class */
1780
              if (!fn_fieldp->dsvar.a_union)
1781
                warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
1782
              /* Get space to record the next field/data-member. */
1783
              new = (struct nextfield *) alloca (sizeof (struct nextfield));
1784
              new->next = list;
1785
              list = new;
1786
 
1787
              list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
1788
              FIELD_BITPOS (list->field) = 0;    /* FIXME is this always true? */
1789
              FIELD_BITSIZE (list->field) = 0;   /* use length from type */
1790
              memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
1791
              list->field.type = memtype;
1792
              list->attributes = 0;
1793
              /* No info to set visibility -- always public */
1794
              nfields++;
1795
            }
1796
          else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR)
1797
            {
1798
              /* Field of anonymous union; union is not inside a class */
1799
              if (!fn_fieldp->ddvar.a_union)
1800
                warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
1801
              /* Get space to record the next field/data-member. */
1802
              new = (struct nextfield *) alloca (sizeof (struct nextfield));
1803
              new->next = list;
1804
              list = new;
1805
 
1806
              list->field.name = VT (objfile) + fn_fieldp->ddvar.name;
1807
              FIELD_BITPOS (list->field) = 0;    /* FIXME is this always true? */
1808
              FIELD_BITSIZE (list->field) = 0;   /* use length from type */
1809
              memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile);
1810
              list->field.type = memtype;
1811
              list->attributes = 0;
1812
              /* No info to set visibility -- always public */
1813
              nfields++;
1814
            }
1815
          else
1816
            {                   /* Not a method, nor a static data member, nor an anon union field */
1817
 
1818
              /* This case is for miscellaneous type entries (local enums,
1819
                 local function templates, etc.) that can be present
1820
                 inside a class. */
1821
 
1822
              /* Enums -- will be handled by other code that takes care
1823
                 of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
1824
                 it's not clear we could have handled them here at all. */
1825
              /* FUNC_TEMPLATE: is handled by other code (??). */
1826
              /* MEMACCESS: modified access for inherited member. Not
1827
                 sure what to do with this, ignoriing it at present. */
1828
 
1829
              /* What other entries can appear following a GENFIELD which
1830
                 we do not handle above?  (MODIFIER, VFUNC handled above.) */
1831
 
1832
              if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) &&
1833
                  (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) &&
1834
                  (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE))
1835
                warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
1836
                         fn_fieldp->dblock.kind);
1837
            }
1838
          /* walk to the next FIELD or GENFIELD */
1839
          field = fieldp->dgenfield.nextfield;
1840
 
1841
        }
1842
      else if (fieldp->dblock.kind == DNTT_TYPE_FIELD)
1843
        {
1844
 
1845
          /* Ordinary structure/union/class field */
1846
          struct type *anon_union_type;
1847
 
1848
          /* Get space to record the next field/data-member. */
1849
          new = (struct nextfield *) alloca (sizeof (struct nextfield));
1850
          new->next = list;
1851
          list = new;
1852
 
1853
          list->field.name = VT (objfile) + fieldp->dfield.name;
1854
 
1855
 
1856
          /* A FIELD by itself (without a GENFIELD) can also be a static member */
1857
          if (fieldp->dfield.staticmem)
1858
            {
1859
              FIELD_BITPOS (list->field) = -1;
1860
              FIELD_BITSIZE (list->field) = 0;
1861
            }
1862
          else
1863
            /* Non-static data member */
1864
            {
1865
              FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
1866
              if (fieldp->dfield.bitlength % 8)
1867
                FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
1868
              else
1869
                FIELD_BITSIZE (list->field) = 0;
1870
            }
1871
 
1872
          memtype = hpread_type_lookup (fieldp->dfield.type, objfile);
1873
          FIELD_TYPE (list->field) = memtype;
1874
          list->attributes = 0;
1875
          switch (fieldp->dfield.visibility)
1876
            {
1877
            case 1:
1878
              B_SET (&(list->attributes), ATTR_PROTECT);
1879
              break;
1880
            case 2:
1881
              B_SET (&(list->attributes), ATTR_PRIVATE);
1882
              break;
1883
            }
1884
          nfields++;
1885
 
1886
 
1887
          /* Note 1: First, we have to check if the current field is an anonymous
1888
             union. If it is, then *its* fields are threaded along in the
1889
             nextfield chain. :-( This was supposed to help debuggers, but is
1890
             really just a nuisance since we deal with anonymous unions anyway by
1891
             checking that the name is null.  So anyway, we skip over the fields
1892
             of the anonymous union. pai/1997-08-22 */
1893
          /* Note 2: In addition, the bitoffsets for the fields of the anon union
1894
             are relative to the enclosing struct, *NOT* relative to the anon
1895
             union!  This is an even bigger nuisance -- we have to go in and munge
1896
             the anon union's type information appropriately. pai/1997-08-22 */
1897
 
1898
          /* Both tasks noted above are done by a separate function.  This takes us
1899
             to the next FIELD or GENFIELD, skipping anon unions, and recursively
1900
             processing intermediate types. */
1901
          field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile);
1902
 
1903
        }
1904
      else
1905
        {
1906
          /* neither field nor genfield ?? is this possible?? */
1907
          /* pai:: FIXME walk to the next -- how? */
1908
          warning ("Internal error: unexpected DNTT kind %d encountered as field of struct");
1909
          warning ("Skipping remaining fields of struct");
1910
          break;                /* get out of loop of fields */
1911
        }
1912
    }
1913
 
1914
  /* If it's a template, read in the instantiation list */
1915
  if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
1916
    {
1917
      ninstantiations = 0;
1918
      field = dn_bufp->dtemplate.expansions;
1919
      while (field.word && field.word != DNTTNIL)
1920
        {
1921
          fieldp = hpread_get_lntt (field.dnttp.index, objfile);
1922
 
1923
          /* The expansions or nextexp should point to a tagdef */
1924
          if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF)
1925
            break;
1926
 
1927
          i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation));
1928
          i_new->next = i_list;
1929
          i_list = i_new;
1930
          i_list->t = hpread_type_lookup (field, objfile);
1931
          ninstantiations++;
1932
 
1933
          /* And the "type" field of that should point to a class */
1934
          field = fieldp->dtag.type;
1935
          fieldp = hpread_get_lntt (field.dnttp.index, objfile);
1936
          if (fieldp->dblock.kind != DNTT_TYPE_CLASS)
1937
            break;
1938
 
1939
          /* Get the next expansion */
1940
          field = fieldp->dclass.nextexp;
1941
        }
1942
    }
1943
  TYPE_NINSTANTIATIONS (type) = ninstantiations;
1944
  if (ninstantiations > 0)
1945
    TYPE_INSTANTIATIONS (type) = (struct type **)
1946
      obstack_alloc (&objfile->type_obstack, sizeof (struct type *) * ninstantiations);
1947
  for (n = ninstantiations; i_list; i_list = i_list->next)
1948
    {
1949
      n -= 1;
1950
      TYPE_INSTANTIATION (type, n) = i_list->t;
1951
    }
1952
 
1953
 
1954
  /* Copy the field-list to GDB's symbol table */
1955
  TYPE_NFIELDS (type) = nfields;
1956
  TYPE_N_BASECLASSES (type) = n_base_classes;
1957
  TYPE_FIELDS (type) = (struct field *)
1958
    obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nfields);
1959
  /* Copy the saved-up fields into the field vector.  */
1960
  for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
1961
    {
1962
      n -= 1;
1963
      TYPE_FIELD (type, n) = tmp_list->field;
1964
    }
1965
 
1966
  /* Copy the "function-field-list" (i.e., the list of member
1967
   * functions in the class) to GDB's symbol table
1968
   */
1969
  TYPE_NFN_FIELDS (type) = n_fn_fields;
1970
  TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total;
1971
  TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
1972
    obstack_alloc (&objfile->type_obstack, sizeof (struct fn_fieldlist) * n_fn_fields);
1973
  for (n = n_fn_fields; fn_list; fn_list = fn_list->next)
1974
    {
1975
      n -= 1;
1976
      TYPE_FN_FIELDLIST (type, n) = fn_list->field;
1977
    }
1978
 
1979
  /* pai:: FIXME -- perhaps each bitvector should be created individually */
1980
  for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
1981
    {
1982
      n -= 1;
1983
      if (tmp_list->attributes)
1984
        {
1985
          need_bitvectors = 1;
1986
          break;
1987
        }
1988
    }
1989
 
1990
  if (need_bitvectors)
1991
    {
1992
      /* pai:: this step probably redundant */
1993
      ALLOCATE_CPLUS_STRUCT_TYPE (type);
1994
 
1995
      TYPE_FIELD_VIRTUAL_BITS (type) =
1996
        (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
1997
      B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields);
1998
 
1999
      TYPE_FIELD_PRIVATE_BITS (type) =
2000
        (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2001
      B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2002
 
2003
      TYPE_FIELD_PROTECTED_BITS (type) =
2004
        (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2005
      B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2006
 
2007
      /* this field vector isn't actually used with HP aCC */
2008
      TYPE_FIELD_IGNORE_BITS (type) =
2009
        (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2010
      B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
2011
 
2012
      while (nfields-- > 0)
2013
        {
2014
          if (B_TST (&(list->attributes), ATTR_VIRTUAL))
2015
            SET_TYPE_FIELD_VIRTUAL (type, nfields);
2016
          if (B_TST (&(list->attributes), ATTR_PRIVATE))
2017
            SET_TYPE_FIELD_PRIVATE (type, nfields);
2018
          if (B_TST (&(list->attributes), ATTR_PROTECT))
2019
            SET_TYPE_FIELD_PROTECTED (type, nfields);
2020
 
2021
          list = list->next;
2022
        }
2023
    }
2024
  else
2025
    {
2026
      TYPE_FIELD_VIRTUAL_BITS (type) = NULL;
2027
      TYPE_FIELD_PROTECTED_BITS (type) = NULL;
2028
      TYPE_FIELD_PRIVATE_BITS (type) = NULL;
2029
    }
2030
 
2031
  if (has_vtable (type))
2032
    {
2033
      /* Allocate space for class runtime information */
2034
      TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info));
2035
      /* Set flag for vtable */
2036
      TYPE_VTABLE (type) = 1;
2037
      /* The first non-virtual base class with a vtable. */
2038
      TYPE_PRIMARY_BASE (type) = primary_base_class (type);
2039
      /* The virtual base list. */
2040
      TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type);
2041
    }
2042
  else
2043
    TYPE_RUNTIME_PTR (type) = NULL;
2044
 
2045
  /* If this is a local type (C++ - declared inside a function), record file name & line # */
2046
  if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ ))
2047
    {
2048
      TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info));
2049
      TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1);
2050
      strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name);
2051
      if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0))
2052
        TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line;
2053
      else
2054
        TYPE_LOCALTYPE_LINE (type) = 0;
2055
    }
2056
  else
2057
    TYPE_LOCALTYPE_PTR (type) = NULL;
2058
 
2059
  /* Clear the global saying what template we are in the middle of processing */
2060
  current_template = NULL;
2061
 
2062
  return type;
2063
}
2064
 
2065
/* Adjust the physnames for each static member of a struct
2066
   or class type to be something like "A::x"; then various
2067
   other pieces of code that do a lookup_symbol on the phyname
2068
   work correctly.
2069
   TYPE is a pointer to the struct/class type
2070
   NAME is a char * (string) which is the class/struct name
2071
   Void return */
2072
 
2073
static void
2074
fix_static_member_physnames (type, class_name, objfile)
2075
     struct type *type;
2076
     char *class_name;
2077
     struct objfile *objfile;
2078
{
2079
  int i;
2080
 
2081
  /* We fix the member names only for classes or structs */
2082
  if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
2083
    return;
2084
 
2085
  for (i = 0; i < TYPE_NFIELDS (type); i++)
2086
    if (TYPE_FIELD_STATIC (type, i))
2087
      {
2088
        if (TYPE_FIELD_STATIC_PHYSNAME (type, i))
2089
          return;               /* physnames are already set */
2090
 
2091
        SET_FIELD_PHYSNAME (type->fields[i],
2092
                            obstack_alloc (&objfile->type_obstack,
2093
             strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3));
2094
        strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name);
2095
        strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::");
2096
        strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i));
2097
      }
2098
}
2099
 
2100
/* Fix-up the type structure for a CLASS so that the type entry
2101
 * for a method (previously marked with a null type in hpread_read_struct_type()
2102
 * is set correctly to METHOD.
2103
 * OBJFILE is as for other such functions.
2104
 * Void return. */
2105
 
2106
static void
2107
fixup_class_method_type (class, method, objfile)
2108
     struct type *class;
2109
     struct type *method;
2110
     struct objfile *objfile;
2111
{
2112
  int i, j, k;
2113
 
2114
  if (!class || !method || !objfile)
2115
    return;
2116
 
2117
  /* Only for types that have methods */
2118
  if ((TYPE_CODE (class) != TYPE_CODE_CLASS) &&
2119
      (TYPE_CODE (class) != TYPE_CODE_UNION))
2120
    return;
2121
 
2122
  /* Loop over all methods and find the one marked with a NULL type */
2123
  for (i = 0; i < TYPE_NFN_FIELDS (class); i++)
2124
    for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++)
2125
      if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL)
2126
        {
2127
          /* Set the method type */
2128
          TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method;
2129
          /* The argument list */
2130
          (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types
2131
            = (struct type **) obstack_alloc (&objfile->type_obstack,
2132
                            sizeof (struct type *) * (method->nfields + 1));
2133
          for (k = 0; k < method->nfields; k++)
2134
            (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types[k] = method->fields[k].type;
2135
          /* void termination */
2136
          (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j))->type_specific.arg_types[method->nfields] = builtin_type_void;
2137
 
2138
          /* pai: It's not clear why this args field has to be set.  Perhaps
2139
           * it should be eliminated entirely. */
2140
          (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args
2141
            = (struct type **) obstack_alloc (&objfile->type_obstack,
2142
                            sizeof (struct type *) * (method->nfields + 1));
2143
          for (k = 0; k < method->nfields; k++)
2144
            (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[k] = method->fields[k].type;
2145
          /* null-terminated, unlike arg_types above */
2146
          (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i), j)).args[method->nfields] = NULL;
2147
 
2148
          /* Break out of both loops -- only one method to fix up in a class */
2149
          goto finish;
2150
        }
2151
 
2152
finish:
2153
  TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE;
2154
}
2155
 
2156
 
2157
/* If we're in the middle of processing a template, get a pointer
2158
 * to the Nth template argument.
2159
 * An example may make this clearer:
2160
 *   template <class T1, class T2> class q2 {
2161
 *     public:
2162
 *     T1 a;
2163
 *     T2 b;
2164
 *   };
2165
 * The type for "a" will be "first template arg" and
2166
 * the type for "b" will be "second template arg".
2167
 * We need to look these up in order to fill in "a" and "b"'s type.
2168
 * This is called from hpread_type_lookup().
2169
 */
2170
static struct type *
2171
hpread_get_nth_template_arg (objfile, n)
2172
     struct objfile *objfile;
2173
     int n;
2174
{
2175
  if (current_template != NULL)
2176
    return TYPE_TEMPLATE_ARG (current_template, n).type;
2177
  else
2178
    return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG);
2179
}
2180
 
2181
/* Read in and internalize a TEMPL_ARG (template arg) symbol.  */
2182
 
2183
static struct type *
2184
hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name)
2185
     dnttpointer hp_type;
2186
     union dnttentry *dn_bufp;
2187
     struct objfile *objfile;
2188
     char *name;
2189
{
2190
  struct type *type;
2191
 
2192
  /* See if it's something we've already deal with.  */
2193
  type = hpread_alloc_type (hp_type, objfile);
2194
  if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG)
2195
    return type;
2196
 
2197
  /* Nope.  Fill in the appropriate fields.  */
2198
  TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG;
2199
  TYPE_LENGTH (type) = 0;
2200
  TYPE_NFIELDS (type) = 0;
2201
  TYPE_NAME (type) = name;
2202
  return type;
2203
}
2204
 
2205
/* Read in and internalize a set debug symbol.  */
2206
 
2207
static struct type *
2208
hpread_read_set_type (hp_type, dn_bufp, objfile)
2209
     dnttpointer hp_type;
2210
     union dnttentry *dn_bufp;
2211
     struct objfile *objfile;
2212
{
2213
  struct type *type;
2214
 
2215
  /* See if it's something we've already deal with.  */
2216
  type = hpread_alloc_type (hp_type, objfile);
2217
  if (TYPE_CODE (type) == TYPE_CODE_SET)
2218
    return type;
2219
 
2220
  /* Nope.  Fill in the appropriate fields.  */
2221
  TYPE_CODE (type) = TYPE_CODE_SET;
2222
  TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8;
2223
  TYPE_NFIELDS (type) = 0;
2224
  TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype,
2225
                                                objfile);
2226
  return type;
2227
}
2228
 
2229
/* Read in and internalize an array debug symbol.  */
2230
 
2231
static struct type *
2232
hpread_read_array_type (hp_type, dn_bufp, objfile)
2233
     dnttpointer hp_type;
2234
     union dnttentry *dn_bufp;
2235
     struct objfile *objfile;
2236
{
2237
  struct type *type;
2238
 
2239
  /* Allocate an array type symbol.
2240
   * Why no check for already-read here, like in the other
2241
   * hpread_read_xxx_type routines?  Because it kept us
2242
   * from properly determining the size of the array!
2243
   */
2244
  type = hpread_alloc_type (hp_type, objfile);
2245
 
2246
  TYPE_CODE (type) = TYPE_CODE_ARRAY;
2247
 
2248
  /* Although the hp-symtab.h does not *require* this to be the case,
2249
   * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
2250
   * I.e., express both array-length and element-length in bits,
2251
   * or express both array-length and element-length in bytes.
2252
   */
2253
  if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) ||
2254
        (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes)))
2255
    {
2256
      warning ("error in hpread_array_type.\n");
2257
      return;
2258
    }
2259
  else if (dn_bufp->darray.arraylength == 0x7fffffff)
2260
    {
2261
      /* The HP debug format represents char foo[]; as an array with
2262
       * length 0x7fffffff.  Internally GDB wants to represent this
2263
       *  as an array of length zero.
2264
       */
2265
      TYPE_LENGTH (type) = 0;
2266
    }
2267
  else if (dn_bufp->darray.arrayisbytes)
2268
    TYPE_LENGTH (type) = dn_bufp->darray.arraylength;
2269
  else                          /* arraylength is in bits */
2270
    TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
2271
 
2272
  TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype,
2273
                                                objfile);
2274
 
2275
  /* The one "field" is used to store the subscript type */
2276
  /* Since C and C++ multi-dimensional arrays are simply represented
2277
   * as: array of array of ..., we only need one subscript-type
2278
   * per array. This subscript type is typically a subrange of integer.
2279
   * If this gets extended to support languages like Pascal, then
2280
   * we need to fix this to represent multi-dimensional arrays properly.
2281
   */
2282
  TYPE_NFIELDS (type) = 1;
2283
  TYPE_FIELDS (type) = (struct field *)
2284
    obstack_alloc (&objfile->type_obstack, sizeof (struct field));
2285
  TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype,
2286
                                                  objfile);
2287
  return type;
2288
}
2289
 
2290
/* Read in and internalize a subrange debug symbol.  */
2291
static struct type *
2292
hpread_read_subrange_type (hp_type, dn_bufp, objfile)
2293
     dnttpointer hp_type;
2294
     union dnttentry *dn_bufp;
2295
     struct objfile *objfile;
2296
{
2297
  struct type *type;
2298
 
2299
  /* Is it something we've already dealt with.  */
2300
  type = hpread_alloc_type (hp_type, objfile);
2301
  if (TYPE_CODE (type) == TYPE_CODE_RANGE)
2302
    return type;
2303
 
2304
  /* Nope, internalize it.  */
2305
  TYPE_CODE (type) = TYPE_CODE_RANGE;
2306
  TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
2307
  TYPE_NFIELDS (type) = 2;
2308
  TYPE_FIELDS (type)
2309
    = (struct field *) obstack_alloc (&objfile->type_obstack,
2310
                                      2 * sizeof (struct field));
2311
 
2312
  if (dn_bufp->dsubr.dyn_low)
2313
    TYPE_FIELD_BITPOS (type, 0) = 0;
2314
  else
2315
    TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound;
2316
 
2317
  if (dn_bufp->dsubr.dyn_high)
2318
    TYPE_FIELD_BITPOS (type, 1) = -1;
2319
  else
2320
    TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound;
2321
  TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype,
2322
                                                objfile);
2323
  return type;
2324
}
2325
 
2326
/* struct type * hpread_type_lookup(hp_type, objfile)
2327
 *   Arguments:
2328
 *     hp_type: A pointer into the DNTT specifying what type we
2329
 *              are about to "look up"., or else [for fundamental types
2330
 *              like int, float, ...] an "immediate" structure describing
2331
 *              the type.
2332
 *     objfile: ?
2333
 *   Return value: A pointer to a "struct type" (representation of a
2334
 *                 type in GDB's internal symbol table - see gdbtypes.h)
2335
 *   Routine description:
2336
 *     There are a variety of places when scanning the DNTT when we
2337
 *     need to interpret a "type" field. The simplest and most basic
2338
 *     example is when we're processing the symbol table record
2339
 *     for a data symbol (a SVAR or DVAR record). That has
2340
 *     a "type" field specifying the type of the data symbol. That
2341
 *     "type" field is either an "immediate" type specification (for the
2342
 *     fundamental types) or a DNTT pointer (for more complicated types).
2343
 *     For the more complicated types, we may or may not have already
2344
 *     processed the pointed-to type. (Multiple data symbols can of course
2345
 *     share the same type).
2346
 *     The job of hpread_type_lookup() is to process this "type" field.
2347
 *     Most of the real work is done in subroutines. Here we interpret
2348
 *     the immediate flag. If not immediate, chase the DNTT pointer to
2349
 *     find our way to the SOM record describing the type, switch on
2350
 *     the SOM kind, and then call an appropriate subroutine depending
2351
 *     on what kind of type we are constructing. (e.g., an array type,
2352
 *     a struct/class type, etc).
2353
 */
2354
static struct type *
2355
hpread_type_lookup (hp_type, objfile)
2356
     dnttpointer hp_type;
2357
     struct objfile *objfile;
2358
{
2359
  union dnttentry *dn_bufp;
2360
  struct type *tmp_type;
2361
 
2362
  /* First see if it's a simple builtin type.  */
2363
  if (hp_type.dntti.immediate)
2364
    /* If this is a template argument, the argument number is
2365
     * encoded in the bitlength. All other cases, just return
2366
     * GDB's representation of this fundamental type.
2367
     */
2368
    if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG)
2369
      return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength);
2370
    else
2371
      return lookup_fundamental_type (objfile, hpread_type_translate (hp_type));
2372
 
2373
  /* Not a builtin type.  We'll have to read it in.  */
2374
  if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile))
2375
    dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile);
2376
  else
2377
    /* This is a fancy way of returning NULL */
2378
    return lookup_fundamental_type (objfile, FT_VOID);
2379
 
2380
  switch (dn_bufp->dblock.kind)
2381
    {
2382
    case DNTT_TYPE_SRCFILE:
2383
    case DNTT_TYPE_MODULE:
2384
    case DNTT_TYPE_ENTRY:
2385
    case DNTT_TYPE_BEGIN:
2386
    case DNTT_TYPE_END:
2387
    case DNTT_TYPE_IMPORT:
2388
    case DNTT_TYPE_LABEL:
2389
    case DNTT_TYPE_FPARAM:
2390
    case DNTT_TYPE_SVAR:
2391
    case DNTT_TYPE_DVAR:
2392
    case DNTT_TYPE_CONST:
2393
    case DNTT_TYPE_MEMENUM:
2394
    case DNTT_TYPE_VARIANT:
2395
    case DNTT_TYPE_FILE:
2396
    case DNTT_TYPE_WITH:
2397
    case DNTT_TYPE_COMMON:
2398
    case DNTT_TYPE_COBSTRUCT:
2399
    case DNTT_TYPE_XREF:
2400
    case DNTT_TYPE_SA:
2401
    case DNTT_TYPE_MACRO:
2402
    case DNTT_TYPE_BLOCKDATA:
2403
    case DNTT_TYPE_CLASS_SCOPE:
2404
    case DNTT_TYPE_MEMACCESS:
2405
    case DNTT_TYPE_INHERITANCE:
2406
    case DNTT_TYPE_OBJECT_ID:
2407
    case DNTT_TYPE_FRIEND_CLASS:
2408
    case DNTT_TYPE_FRIEND_FUNC:
2409
      /* These are not types - something went wrong.  */
2410
      /* This is a fancy way of returning NULL */
2411
      return lookup_fundamental_type (objfile, FT_VOID);
2412
 
2413
    case DNTT_TYPE_FUNCTION:
2414
      /* We wind up here when dealing with class member functions
2415
       * (called from hpread_read_struct_type(), i.e. when processing
2416
       * the class definition itself).
2417
       */
2418
      return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
2419
 
2420
    case DNTT_TYPE_DOC_FUNCTION:
2421
      return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
2422
 
2423
    case DNTT_TYPE_TYPEDEF:
2424
      {
2425
        /* A typedef - chase it down by making a recursive call */
2426
        struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
2427
                                                      objfile);
2428
 
2429
        /* The following came from the base hpread.c that we inherited.
2430
         * It is WRONG so I have commented it out. - RT
2431
         *...
2432
 
2433
         char *suffix;
2434
         suffix = VT (objfile) + dn_bufp->dtype.name;
2435
         TYPE_NAME (structtype) = suffix;
2436
 
2437
         * ... further explanation ....
2438
         *
2439
         * What we have here is a typedef pointing to a typedef.
2440
         * E.g.,
2441
         * typedef int foo;
2442
         * typedef foo fum;
2443
         *
2444
         * What we desire to build is (these are pictures
2445
         * of "struct type"'s):
2446
         *
2447
         *  +---------+     +----------+     +------------+
2448
         *  | typedef |     | typedef  |     | fund. type |
2449
         *  |     type| ->  |      type| ->  |            |
2450
         *  | "fum"   |     | "foo"    |     | "int"      |
2451
         *  +---------+     +----------+     +------------+
2452
         *
2453
         * What this commented-out code is doing is smashing the
2454
         * name of pointed-to-type to be the same as the pointed-from
2455
         * type. So we wind up with something like:
2456
         *
2457
         *  +---------+     +----------+     +------------+
2458
         *  | typedef |     | typedef  |     | fund. type |
2459
         *  |     type| ->  |      type| ->  |            |
2460
         *  | "fum"   |     | "fum"    |     | "fum"      |
2461
         *  +---------+     +----------+     +------------+
2462
         *
2463
         */
2464
 
2465
        return structtype;
2466
      }
2467
 
2468
    case DNTT_TYPE_TAGDEF:
2469
      {
2470
        /* Just a little different from above.  We have to tack on
2471
         * an identifier of some kind (struct, union, enum, class, etc).
2472
         */
2473
        struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
2474
                                                      objfile);
2475
        char *prefix, *suffix;
2476
        suffix = VT (objfile) + dn_bufp->dtype.name;
2477
 
2478
        /* Lookup the next type in the list.  It should be a structure,
2479
         * union, class, enum, or template type.
2480
         * We will need to attach that to our name.
2481
         */
2482
        if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
2483
          dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
2484
        else
2485
          {
2486
            complain (&hpread_type_lookup_complaint);
2487
            return;
2488
          }
2489
 
2490
        if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
2491
          {
2492
            prefix = "struct ";
2493
          }
2494
        else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
2495
          {
2496
            prefix = "union ";
2497
          }
2498
        else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
2499
          {
2500
            /* Further field for CLASS saying how it was really declared */
2501
            /* 0==class, 1==union, 2==struct */
2502
            if (dn_bufp->dclass.class_decl == 0)
2503
              prefix = "class ";
2504
            else if (dn_bufp->dclass.class_decl == 1)
2505
              prefix = "union ";
2506
            else if (dn_bufp->dclass.class_decl == 2)
2507
              prefix = "struct ";
2508
            else
2509
              prefix = "";
2510
          }
2511
        else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM)
2512
          {
2513
            prefix = "enum ";
2514
          }
2515
        else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
2516
          {
2517
            prefix = "template ";
2518
          }
2519
        else
2520
          {
2521
            prefix = "";
2522
          }
2523
 
2524
        /* Build the correct name.  */
2525
        structtype->name
2526
          = (char *) obstack_alloc (&objfile->type_obstack,
2527
                                    strlen (prefix) + strlen (suffix) + 1);
2528
        TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix);
2529
        TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix);
2530
        TYPE_TAG_NAME (structtype) = suffix;
2531
 
2532
        /* For classes/structs, we have to set the static member "physnames"
2533
           to point to strings like "Class::Member" */
2534
        if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT)
2535
          fix_static_member_physnames (structtype, suffix, objfile);
2536
 
2537
        return structtype;
2538
      }
2539
 
2540
    case DNTT_TYPE_POINTER:
2541
      /* Pointer type - call a routine in gdbtypes.c that constructs
2542
       * the appropriate GDB type.
2543
       */
2544
      return make_pointer_type (
2545
                                 hpread_type_lookup (dn_bufp->dptr.pointsto,
2546
                                                     objfile),
2547
                                 NULL);
2548
 
2549
    case DNTT_TYPE_REFERENCE:
2550
      /* C++ reference type - call a routine in gdbtypes.c that constructs
2551
       * the appropriate GDB type.
2552
       */
2553
      return make_reference_type (
2554
                           hpread_type_lookup (dn_bufp->dreference.pointsto,
2555
                                               objfile),
2556
                                   NULL);
2557
 
2558
    case DNTT_TYPE_ENUM:
2559
      return hpread_read_enum_type (hp_type, dn_bufp, objfile);
2560
    case DNTT_TYPE_SET:
2561
      return hpread_read_set_type (hp_type, dn_bufp, objfile);
2562
    case DNTT_TYPE_SUBRANGE:
2563
      return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
2564
    case DNTT_TYPE_ARRAY:
2565
      return hpread_read_array_type (hp_type, dn_bufp, objfile);
2566
    case DNTT_TYPE_STRUCT:
2567
    case DNTT_TYPE_UNION:
2568
      return hpread_read_struct_type (hp_type, dn_bufp, objfile);
2569
    case DNTT_TYPE_FIELD:
2570
      return hpread_type_lookup (dn_bufp->dfield.type, objfile);
2571
 
2572
    case DNTT_TYPE_FUNCTYPE:
2573
      /* Here we want to read the function SOMs and return a
2574
       * type for it. We get here, for instance, when processing
2575
       * pointer-to-function type.
2576
       */
2577
      return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
2578
 
2579
    case DNTT_TYPE_PTRMEM:
2580
      /* Declares a C++ pointer-to-data-member type.
2581
       * The "pointsto" field defines the class,
2582
       * while the "memtype" field defines the pointed-to-type.
2583
       */
2584
      {
2585
        struct type *ptrmemtype;
2586
        struct type *class_type;
2587
        struct type *memtype;
2588
        memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
2589
                                      objfile),
2590
          class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
2591
                                           objfile),
2592
          ptrmemtype = alloc_type (objfile);
2593
        smash_to_member_type (ptrmemtype, class_type, memtype);
2594
        return make_pointer_type (ptrmemtype, NULL);
2595
      }
2596
      break;
2597
 
2598
    case DNTT_TYPE_PTRMEMFUNC:
2599
      /* Defines a C++ pointer-to-function-member type.
2600
       * The "pointsto" field defines the class,
2601
       * while the "memtype" field defines the pointed-to-type.
2602
       */
2603
      {
2604
        struct type *ptrmemtype;
2605
        struct type *class_type;
2606
        struct type *functype;
2607
        struct type *retvaltype;
2608
        int nargs;
2609
        int i;
2610
        struct type **args_type;
2611
        class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
2612
                                         objfile);
2613
        functype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
2614
                                       objfile);
2615
        retvaltype = TYPE_TARGET_TYPE (functype);
2616
        nargs = TYPE_NFIELDS (functype);
2617
        args_type = (struct type **) xmalloc ((nargs + 1) * sizeof (struct type *));
2618
        for (i = 0; i < nargs; i++)
2619
          {
2620
            args_type[i] = TYPE_FIELD_TYPE (functype, i);
2621
          }
2622
        args_type[nargs] = NULL;
2623
        ptrmemtype = alloc_type (objfile);
2624
        smash_to_method_type (ptrmemtype, class_type, retvaltype, args_type);
2625
        return make_pointer_type (ptrmemtype, NULL);
2626
      }
2627
      break;
2628
 
2629
    case DNTT_TYPE_CLASS:
2630
      return hpread_read_struct_type (hp_type, dn_bufp, objfile);
2631
 
2632
    case DNTT_TYPE_GENFIELD:
2633
      /* Chase pointer from GENFIELD to FIELD, and make recursive
2634
       * call on that.
2635
       */
2636
      return hpread_type_lookup (dn_bufp->dgenfield.field, objfile);
2637
 
2638
    case DNTT_TYPE_VFUNC:
2639
      /* C++ virtual function.
2640
       * We get here in the course of processing a class type which
2641
       * contains virtual functions. Just go through another level
2642
       * of indirection to get to the pointed-to function SOM.
2643
       */
2644
      return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile);
2645
 
2646
    case DNTT_TYPE_MODIFIER:
2647
      /* Check the modifiers and then just make a recursive call on
2648
       * the "type" pointed to by the modifier DNTT.
2649
       *
2650
       * pai:: FIXME -- do we ever want to handle "m_duplicate" and
2651
       * "m_void" modifiers?  Is static_flag really needed here?
2652
       * (m_static used for methods of classes, elsewhere).
2653
       */
2654
      tmp_type = make_cv_type (dn_bufp->dmodifier.m_const,
2655
                               dn_bufp->dmodifier.m_volatile,
2656
                      hpread_type_lookup (dn_bufp->dmodifier.type, objfile),
2657
                               0);
2658
      return tmp_type;
2659
 
2660
 
2661
    case DNTT_TYPE_MEMFUNC:
2662
      /* Member function. Treat like a function.
2663
       * I think we get here in the course of processing a
2664
       * pointer-to-member-function type...
2665
       */
2666
      return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
2667
 
2668
    case DNTT_TYPE_DOC_MEMFUNC:
2669
      return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
2670
 
2671
    case DNTT_TYPE_TEMPLATE:
2672
      /* Template - sort of the header for a template definition,
2673
       * which like a class, points to a member list and also points
2674
       * to a TEMPLATE_ARG list of type-arguments.
2675
       */
2676
      return hpread_read_struct_type (hp_type, dn_bufp, objfile);
2677
 
2678
    case DNTT_TYPE_TEMPLATE_ARG:
2679
      {
2680
        char *name;
2681
        /* The TEMPLATE record points to an argument list of
2682
         * TEMPLATE_ARG records, each of which describes one
2683
         * of the type-arguments.
2684
         */
2685
        name = VT (objfile) + dn_bufp->dtempl_arg.name;
2686
        return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name);
2687
      }
2688
 
2689
    case DNTT_TYPE_FUNC_TEMPLATE:
2690
      /* We wind up here when processing a TEMPLATE type,
2691
       * if the template has member function(s).
2692
       * Treat it like a FUNCTION.
2693
       */
2694
      return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
2695
 
2696
    case DNTT_TYPE_LINK:
2697
      /* The LINK record is used to link up templates with instantiations.
2698
       * There is no type associated with the LINK record per se.
2699
       */
2700
      return lookup_fundamental_type (objfile, FT_VOID);
2701
 
2702
      /* Also not yet handled... */
2703
      /* case DNTT_TYPE_DYN_ARRAY_DESC: */
2704
      /* case DNTT_TYPE_DESC_SUBRANGE: */
2705
      /* case DNTT_TYPE_BEGIN_EXT: */
2706
      /* case DNTT_TYPE_INLN: */
2707
      /* case DNTT_TYPE_INLN_LIST: */
2708
      /* case DNTT_TYPE_ALIAS: */
2709
    default:
2710
      /* A fancy way of returning NULL */
2711
      return lookup_fundamental_type (objfile, FT_VOID);
2712
    }
2713
}
2714
 
2715
static sltpointer
2716
hpread_record_lines (subfile, s_idx, e_idx, objfile, offset)
2717
     struct subfile *subfile;
2718
     sltpointer s_idx, e_idx;
2719
     struct objfile *objfile;
2720
     CORE_ADDR offset;
2721
{
2722
  union sltentry *sl_bufp;
2723
 
2724
  while (s_idx <= e_idx)
2725
    {
2726
      sl_bufp = hpread_get_slt (s_idx, objfile);
2727
      /* Only record "normal" entries in the SLT.  */
2728
      if (sl_bufp->snorm.sltdesc == SLT_NORMAL
2729
          || sl_bufp->snorm.sltdesc == SLT_EXIT)
2730
        record_line (subfile, sl_bufp->snorm.line,
2731
                     sl_bufp->snorm.address + offset);
2732
      else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
2733
        record_line (subfile, sl_bufp->snormoff.line,
2734
                     sl_bufp->snormoff.address + offset);
2735
      s_idx++;
2736
    }
2737
  return e_idx;
2738
}
2739
 
2740
/* Given a function "f" which is a member of a class, find
2741
 * the classname that it is a member of. Used to construct
2742
 * the name (e.g., "c::f") which GDB will put in the
2743
 * "demangled name" field of the function's symbol.
2744
 * Called from hpread_process_one_debug_symbol()
2745
 * If "f" is not a member function, return NULL.
2746
 */
2747
char *
2748
class_of (functype)
2749
     struct type *functype;
2750
{
2751
  struct type *first_param_type;
2752
  char *first_param_name;
2753
  struct type *pointed_to_type;
2754
  char *class_name;
2755
 
2756
  /* Check that the function has a first argument "this",
2757
   * and that "this" is a pointer to a class. If not,
2758
   * functype is not a member function, so return NULL.
2759
   */
2760
  if (TYPE_NFIELDS (functype) == 0)
2761
    return NULL;
2762
  first_param_name = TYPE_FIELD_NAME (functype, 0);
2763
  if (first_param_name == NULL)
2764
    return NULL;                /* paranoia */
2765
  if (strcmp (first_param_name, "this"))
2766
    return NULL;
2767
  first_param_type = TYPE_FIELD_TYPE (functype, 0);
2768
  if (first_param_type == NULL)
2769
    return NULL;                /* paranoia */
2770
  if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR)
2771
    return NULL;
2772
 
2773
  /* Get the thing that "this" points to, check that
2774
   * it's a class, and get its class name.
2775
   */
2776
  pointed_to_type = TYPE_TARGET_TYPE (first_param_type);
2777
  if (pointed_to_type == NULL)
2778
    return NULL;                /* paranoia */
2779
  if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS)
2780
    return NULL;
2781
  class_name = TYPE_NAME (pointed_to_type);
2782
  if (class_name == NULL)
2783
    return NULL;                /* paranoia */
2784
 
2785
  /* The class name may be of the form "class c", in which case
2786
   * we want to strip off the leading "class ".
2787
   */
2788
  if (strncmp (class_name, "class ", 6) == 0)
2789
    class_name += 6;
2790
 
2791
  return class_name;
2792
}
2793
 
2794
/* Internalize one native debug symbol.
2795
 * Called in a loop from hpread_expand_symtab().
2796
 * Arguments:
2797
 *   dn_bufp:
2798
 *   name:
2799
 *   section_offsets:
2800
 *   objfile:
2801
 *   text_offset:
2802
 *   text_size:
2803
 *   filename:
2804
 *   index:             Index of this symbol
2805
 *   at_module_boundary_p Pointer to boolean flag to control caller's loop.
2806
 */
2807
 
2808
static void
2809
hpread_process_one_debug_symbol (dn_bufp, name, section_offsets, objfile,
2810
                                 text_offset, text_size, filename,
2811
                                 index, at_module_boundary_p
2812
)
2813
     union dnttentry *dn_bufp;
2814
     char *name;
2815
     struct section_offsets *section_offsets;
2816
     struct objfile *objfile;
2817
     CORE_ADDR text_offset;
2818
     int text_size;
2819
     char *filename;
2820
     int index;
2821
     int *at_module_boundary_p;
2822
{
2823
  unsigned long desc;
2824
  int type;
2825
  CORE_ADDR valu;
2826
  int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
2827
  int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA);
2828
  union dnttentry *dn_temp;
2829
  dnttpointer hp_type;
2830
  struct symbol *sym;
2831
  struct context_stack *new;
2832
  char *class_scope_name;
2833
 
2834
  /* Allocate one GDB debug symbol and fill in some default values. */
2835
  sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
2836
                                         sizeof (struct symbol));
2837
  memset (sym, 0, sizeof (struct symbol));
2838
  SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->symbol_obstack);
2839
  SYMBOL_LANGUAGE (sym) = language_auto;
2840
  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2841
  SYMBOL_LINE (sym) = 0;
2842
  SYMBOL_VALUE (sym) = 0;
2843
  SYMBOL_CLASS (sym) = LOC_TYPEDEF;
2844
 
2845
  /* Just a trick in case the SOM debug symbol is a type definition.
2846
   * There are routines that are set up to build a GDB type symbol, given
2847
   * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
2848
   * This allows us to call those same routines.
2849
   */
2850
  hp_type.dnttp.extension = 1;
2851
  hp_type.dnttp.immediate = 0;
2852
  hp_type.dnttp.global = 0;
2853
  hp_type.dnttp.index = index;
2854
 
2855
  /* This "type" is the type of SOM record.
2856
   * Switch on SOM type.
2857
   */
2858
  type = dn_bufp->dblock.kind;
2859
  switch (type)
2860
    {
2861
    case DNTT_TYPE_SRCFILE:
2862
      /* This type of symbol indicates from which source file or
2863
       * include file any following data comes. It may indicate:
2864
       *
2865
       * o   The start of an entirely new source file (and thus
2866
       *     a new module)
2867
       *
2868
       * o   The start of a different source file due to #include
2869
       *
2870
       * o   The end of an include file and the return to the original
2871
       *     file. Thus if "foo.c" includes "bar.h", we see first
2872
       *     a SRCFILE for foo.c, then one for bar.h, and then one for
2873
       *     foo.c again.
2874
       *
2875
       * If it indicates the start of a new module then we must
2876
       * finish the symbol table of the previous module
2877
       * (if any) and start accumulating a new symbol table.
2878
       */
2879
 
2880
      valu = text_offset;
2881
      if (!last_source_file)
2882
        {
2883
          /*
2884
           * A note on "last_source_file": this is a char* pointing
2885
           * to the actual file name.  "start_symtab" sets it,
2886
           * "end_symtab" clears it.
2887
           *
2888
           * So if "last_source_file" is NULL, then either this is
2889
           * the first record we are looking at, or a previous call
2890
           * to "end_symtab()" was made to close out the previous
2891
           * module.  Since we're now quitting the scan loop when we
2892
           * see a MODULE END record, we should never get here, except
2893
           * in the case that we're not using the quick look-up tables
2894
           * and have to use the old system as a fall-back.
2895
           */
2896
          start_symtab (name, NULL, valu);
2897
          record_debugformat ("HP");
2898
          SL_INDEX (objfile) = dn_bufp->dsfile.address;
2899
        }
2900
 
2901
      else
2902
        {
2903
          /* Either a new include file, or a SRCFILE record
2904
           * saying we are back in the main source (or out of
2905
           * a nested include file) again.
2906
           */
2907
          SL_INDEX (objfile) = hpread_record_lines (current_subfile,
2908
                                                    SL_INDEX (objfile),
2909
                                                    dn_bufp->dsfile.address,
2910
                                                    objfile, offset);
2911
        }
2912
 
2913
      /* A note on "start_subfile".  This routine will check
2914
       * the name we pass it and look for an existing subfile
2915
       * of that name.  There's thus only one sub-file for the
2916
       * actual source (e.g. for "foo.c" in foo.c), despite the
2917
       * fact that we'll see lots of SRCFILE entries for foo.c
2918
       * inside foo.c.
2919
       */
2920
      start_subfile (name, NULL);
2921
      break;
2922
 
2923
    case DNTT_TYPE_MODULE:
2924
      /*
2925
       * We no longer ignore DNTT_TYPE_MODULE symbols.  The module
2926
       * represents the meaningful semantic structure of a compilation
2927
       * unit.  We expect to start the psymtab-to-symtab expansion
2928
       * looking at a MODULE entry, and to end it at the corresponding
2929
       * END MODULE entry.
2930
       *
2931
       *--Begin outdated comments
2932
       *
2933
       * This record signifies the start of a new source module
2934
       * In C/C++ there is no explicit "module" construct in the language,
2935
       * but each compilation unit is implicitly a module and they
2936
       * do emit the DNTT_TYPE_MODULE records.
2937
       * The end of the module is marked by a matching DNTT_TYPE_END record.
2938
       *
2939
       * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
2940
       * is it notices the DNTT_TYPE_END record for the previous
2941
       * module (see comments under DNTT_TYPE_END case), and then treats
2942
       * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
2943
       * (i.e., it makes a start_symtab() call).
2944
       * This scheme seems a little convoluted, but I'll leave it
2945
       * alone on the principle "if it ain't broke don't fix
2946
       * it". (RT).
2947
       *
2948
       *-- End outdated comments
2949
       */
2950
 
2951
      valu = text_offset;
2952
      if (!last_source_file)
2953
        {
2954
          /* Start of a new module. We know this because "last_source_file"
2955
           * is NULL, which can only happen the first time or if we just
2956
           * made a call to end_symtab() to close out the previous module.
2957
           */
2958
          start_symtab (name, NULL, valu);
2959
          SL_INDEX (objfile) = dn_bufp->dmodule.address;
2960
        }
2961
      else
2962
        {
2963
          /* This really shouldn't happen if we're using the quick
2964
           * look-up tables, as it would mean we'd scanned past an
2965
           * END MODULE entry.  But if we're not using the tables,
2966
           * we started the module on the SRCFILE entry, so it's ok.
2967
           * For now, accept this.
2968
           */
2969
          /* warning( "Error expanding psymtab, missed module end, found entry for %s",
2970
           *           name );
2971
           */
2972
          *at_module_boundary_p = -1;
2973
        }
2974
 
2975
      start_subfile (name, NULL);
2976
      break;
2977
 
2978
    case DNTT_TYPE_FUNCTION:
2979
    case DNTT_TYPE_ENTRY:
2980
      /* A function or secondary entry point.  */
2981
      valu = dn_bufp->dfunc.lowaddr + offset;
2982
 
2983
      /* Record lines up to this point. */
2984
      SL_INDEX (objfile) = hpread_record_lines (current_subfile,
2985
                                                SL_INDEX (objfile),
2986
                                                dn_bufp->dfunc.address,
2987
                                                objfile, offset);
2988
 
2989
      WITHIN_FUNCTION (objfile) = 1;
2990
      CURRENT_FUNCTION_VALUE (objfile) = valu;
2991
 
2992
      /* Stack must be empty now.  */
2993
      if (context_stack_depth != 0)
2994
        complain (&lbrac_unmatched_complaint, (char *) symnum);
2995
      new = push_context (0, valu);
2996
 
2997
      /* Built a type for the function. This includes processing
2998
       * the symbol records for the function parameters.
2999
       */
3000
      SYMBOL_CLASS (sym) = LOC_BLOCK;
3001
      SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1);
3002
 
3003
      /* The "SYMBOL_NAME" field is expected to be the mangled name
3004
       * (if any), which we get from the "alias" field of the SOM record
3005
       * if that exists.
3006
       */
3007
      if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
3008
          dn_bufp->dfunc.alias &&       /* has an alias */
3009
          *(char *) (VT (objfile) + dn_bufp->dfunc.alias))      /* not a null string */
3010
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias;
3011
      else
3012
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
3013
 
3014
      /* Special hack to get around HP compilers' insistence on
3015
       * reporting "main" as "_MAIN_" for C/C++ */
3016
      if ((strcmp (SYMBOL_NAME (sym), "_MAIN_") == 0) &&
3017
          (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0))
3018
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
3019
 
3020
      /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
3021
       * be the demangled name.
3022
       */
3023
      if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
3024
        {
3025
          /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
3026
           * calling the demangler in libiberty (cplus_demangle()) to
3027
           * do the job. This generally does the job, even though
3028
           * it's intended for the GNU compiler and not the aCC compiler
3029
           * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
3030
           * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
3031
           * Generally, we don't want params when we display
3032
           * a demangled name, but when I took out the DMGL_PARAMS,
3033
           * some things broke, so I'm leaving it in here, and
3034
           * working around the issue in stack.c. - RT
3035
           */
3036
          SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
3037
          if ((SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) &&
3038
              (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
3039
            {
3040
 
3041
              /* Well, the symbol name is mangled, but the
3042
               * demangler in libiberty failed so the demangled
3043
               * field is still NULL. Try to
3044
               * do the job ourselves based on the "name" field
3045
               * in the SOM record. A complication here is that
3046
               * the name field contains only the function name
3047
               * (like "f"), whereas we want the class qualification
3048
               * (as in "c::f"). Try to reconstruct that.
3049
               */
3050
              char *basename;
3051
              char *classname;
3052
              char *dem_name;
3053
              basename = VT (objfile) + dn_bufp->dfunc.name;
3054
              classname = class_of (SYMBOL_TYPE (sym));
3055
              if (classname)
3056
                {
3057
                  dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
3058
                  strcpy (dem_name, classname);
3059
                  strcat (dem_name, "::");
3060
                  strcat (dem_name, basename);
3061
                  SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
3062
                  SYMBOL_LANGUAGE (sym) = language_cplus;
3063
                }
3064
            }
3065
        }
3066
 
3067
      /* Add the function symbol to the list of symbols in this blockvector */
3068
      if (dn_bufp->dfunc.global)
3069
        add_symbol_to_list (sym, &global_symbols);
3070
      else
3071
        add_symbol_to_list (sym, &file_symbols);
3072
      new->name = sym;
3073
 
3074
      /* Search forward to the next BEGIN and also read
3075
       * in the line info up to that point.
3076
       * Not sure why this is needed.
3077
       * In HP FORTRAN this code is harmful since there
3078
       * may not be a BEGIN after the FUNCTION.
3079
       * So I made it C/C++ specific. - RT
3080
       */
3081
      if (dn_bufp->dfunc.language == HP_LANGUAGE_C ||
3082
          dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
3083
        {
3084
          while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
3085
            {
3086
              dn_bufp = hpread_get_lntt (++index, objfile);
3087
              if (dn_bufp->dblock.extension)
3088
                continue;
3089
            }
3090
          SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3091
                                                    SL_INDEX (objfile),
3092
                                                    dn_bufp->dbegin.address,
3093
                                                    objfile, offset);
3094
          SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
3095
        }
3096
      record_line (current_subfile, SYMBOL_LINE (sym), valu);
3097
      break;
3098
 
3099
    case DNTT_TYPE_DOC_FUNCTION:
3100
      valu = dn_bufp->ddocfunc.lowaddr + offset;
3101
 
3102
      /* Record lines up to this point. */
3103
      SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3104
                                                SL_INDEX (objfile),
3105
                                                dn_bufp->ddocfunc.address,
3106
                                                objfile, offset);
3107
 
3108
      WITHIN_FUNCTION (objfile) = 1;
3109
      CURRENT_FUNCTION_VALUE (objfile) = valu;
3110
      /* Stack must be empty now.  */
3111
      if (context_stack_depth != 0)
3112
        complain (&lbrac_unmatched_complaint, (char *) symnum);
3113
      new = push_context (0, valu);
3114
 
3115
      /* Built a type for the function. This includes processing
3116
       * the symbol records for the function parameters.
3117
       */
3118
      SYMBOL_CLASS (sym) = LOC_BLOCK;
3119
      SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1);
3120
 
3121
      /* The "SYMBOL_NAME" field is expected to be the mangled name
3122
       * (if any), which we get from the "alias" field of the SOM record
3123
       * if that exists.
3124
       */
3125
      if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
3126
          dn_bufp->ddocfunc.alias &&    /* has an alias */
3127
          *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias))   /* not a null string */
3128
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias;
3129
      else
3130
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
3131
 
3132
      /* Special hack to get around HP compilers' insistence on
3133
       * reporting "main" as "_MAIN_" for C/C++ */
3134
      if ((strcmp (SYMBOL_NAME (sym), "_MAIN_") == 0) &&
3135
          (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0))
3136
        SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
3137
 
3138
      if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
3139
        {
3140
 
3141
          /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
3142
           * calling the demangler in libiberty (cplus_demangle()) to
3143
           * do the job. This generally does the job, even though
3144
           * it's intended for the GNU compiler and not the aCC compiler
3145
           * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
3146
           * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
3147
           * Generally, we don't want params when we display
3148
           * a demangled name, but when I took out the DMGL_PARAMS,
3149
           * some things broke, so I'm leaving it in here, and
3150
           * working around the issue in stack.c. - RT
3151
           */
3152
          SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
3153
 
3154
          if ((SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) &&
3155
              (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
3156
            {
3157
 
3158
              /* Well, the symbol name is mangled, but the
3159
               * demangler in libiberty failed so the demangled
3160
               * field is still NULL. Try to
3161
               * do the job ourselves based on the "name" field
3162
               * in the SOM record. A complication here is that
3163
               * the name field contains only the function name
3164
               * (like "f"), whereas we want the class qualification
3165
               * (as in "c::f"). Try to reconstruct that.
3166
               */
3167
              char *basename;
3168
              char *classname;
3169
              char *dem_name;
3170
              basename = VT (objfile) + dn_bufp->ddocfunc.name;
3171
              classname = class_of (SYMBOL_TYPE (sym));
3172
              if (classname)
3173
                {
3174
                  dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
3175
                  strcpy (dem_name, classname);
3176
                  strcat (dem_name, "::");
3177
                  strcat (dem_name, basename);
3178
                  SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
3179
                  SYMBOL_LANGUAGE (sym) = language_cplus;
3180
                }
3181
            }
3182
        }
3183
 
3184
      /* Add the function symbol to the list of symbols in this blockvector */
3185
      if (dn_bufp->ddocfunc.global)
3186
        add_symbol_to_list (sym, &global_symbols);
3187
      else
3188
        add_symbol_to_list (sym, &file_symbols);
3189
      new->name = sym;
3190
 
3191
      /* Search forward to the next BEGIN and also read
3192
       * in the line info up to that point.
3193
       * Not sure why this is needed.
3194
       * In HP FORTRAN this code is harmful since there
3195
       * may not be a BEGIN after the FUNCTION.
3196
       * So I made it C/C++ specific. - RT
3197
       */
3198
      if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C ||
3199
          dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
3200
        {
3201
          while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
3202
            {
3203
              dn_bufp = hpread_get_lntt (++index, objfile);
3204
              if (dn_bufp->dblock.extension)
3205
                continue;
3206
            }
3207
          SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3208
                                                    SL_INDEX (objfile),
3209
                                                    dn_bufp->dbegin.address,
3210
                                                    objfile, offset);
3211
          SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
3212
        }
3213
      record_line (current_subfile, SYMBOL_LINE (sym), valu);
3214
      break;
3215
 
3216
    case DNTT_TYPE_BEGIN:
3217
      /* Begin a new scope. */
3218
      if (context_stack_depth == 1 /* this means we're at function level */  &&
3219
          context_stack[0].name != NULL /* this means it's a function */  &&
3220
          context_stack[0].depth == 0     /* this means it's the first BEGIN
3221
                                           we've seen after the FUNCTION */
3222
        )
3223
        {
3224
          /* This is the first BEGIN after a FUNCTION.
3225
           * We ignore this one, since HP compilers always insert
3226
           * at least one BEGIN, i.e. it's:
3227
           *
3228
           *     FUNCTION
3229
           *     argument symbols
3230
           *     BEGIN
3231
           *     local symbols
3232
           *        (possibly nested BEGIN ... END's if there are inner { } blocks)
3233
           *     END
3234
           *     END
3235
           *
3236
           * By ignoring this first BEGIN, the local symbols get treated
3237
           * as belonging to the function scope, and "print func::local_sym"
3238
           * works (which is what we want).
3239
           */
3240
 
3241
          /* All we do here is increase the depth count associated with
3242
           * the FUNCTION entry in the context stack. This ensures that
3243
           * the next BEGIN we see (if any), representing a real nested { }
3244
           * block, will get processed.
3245
           */
3246
 
3247
          context_stack[0].depth++;
3248
 
3249
        }
3250
      else
3251
        {
3252
 
3253
          /* Record lines up to this SLT pointer. */
3254
          SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3255
                                                    SL_INDEX (objfile),
3256
                                                    dn_bufp->dbegin.address,
3257
                                                    objfile, offset);
3258
          /* Calculate start address of new scope */
3259
          valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
3260
          valu += offset;       /* Relocate for dynamic loading */
3261
          /* We use the scope start DNTT index as nesting depth identifier! */
3262
          desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile);
3263
          new = push_context (desc, valu);
3264
        }
3265
      break;
3266
 
3267
    case DNTT_TYPE_END:
3268
      /* End a scope.  */
3269
 
3270
      /* Valid end kinds are:
3271
       *  MODULE
3272
       *  FUNCTION
3273
       *  WITH
3274
       *  COMMON
3275
       *  BEGIN
3276
       *  CLASS_SCOPE
3277
       */
3278
 
3279
      SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3280
                                                SL_INDEX (objfile),
3281
                                                dn_bufp->dend.address,
3282
                                                objfile, offset);
3283
      switch (dn_bufp->dend.endkind)
3284
        {
3285
        case DNTT_TYPE_MODULE:
3286
          /* Ending a module ends the symbol table for that module.
3287
           * Calling end_symtab() has the side effect of clearing the
3288
           * last_source_file pointer, which in turn signals
3289
           * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
3290
           * record as a module-begin.
3291
           */
3292
          valu = text_offset + text_size + offset;
3293
 
3294
          /* Tell our caller that we're done with expanding the
3295
           * debug information for a module.
3296
           */
3297
          *at_module_boundary_p = 1;
3298
 
3299
          /* Don't do this, as our caller will do it!
3300
 
3301
           *      (void) end_symtab (valu, objfile, 0);
3302
           */
3303
          break;
3304
 
3305
        case DNTT_TYPE_FUNCTION:
3306
          /* Ending a function, well, ends the function's scope.  */
3307
          dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
3308
                                     objfile);
3309
          valu = dn_temp->dfunc.hiaddr + offset;
3310
          /* Insert func params into local list */
3311
          merge_symbol_lists (&param_symbols, &local_symbols);
3312
          new = pop_context ();
3313
          /* Make a block for the local symbols within.  */
3314
          finish_block (new->name, &local_symbols, new->old_blocks,
3315
                        new->start_addr, valu, objfile);
3316
          WITHIN_FUNCTION (objfile) = 0; /* This may have to change for Pascal */
3317
          local_symbols = new->locals;
3318
          param_symbols = new->params;
3319
          break;
3320
 
3321
        case DNTT_TYPE_BEGIN:
3322
          if (context_stack_depth == 1 &&
3323
              context_stack[0].name != NULL &&
3324
              context_stack[0].depth == 1)
3325
            {
3326
              /* This is the END corresponding to the
3327
               * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
3328
               */
3329
              context_stack[0].depth--;
3330
            }
3331
          else
3332
            {
3333
              /* Ending a local scope.  */
3334
              valu = hpread_get_location (dn_bufp->dend.address, objfile);
3335
              /* Why in the hell is this needed?  */
3336
              valu += offset + 9;       /* Relocate for dynamic loading */
3337
              new = pop_context ();
3338
              desc = dn_bufp->dend.beginscope.dnttp.index;
3339
              if (desc != new->depth)
3340
                complain (&lbrac_mismatch_complaint, (char *) symnum);
3341
 
3342
              /* Make a block for the local symbols within.  */
3343
              finish_block (new->name, &local_symbols, new->old_blocks,
3344
                            new->start_addr, valu, objfile);
3345
              local_symbols = new->locals;
3346
              param_symbols = new->params;
3347
            }
3348
          break;
3349
 
3350
        case DNTT_TYPE_WITH:
3351
          /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
3352
           * we can ignore the DNTT_TYPE_END that ends it.
3353
           */
3354
          break;
3355
 
3356
        case DNTT_TYPE_COMMON:
3357
          /* End a FORTRAN common block. We don't currently handle these */
3358
          complain (&hpread_unhandled_end_common_complaint);
3359
          break;
3360
 
3361
        case DNTT_TYPE_CLASS_SCOPE:
3362
 
3363
          /* pai: FIXME Not handling nested classes for now -- must
3364
             * maintain a stack */
3365
          class_scope_name = NULL;
3366
 
3367
#if 0
3368
          /* End a class scope */
3369
          valu = hpread_get_location (dn_bufp->dend.address, objfile);
3370
          /* Why in the hell is this needed?  */
3371
          valu += offset + 9;   /* Relocate for dynamic loading */
3372
          new = pop_context ();
3373
          desc = dn_bufp->dend.beginscope.dnttp.index;
3374
          if (desc != new->depth)
3375
            complain (&lbrac_mismatch_complaint, (char *) symnum);
3376
          /* Make a block for the local symbols within.  */
3377
          finish_block (new->name, &local_symbols, new->old_blocks,
3378
                        new->start_addr, valu, objfile);
3379
          local_symbols = new->locals;
3380
          param_symbols = new->params;
3381
#endif
3382
          break;
3383
 
3384
        default:
3385
          complain (&hpread_unexpected_end_complaint);
3386
          break;
3387
        }
3388
      break;
3389
 
3390
      /* DNTT_TYPE_IMPORT is not handled */
3391
 
3392
    case DNTT_TYPE_LABEL:
3393
      SYMBOL_NAMESPACE (sym) = LABEL_NAMESPACE;
3394
      break;
3395
 
3396
    case DNTT_TYPE_FPARAM:
3397
      /* Function parameters.  */
3398
      /* Note 1: This code was present in the 4.16 sources, and then
3399
         removed, because fparams are handled in
3400
         hpread_read_function_type().  However, while fparam symbols
3401
         are indeed handled twice, this code here cannot be removed
3402
         because then they don't get added to the local symbol list of
3403
         the function's code block, which leads to a failure to look
3404
         up locals, "this"-relative member names, etc.  So I've put
3405
         this code back in. pai/1997-07-21 */
3406
      /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
3407
         in hpread_read_function_type(), so FPARAMS had to be handled
3408
         here.  I changed the location to be the appropriate argument
3409
         kinds rather than LOC_LOCAL. pai/1997-08-08 */
3410
      /* Note 3: Well, the fix in Note 2 above broke argument printing
3411
         in traceback frames, and further it makes assumptions about the
3412
         order of the FPARAM entries from HP compilers (cc and aCC in particular
3413
         generate them in reverse orders -- fixing one breaks for the other).
3414
         So I've added code in hpread_read_function_type() to add fparams
3415
         to a param_symbols list for the current context level.  These are
3416
         then merged into local_symbols when a function end is reached.
3417
         pai/1997-08-11 */
3418
 
3419
      break;                    /* do nothing; handled in hpread_read_function_type() */
3420
 
3421
#if 0                           /* Old code */
3422
      if (dn_bufp->dfparam.regparam)
3423
        SYMBOL_CLASS (sym) = LOC_REGISTER;
3424
      else if (dn_bufp->dfparam.indirect)
3425
        SYMBOL_CLASS (sym) = LOC_REF_ARG;
3426
      else
3427
        SYMBOL_CLASS (sym) = LOC_ARG;
3428
      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3429
      if (dn_bufp->dfparam.copyparam)
3430
        {
3431
          SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
3432
#ifdef HPREAD_ADJUST_STACK_ADDRESS
3433
          SYMBOL_VALUE (sym)
3434
            += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3435
#endif
3436
        }
3437
      else
3438
        SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
3439
      SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
3440
      add_symbol_to_list (sym, &fparam_symbols);
3441
      break;
3442
#endif
3443
 
3444
    case DNTT_TYPE_SVAR:
3445
      /* Static variables.  */
3446
      SYMBOL_CLASS (sym) = LOC_STATIC;
3447
 
3448
      /* Note: There is a case that arises with globals in shared
3449
       * libraries where we need to set the address to LOC_INDIRECT.
3450
       * This case is if you have a global "g" in one library, and
3451
       * it is referenced "extern <type> g;" in another library.
3452
       * If we're processing the symbols for the referencing library,
3453
       * we'll see a global "g", but in this case the address given
3454
       * in the symbol table contains a pointer to the real "g".
3455
       * We use the storage class LOC_INDIRECT to indicate this. RT
3456
       */
3457
      if (is_in_import_list (SYMBOL_NAME (sym), objfile))
3458
        SYMBOL_CLASS (sym) = LOC_INDIRECT;
3459
 
3460
      SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset;
3461
      SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
3462
 
3463
      if (dn_bufp->dsvar.global)
3464
        add_symbol_to_list (sym, &global_symbols);
3465
 
3466
      else if (WITHIN_FUNCTION (objfile))
3467
        add_symbol_to_list (sym, &local_symbols);
3468
 
3469
      else
3470
        add_symbol_to_list (sym, &file_symbols);
3471
 
3472
      if (dn_bufp->dsvar.thread_specific)
3473
        {
3474
          /* Thread-local variable.
3475
           */
3476
          SYMBOL_CLASS (sym) = LOC_THREAD_LOCAL_STATIC;
3477
          SYMBOL_BASEREG (sym) = CR27_REGNUM;
3478
 
3479
          if (objfile->flags & OBJF_SHARED)
3480
            {
3481
              /*
3482
               * This variable is not only thread local but
3483
               * in a shared library.
3484
               *
3485
               * Alas, the shared lib structures are private
3486
               * to "somsolib.c".  But C lets us point to one.
3487
               */
3488
              struct so_list *so;
3489
 
3490
              if (objfile->obj_private == NULL)
3491
                error ("Internal error in reading shared library information.");
3492
 
3493
              so = ((obj_private_data_t *) (objfile->obj_private))->so_info;
3494
              if (so == NULL)
3495
                error ("Internal error in reading shared library information.");
3496
 
3497
              /* Thread-locals in shared libraries do NOT have the
3498
               * standard offset ("data_offset"), so we re-calculate
3499
               * where to look for this variable, using a call-back
3500
               * to interpret the private shared-library data.
3501
               */
3502
              SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location +
3503
                so_lib_thread_start_addr (so);
3504
            }
3505
        }
3506
      break;
3507
 
3508
    case DNTT_TYPE_DVAR:
3509
      /* Dynamic variables.  */
3510
      if (dn_bufp->ddvar.regvar)
3511
        SYMBOL_CLASS (sym) = LOC_REGISTER;
3512
      else
3513
        SYMBOL_CLASS (sym) = LOC_LOCAL;
3514
 
3515
      SYMBOL_VALUE (sym) = dn_bufp->ddvar.location;
3516
#ifdef HPREAD_ADJUST_STACK_ADDRESS
3517
      SYMBOL_VALUE (sym)
3518
        += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3519
#endif
3520
      SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
3521
      if (dn_bufp->ddvar.global)
3522
        add_symbol_to_list (sym, &global_symbols);
3523
      else if (WITHIN_FUNCTION (objfile))
3524
        add_symbol_to_list (sym, &local_symbols);
3525
      else
3526
        add_symbol_to_list (sym, &file_symbols);
3527
      break;
3528
 
3529
    case DNTT_TYPE_CONST:
3530
      /* A constant (pascal?).  */
3531
      SYMBOL_CLASS (sym) = LOC_CONST;
3532
      SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
3533
      SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
3534
      if (dn_bufp->dconst.global)
3535
        add_symbol_to_list (sym, &global_symbols);
3536
      else if (WITHIN_FUNCTION (objfile))
3537
        add_symbol_to_list (sym, &local_symbols);
3538
      else
3539
        add_symbol_to_list (sym, &file_symbols);
3540
      break;
3541
 
3542
    case DNTT_TYPE_TYPEDEF:
3543
      /* A typedef. We do want to process these, since a name is
3544
       * added to the namespace for the typedef'ed name.
3545
       */
3546
      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3547
      SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
3548
      if (dn_bufp->dtype.global)
3549
        add_symbol_to_list (sym, &global_symbols);
3550
      else if (WITHIN_FUNCTION (objfile))
3551
        add_symbol_to_list (sym, &local_symbols);
3552
      else
3553
        add_symbol_to_list (sym, &file_symbols);
3554
      break;
3555
 
3556
    case DNTT_TYPE_TAGDEF:
3557
      {
3558
        int global = dn_bufp->dtag.global;
3559
        /* Structure, union, enum, template, or class tag definition */
3560
        /* We do want to process these, since a name is
3561
         * added to the namespace for the tag name (and if C++ class,
3562
         * for the typename also).
3563
         */
3564
        SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
3565
 
3566
        /* The tag contains in its "type" field a pointer to the
3567
         * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
3568
         * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
3569
         * record that actually defines the type.
3570
         */
3571
        SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
3572
        TYPE_NAME (sym->type) = SYMBOL_NAME (sym);
3573
        TYPE_TAG_NAME (sym->type) = SYMBOL_NAME (sym);
3574
        if (dn_bufp->dtag.global)
3575
          add_symbol_to_list (sym, &global_symbols);
3576
        else if (WITHIN_FUNCTION (objfile))
3577
          add_symbol_to_list (sym, &local_symbols);
3578
        else
3579
          add_symbol_to_list (sym, &file_symbols);
3580
 
3581
        /* If this is a C++ class, then we additionally
3582
         * need to define a typedef for the
3583
         * class type. E.g., so that the name "c" becomes visible as
3584
         * a type name when the user says "class c { ... }".
3585
         * In order to figure this out, we need to chase down the "type"
3586
         * field to get to the DNTT_TYPE_CLASS record.
3587
         *
3588
         * We also add the typename for ENUM. Though this isn't
3589
         * strictly correct, it is necessary because of the debug info
3590
         * generated by the aCC compiler, in which we cannot
3591
         * distinguish between:
3592
         *   enum e { ... };
3593
         * and
3594
         *   typedef enum { ... } e;
3595
         * I.e., the compiler emits the same debug info for the above
3596
         * two cases, in both cases "e" appearing as a tagdef.
3597
         * Therefore go ahead and generate the typename so that
3598
         * "ptype e" will work in the above cases.
3599
         *
3600
         * We also add the typename for TEMPLATE, so as to allow "ptype t"
3601
         * when "t" is a template name.
3602
         */
3603
        if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
3604
          dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
3605
        else
3606
          {
3607
            complain (&hpread_tagdef_complaint);
3608
            return;
3609
          }
3610
        if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
3611
            dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
3612
            dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3613
          {
3614
            struct symbol *newsym;
3615
 
3616
            newsym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3617
                                                    sizeof (struct symbol));
3618
            memset (newsym, 0, sizeof (struct symbol));
3619
            SYMBOL_NAME (newsym) = name;
3620
            SYMBOL_LANGUAGE (newsym) = language_auto;
3621
            SYMBOL_NAMESPACE (newsym) = VAR_NAMESPACE;
3622
            SYMBOL_LINE (newsym) = 0;
3623
            SYMBOL_VALUE (newsym) = 0;
3624
            SYMBOL_CLASS (newsym) = LOC_TYPEDEF;
3625
            SYMBOL_TYPE (newsym) = sym->type;
3626
            if (global)
3627
              add_symbol_to_list (newsym, &global_symbols);
3628
            else if (WITHIN_FUNCTION (objfile))
3629
              add_symbol_to_list (newsym, &local_symbols);
3630
            else
3631
              add_symbol_to_list (newsym, &file_symbols);
3632
          }
3633
      }
3634
      break;
3635
 
3636
    case DNTT_TYPE_POINTER:
3637
      /* Declares a pointer type. Should not be necessary to do anything
3638
       * with the type at this level; these are processed
3639
       * at the hpread_type_lookup() level.
3640
       */
3641
      break;
3642
 
3643
    case DNTT_TYPE_ENUM:
3644
      /* Declares an enum type. Should not be necessary to do anything
3645
       * with the type at this level; these are processed
3646
       * at the hpread_type_lookup() level.
3647
       */
3648
      break;
3649
 
3650
    case DNTT_TYPE_MEMENUM:
3651
      /* Member of enum */
3652
      /* Ignored at this level, but hpread_read_enum_type() will take
3653
       * care of walking the list of enumeration members.
3654
       */
3655
      break;
3656
 
3657
    case DNTT_TYPE_SET:
3658
      /* Declares a set type. Should not be necessary to do anything
3659
       * with the type at this level; these are processed
3660
       * at the hpread_type_lookup() level.
3661
       */
3662
      break;
3663
 
3664
    case DNTT_TYPE_SUBRANGE:
3665
      /* Declares a subrange type. Should not be necessary to do anything
3666
       * with the type at this level; these are processed
3667
       * at the hpread_type_lookup() level.
3668
       */
3669
      break;
3670
 
3671
    case DNTT_TYPE_ARRAY:
3672
      /* Declares an array type. Should not be necessary to do anything
3673
       * with the type at this level; these are processed
3674
       * at the hpread_type_lookup() level.
3675
       */
3676
      break;
3677
 
3678
    case DNTT_TYPE_STRUCT:
3679
    case DNTT_TYPE_UNION:
3680
      /* Declares an struct/union type.
3681
       * Should not be necessary to do anything
3682
       * with the type at this level; these are processed
3683
       * at the hpread_type_lookup() level.
3684
       */
3685
      break;
3686
 
3687
    case DNTT_TYPE_FIELD:
3688
      /* Structure/union/class field */
3689
      /* Ignored at this level, but hpread_read_struct_type() will take
3690
       * care of walking the list of structure/union/class members.
3691
       */
3692
      break;
3693
 
3694
      /* DNTT_TYPE_VARIANT is not handled by GDB */
3695
 
3696
      /* DNTT_TYPE_FILE is not handled by GDB */
3697
 
3698
    case DNTT_TYPE_FUNCTYPE:
3699
      /* Function type */
3700
      /* Ignored at this level, handled within hpread_type_lookup() */
3701
      break;
3702
 
3703
    case DNTT_TYPE_WITH:
3704
      /* This is emitted within methods to indicate "with <class>"
3705
       * scoping rules (i.e., indicate that the class data members
3706
       * are directly visible).
3707
       * However, since GDB already infers this by looking at the
3708
       * "this" argument, interpreting the DNTT_TYPE_WITH
3709
       * symbol record is unnecessary.
3710
       */
3711
      break;
3712
 
3713
    case DNTT_TYPE_COMMON:
3714
      /* FORTRAN common. Not yet handled. */
3715
      complain (&hpread_unhandled_common_complaint);
3716
      break;
3717
 
3718
      /* DNTT_TYPE_COBSTRUCT is not handled by GDB.  */
3719
      /* DNTT_TYPE_XREF is not handled by GDB.  */
3720
      /* DNTT_TYPE_SA is not handled by GDB.  */
3721
      /* DNTT_TYPE_MACRO is not handled by GDB */
3722
 
3723
    case DNTT_TYPE_BLOCKDATA:
3724
      /* Not sure what this is - part of FORTRAN support maybe?
3725
       * Anyway, not yet handled.
3726
       */
3727
      complain (&hpread_unhandled_blockdata_complaint);
3728
      break;
3729
 
3730
    case DNTT_TYPE_CLASS_SCOPE:
3731
 
3732
 
3733
 
3734
      /* The compiler brackets member functions with a CLASS_SCOPE/END
3735
       * pair of records, presumably to put them in a different scope
3736
       * from the module scope where they are normally defined.
3737
       * E.g., in the situation:
3738
       *   void f() { ... }
3739
       *   void c::f() { ...}
3740
       * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
3741
       * This causes "break f" at the module level to pick the
3742
       * the file-level function f(), not the member function
3743
       * (which needs to be referenced via "break c::f").
3744
       *
3745
       * Here we record the class name to generate the demangled names of
3746
       * member functions later.
3747
       *
3748
       * FIXME Not being used now for anything -- cplus_demangle seems
3749
       * enough for getting the class-qualified names of functions. We
3750
       * may need this for handling nested classes and types.  */
3751
 
3752
      /* pai: FIXME Not handling nested classes for now -- need to
3753
       * maintain a stack */
3754
 
3755
      dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile);
3756
      if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF)
3757
        class_scope_name = VT (objfile) + dn_temp->dtag.name;
3758
      else
3759
        class_scope_name = NULL;
3760
 
3761
#if 0
3762
 
3763
      /* Begin a new scope.  */
3764
      SL_INDEX (objfile) = hpread_record_lines (current_subfile,
3765
                                                SL_INDEX (objfile),
3766
                                              dn_bufp->dclass_scope.address,
3767
                                                objfile, offset);
3768
      valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile);
3769
      valu += offset;           /* Relocate for dynamic loading */
3770
      desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile);
3771
      /* We use the scope start DNTT index as the nesting depth identifier! */
3772
      new = push_context (desc, valu);
3773
#endif
3774
      break;
3775
 
3776
    case DNTT_TYPE_REFERENCE:
3777
      /* Declares a C++ reference type. Should not be necessary to do anything
3778
       * with the type at this level; these are processed
3779
       * at the hpread_type_lookup() level.
3780
       */
3781
      break;
3782
 
3783
    case DNTT_TYPE_PTRMEM:
3784
      /* Declares a C++ pointer-to-data-member type. This does not
3785
       * need to be handled at this level; being a type description it
3786
       * is instead handled at the hpread_type_lookup() level.
3787
       */
3788
      break;
3789
 
3790
    case DNTT_TYPE_PTRMEMFUNC:
3791
      /* Declares a C++ pointer-to-function-member type. This does not
3792
       * need to be handled at this level; being a type description it
3793
       * is instead handled at the hpread_type_lookup() level.
3794
       */
3795
      break;
3796
 
3797
    case DNTT_TYPE_CLASS:
3798
      /* Declares a class type.
3799
       * Should not be necessary to do anything
3800
       * with the type at this level; these are processed
3801
       * at the hpread_type_lookup() level.
3802
       */
3803
      break;
3804
 
3805
    case DNTT_TYPE_GENFIELD:
3806
      /* I believe this is used for class member functions */
3807
      /* Ignored at this level, but hpread_read_struct_type() will take
3808
       * care of walking the list of class members.
3809
       */
3810
      break;
3811
 
3812
    case DNTT_TYPE_VFUNC:
3813
      /* Virtual function */
3814
      /* This does not have to be handled at this level; handled in
3815
       * the course of processing class symbols.
3816
       */
3817
      break;
3818
 
3819
    case DNTT_TYPE_MEMACCESS:
3820
      /* DDE ignores this symbol table record.
3821
       * It has something to do with "modified access" to class members.
3822
       * I'll assume we can safely ignore it too.
3823
       */
3824
      break;
3825
 
3826
    case DNTT_TYPE_INHERITANCE:
3827
      /* These don't have to be handled here, since they are handled
3828
       * within hpread_read_struct_type() in the process of constructing
3829
       * a class type.
3830
       */
3831
      break;
3832
 
3833
    case DNTT_TYPE_FRIEND_CLASS:
3834
    case DNTT_TYPE_FRIEND_FUNC:
3835
      /* These can safely be ignored, as GDB doesn't need this
3836
       * info. DDE only uses it in "describe". We may later want
3837
       * to extend GDB's "ptype" to give this info, but for now
3838
       * it seems safe enough to ignore it.
3839
       */
3840
      break;
3841
 
3842
    case DNTT_TYPE_MODIFIER:
3843
      /* Intended to supply "modified access" to a type */
3844
      /* From the way DDE handles this, it looks like it always
3845
       * modifies a type. Therefore it is safe to ignore it at this
3846
       * level, and handle it in hpread_type_lookup().
3847
       */
3848
      break;
3849
 
3850
    case DNTT_TYPE_OBJECT_ID:
3851
      /* Just ignore this - that's all DDE does */
3852
      break;
3853
 
3854
    case DNTT_TYPE_MEMFUNC:
3855
      /* Member function */
3856
      /* This does not have to be handled at this level; handled in
3857
       * the course of processing class symbols.
3858
       */
3859
      break;
3860
 
3861
    case DNTT_TYPE_DOC_MEMFUNC:
3862
      /* Member function */
3863
      /* This does not have to be handled at this level; handled in
3864
       * the course of processing class symbols.
3865
       */
3866
      break;
3867
 
3868
    case DNTT_TYPE_TEMPLATE:
3869
      /* Template - sort of the header for a template definition,
3870
       * which like a class, points to a member list and also points
3871
       * to a TEMPLATE_ARG list of type-arguments.
3872
       * We do not need to process TEMPLATE records at this level though.
3873
       */
3874
      break;
3875
 
3876
    case DNTT_TYPE_TEMPLATE_ARG:
3877
      /* The TEMPLATE record points to an argument list of
3878
       * TEMPLATE_ARG records, each of which describes one
3879
       * of the type-arguments.
3880
       * We do not need to process TEMPLATE_ARG records at this level though.
3881
       */
3882
      break;
3883
 
3884
    case DNTT_TYPE_FUNC_TEMPLATE:
3885
      /* This will get emitted for member functions of templates.
3886
       * But we don't need to process this record at this level though,
3887
       * we will process it in the course of processing a TEMPLATE
3888
       * record.
3889
       */
3890
      break;
3891
 
3892
    case DNTT_TYPE_LINK:
3893
      /* The LINK record is used to link up templates with instantiations. */
3894
      /* It is not clear why this is needed, and furthermore aCC does
3895
       * not appear to generate this, so I think we can safely ignore it. - RT
3896
       */
3897
      break;
3898
 
3899
      /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
3900
      /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
3901
      /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
3902
      /* DNTT_TYPE_INLN is not handled by GDB */
3903
      /* DNTT_TYPE_INLN_LIST is not handled by GDB */
3904
      /* DNTT_TYPE_ALIAS is not handled by GDB */
3905
 
3906
    default:
3907
      break;
3908
    }
3909
}
3910
 
3911
/* Get nesting depth for a DNTT entry.
3912
 * DN_BUFP points to a DNTT entry.
3913
 * OBJFILE is the object file.
3914
 * REPORT_NESTED is a flag; if 0, real nesting depth is
3915
 * reported, if it is 1, the function simply returns a
3916
 * non-zero value if the nesting depth is anything > 0.
3917
 *
3918
 * Return value is an integer.  0 => not a local type / name
3919
 * positive return => type or name is local to some
3920
 * block or function.
3921
 */
3922
 
3923
 
3924
/* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
3925
   this function now returns 0 right away. It was taking too much time
3926
   at start up. Now, though, the local types are not handled correctly.
3927
 */
3928
 
3929
 
3930
static int
3931
hpread_get_scope_depth (dn_bufp, objfile, report_nested)
3932
     union dnttentry *dn_bufp;
3933
     struct objfile *objfile;
3934
     int report_nested;
3935
{
3936
  register int index;
3937
  register union dnttentry *dn_tmp;
3938
  register short depth = 0;
3939
/****************************/
3940
  return 0;
3941
/****************************/
3942
 
3943
  index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block));
3944
 
3945
  while (--index >= 0)
3946
    {
3947
      dn_tmp = hpread_get_lntt (index, objfile);
3948
      switch (dn_tmp->dblock.kind)
3949
        {
3950
        case DNTT_TYPE_MODULE:
3951
          return depth;
3952
        case DNTT_TYPE_END:
3953
          /* index is signed int; dnttp.index is 29-bit unsigned int! */
3954
          index = (int) dn_tmp->dend.beginscope.dnttp.index;
3955
          break;
3956
        case DNTT_TYPE_BEGIN:
3957
        case DNTT_TYPE_FUNCTION:
3958
        case DNTT_TYPE_DOC_FUNCTION:
3959
        case DNTT_TYPE_WITH:
3960
        case DNTT_TYPE_COMMON:
3961
        case DNTT_TYPE_CLASS_SCOPE:
3962
          depth++;
3963
          if (report_nested)
3964
            return 1;
3965
          break;
3966
        default:
3967
          break;
3968
        }
3969
    }
3970
  return depth;
3971
}
3972
 
3973
/* Adjust the bitoffsets for all fields of an anonymous union of
3974
   type TYPE by negative BITS.  This handles HP aCC's hideous habit
3975
   of giving members of anonymous unions bit offsets relative to the
3976
   enclosing structure instead of relative to the union itself. */
3977
 
3978
static void
3979
hpread_adjust_bitoffsets (type, bits)
3980
     struct type *type;
3981
     int bits;
3982
{
3983
  register int i;
3984
 
3985
  /* This is done only for unions; caller had better check that
3986
     it is an anonymous one. */
3987
  if (TYPE_CODE (type) != TYPE_CODE_UNION)
3988
    return;
3989
 
3990
  /* Adjust each field; since this is a union, there are no base
3991
     classes. Also no static membes.  Also, no need for recursion as
3992
     the members of this union if themeselves structs or unions, have
3993
     the correct bitoffsets; if an anonymous union is a member of this
3994
     anonymous union, the code in hpread_read_struct_type() will
3995
     adjust for that. */
3996
 
3997
  for (i = 0; i < TYPE_NFIELDS (type); i++)
3998
    TYPE_FIELD_BITPOS (type, i) -= bits;
3999
}
4000
 
4001
/* Because of quirks in HP compilers' treatment of anonymous unions inside
4002
   classes, we have to chase through a chain of threaded FIELD entries.
4003
   If we encounter an anonymous union in the chain, we must recursively skip over
4004
   that too.
4005
 
4006
   This function does a "next" in the chain of FIELD entries, but transparently
4007
   skips over anonymous unions' fields (recursively).
4008
 
4009
   Inputs are the number of times to do "next" at the top level, the dnttpointer
4010
   (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
4011
   and the ubiquitous objfile parameter. (Note: FIELDP is a **.)  Return value
4012
   is a dnttpointer for the new field after all the skipped ones */
4013
 
4014
static dnttpointer
4015
hpread_get_next_skip_over_anon_unions (skip_fields, field, fieldp, objfile)
4016
     int skip_fields;
4017
     dnttpointer field;
4018
     union dnttentry **fieldp;
4019
     struct objfile *objfile;
4020
{
4021
  struct type *anon_type;
4022
  register int i;
4023
  int bitoffset;
4024
  char *name;
4025
 
4026
  for (i = 0; i < skip_fields; i++)
4027
    {
4028
      /* Get type of item we're looking at now; recursively processes the types
4029
         of these intermediate items we skip over, so they aren't lost. */
4030
      anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile);
4031
      anon_type = CHECK_TYPEDEF (anon_type);
4032
      bitoffset = (*fieldp)->dfield.bitoffset;
4033
      name = VT (objfile) + (*fieldp)->dfield.name;
4034
      /* First skip over one item to avoid stack death on recursion */
4035
      field = (*fieldp)->dfield.nextfield;
4036
      *fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4037
      /* Do we have another anonymous union? If so, adjust the bitoffsets
4038
         of its members and skip over its members. */
4039
      if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) &&
4040
          (!name || STREQ (name, "")))
4041
        {
4042
          hpread_adjust_bitoffsets (anon_type, bitoffset);
4043
          field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile);
4044
        }
4045
    }
4046
  return field;
4047
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.