source: trunk/libs/newlib/src/include/hp-symtab.h @ 666

Last change on this file since 666 was 444, checked in by satin@…, 6 years ago

add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc
File size: 63.1 KB
Line 
1/* Definitions and structures for reading debug symbols from the
2   native HP C compiler.
3
4   Written by the Center for Software Science at the University of Utah
5   and by Cygnus Support.
6
7   Copyright 1994, 1995, 1998, 1999, 2003 Free Software Foundation, Inc.
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 3 of the License, or
12   (at your option) any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; if not, write to the Free Software
21   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22   MA 02110-1301, USA.  */
23
24#ifndef HP_SYMTAB_INCLUDED
25#define HP_SYMTAB_INCLUDED
26
27/* General information:
28
29   This header file defines and describes only the data structures
30   necessary to read debug symbols produced by the HP C compiler,
31   HP ANSI C++ compiler, and HP FORTRAN 90 compiler using the
32   SOM object file format. 
33   (For a full description of the debug format, ftp hpux-symtab.h from
34   jaguar.cs.utah.edu:/dist).
35   
36   Additional notes (Rich Title)
37   This file is a reverse-engineered version of a file called
38   "symtab.h" which exists internal to HP's Computer Languages Organization
39   in /CLO/Components/DDE/obj/som/symtab.h. Because HP's version of
40   the file is copyrighted and not distributed, it is necessary for
41   GDB to use the reverse-engineered version that follows.
42   Work was done by Cygnus to reverse-engineer the C subset of symtab.h.
43   The WDB project has extended this to also contain the C++
44   symbol definitions, the F90 symbol definitions,
45   and the DOC (debugging-optimized-code) symbol definitions.
46   In some cases (the C++ symbol definitions)
47   I have added internal documentation here that
48   goes beyond what is supplied in HP's symtab.h. If we someday
49   unify these files again, the extra comments should be merged back
50   into HP's symtab.h.
51 
52   -------------------------------------------------------------------
53
54   Debug symbols are contained entirely within an unloadable space called
55   $DEBUG$.  $DEBUG$ contains several subspaces which group related
56   debug symbols.
57
58   $GNTT$ contains information for global variables, types and contants.
59
60   $LNTT$ contains information for procedures (including nesting), scoping
61   information, local variables, types, and constants.
62
63   $SLT$ contains source line information so that code addresses may be
64   mapped to source lines.
65
66   $VT$ contains various strings and constants for named objects (variables,
67   typedefs, functions, etc).  Strings are stored as null-terminated character
68   lists.  Constants always begin on word boundaries.  The first byte of
69   the VT must be zero (a null string).
70
71   $XT$ is not currently used by GDB.
72
73   Many structures within the subspaces point to other structures within
74   the same subspace, or to structures within a different subspace.  These
75   pointers are represented as a structure index from the beginning of
76   the appropriate subspace.  */
77
78/* Used to describe where a constant is stored.  */
79enum location_type
80{
81  LOCATION_IMMEDIATE,
82  LOCATION_PTR,
83  LOCATION_VT,
84};
85
86/* Languages supported by this debug format.  Within the data structures
87   this type is limited to 4 bits for a maximum of 16 languages.  */
88enum hp_language
89{
90  HP_LANGUAGE_UNKNOWN,
91  HP_LANGUAGE_C,
92  HP_LANGUAGE_FORTRAN,
93  HP_LANGUAGE_F77 = HP_LANGUAGE_FORTRAN,
94  HP_LANGUAGE_PASCAL,
95  HP_LANGUAGE_MODCAL,
96  HP_LANGUAGE_COBOL,
97  HP_LANGUAGE_BASIC,
98  HP_LANGUAGE_ADA,
99  HP_LANGUAGE_CPLUSPLUS,
100  HP_LANGUAGE_DMPASCAL
101};
102
103
104/* Basic data types available in this debug format.  Within the data
105   structures this type is limited to 5 bits for a maximum of 32 basic
106   data types.  */
107enum hp_type
108{
109  HP_TYPE_UNDEFINED, /* 0 */
110  HP_TYPE_BOOLEAN, /* 1 */
111  HP_TYPE_CHAR, /* 2 */
112  HP_TYPE_INT, /* 3 */
113  HP_TYPE_UNSIGNED_INT, /* 4 */
114  HP_TYPE_REAL, /* 5 */
115  HP_TYPE_COMPLEX, /* 6 */
116  HP_TYPE_STRING200, /* 7 */
117  HP_TYPE_LONGSTRING200, /* 8 */
118  HP_TYPE_TEXT, /* 9 */
119  HP_TYPE_FLABEL, /* 10 */
120  HP_TYPE_FTN_STRING_SPEC, /* 11 */
121  HP_TYPE_MOD_STRING_SPEC, /* 12 */
122  HP_TYPE_PACKED_DECIMAL, /* 13 */
123  HP_TYPE_REAL_3000, /* 14 */
124  HP_TYPE_MOD_STRING_3000, /* 15 */
125  HP_TYPE_ANYPOINTER, /* 16 */
126  HP_TYPE_GLOBAL_ANYPOINTER, /* 17 */
127  HP_TYPE_LOCAL_ANYPOINTER, /* 18 */
128  HP_TYPE_COMPLEXS3000, /* 19 */
129  HP_TYPE_FTN_STRING_S300_COMPAT, /* 20 */ 
130  HP_TYPE_FTN_STRING_VAX_COMPAT, /* 21 */
131  HP_TYPE_BOOLEAN_S300_COMPAT, /* 22 */
132  HP_TYPE_BOOLEAN_VAX_COMPAT, /* 23 */
133  HP_TYPE_WIDE_CHAR, /* 24 */
134  HP_TYPE_LONG, /* 25 */
135  HP_TYPE_UNSIGNED_LONG, /* 26 */
136  HP_TYPE_DOUBLE, /* 27 */
137  HP_TYPE_TEMPLATE_ARG, /* 28 */
138  HP_TYPE_VOID /* 29 */
139};
140
141/* An immediate name and type table entry.
142
143   extension and immediate will always be one.
144   global will always be zero.
145   hp_type is the basic type this entry describes.
146   bitlength is the length in bits for the basic type.  */
147struct dnttp_immediate
148{
149  unsigned int extension:       1;
150  unsigned int immediate:       1;
151  unsigned int global:          1;
152  unsigned int type:            5;
153  unsigned int bitlength:       24;
154};
155
156/* A nonimmediate name and type table entry.
157
158   extension will always be one.
159   immediate will always be zero.
160   if global is zero, this entry points into the LNTT
161   if global is one, this entry points into the GNTT
162   index is the index within the GNTT or LNTT for this entry.  */
163struct dnttp_nonimmediate
164{
165  unsigned int extension:       1;
166  unsigned int immediate:       1;
167  unsigned int global:          1;
168  unsigned int index:           29;
169};
170
171/* A pointer to an entry in the GNTT and LNTT tables.  It has two
172   forms depending on the type being described.
173
174   The immediate form is used for simple entries and is one
175   word.
176
177   The nonimmediate form is used for complex entries and contains
178   an index into the LNTT or GNTT which describes the entire type.
179
180   If a dnttpointer is -1, then it is a NIL entry.  */
181
182#define DNTTNIL (-1)
183typedef union dnttpointer
184{
185  struct dnttp_immediate    dntti;
186  struct dnttp_nonimmediate dnttp;
187  int word;
188} dnttpointer;
189
190/* An index into the source line table.  As with dnttpointers, a sltpointer
191   of -1 indicates a NIL entry.  */
192#define SLTNIL (-1)
193typedef int sltpointer;
194
195/* Index into DOC (= "Debugging Optimized Code") line table.  */
196#define LTNIL (-1)
197typedef int ltpointer;
198
199/* Index into context table.  */
200#define CTXTNIL (-1)
201typedef int ctxtpointer;
202
203/* Unsigned byte offset into the VT.  */
204typedef unsigned int vtpointer;
205
206/* A DNTT entry (used within the GNTT and LNTT).
207
208   DNTT entries are variable sized objects, but are always a multiple
209   of 3 words (we call each group of 3 words a "block").
210
211   The first bit in each block is an extension bit.  This bit is zero
212   for the first block of a DNTT entry.  If the entry requires more
213   than one block, then this bit is set to one in all blocks after
214   the first one.  */
215
216/* Each DNTT entry describes a particular debug symbol (beginning of
217   a source file, a function, variables, structures, etc.
218
219   The type of the DNTT entry is stored in the "kind" field within the
220   DNTT entry itself.  */
221
222enum dntt_entry_type
223{
224  DNTT_TYPE_NIL = -1,
225  DNTT_TYPE_SRCFILE,
226  DNTT_TYPE_MODULE,
227  DNTT_TYPE_FUNCTION,
228  DNTT_TYPE_ENTRY,
229  DNTT_TYPE_BEGIN,
230  DNTT_TYPE_END,
231  DNTT_TYPE_IMPORT,
232  DNTT_TYPE_LABEL,
233  DNTT_TYPE_FPARAM,
234  DNTT_TYPE_SVAR,
235  DNTT_TYPE_DVAR,
236  DNTT_TYPE_HOLE1,
237  DNTT_TYPE_CONST,
238  DNTT_TYPE_TYPEDEF,
239  DNTT_TYPE_TAGDEF,
240  DNTT_TYPE_POINTER,
241  DNTT_TYPE_ENUM,
242  DNTT_TYPE_MEMENUM,
243  DNTT_TYPE_SET,
244  DNTT_TYPE_SUBRANGE,
245  DNTT_TYPE_ARRAY,
246  DNTT_TYPE_STRUCT,
247  DNTT_TYPE_UNION,
248  DNTT_TYPE_FIELD,
249  DNTT_TYPE_VARIANT,
250  DNTT_TYPE_FILE,
251  DNTT_TYPE_FUNCTYPE,
252  DNTT_TYPE_WITH,
253  DNTT_TYPE_COMMON,
254  DNTT_TYPE_COBSTRUCT,
255  DNTT_TYPE_XREF,
256  DNTT_TYPE_SA,
257  DNTT_TYPE_MACRO,
258  DNTT_TYPE_BLOCKDATA,
259  DNTT_TYPE_CLASS_SCOPE,
260  DNTT_TYPE_REFERENCE,
261  DNTT_TYPE_PTRMEM,
262  DNTT_TYPE_PTRMEMFUNC,
263  DNTT_TYPE_CLASS,
264  DNTT_TYPE_GENFIELD,
265  DNTT_TYPE_VFUNC,
266  DNTT_TYPE_MEMACCESS,
267  DNTT_TYPE_INHERITANCE,
268  DNTT_TYPE_FRIEND_CLASS,
269  DNTT_TYPE_FRIEND_FUNC,
270  DNTT_TYPE_MODIFIER,
271  DNTT_TYPE_OBJECT_ID,
272  DNTT_TYPE_MEMFUNC,
273  DNTT_TYPE_TEMPLATE,
274  DNTT_TYPE_TEMPLATE_ARG,
275  DNTT_TYPE_FUNC_TEMPLATE,
276  DNTT_TYPE_LINK,
277  DNTT_TYPE_DYN_ARRAY_DESC,
278  DNTT_TYPE_DESC_SUBRANGE,
279  DNTT_TYPE_BEGIN_EXT,
280  DNTT_TYPE_INLN,
281  DNTT_TYPE_INLN_LIST,
282  DNTT_TYPE_ALIAS,
283  DNTT_TYPE_DOC_FUNCTION,
284  DNTT_TYPE_DOC_MEMFUNC,
285  DNTT_TYPE_MAX
286};
287
288/* DNTT_TYPE_SRCFILE:
289
290   One DNTT_TYPE_SRCFILE symbol is output for the start of each source
291   file and at the begin and end of an included file.  A DNTT_TYPE_SRCFILE
292   entry is also output before each DNTT_TYPE_FUNC symbol so that debuggers
293   can determine what file a function was defined in.
294
295   LANGUAGE describes the source file's language.
296
297   NAME points to an VT entry providing the source file's name.
298
299   Note the name used for DNTT_TYPE_SRCFILE entries are exactly as seen
300   by the compiler (ie they may be relative or absolute).  C include files
301   via <> inclusion must use absolute paths.
302
303   ADDRESS points to an SLT entry from which line number and code locations
304   may be determined.  */
305
306struct dntt_type_srcfile
307{
308  unsigned int extension:       1;
309  unsigned int kind:            10;    /* DNTT_TYPE_SRCFILE */
310  unsigned int language:        4;
311  unsigned int unused:          17;
312  vtpointer name;
313  sltpointer address;
314};
315
316/* DNTT_TYPE_MODULE:
317
318   A DNTT_TYPE_MODULE symbol is emitted for the start of a pascal
319   module or C source file. A module indicates a compilation unit
320   for name-scoping purposes; in that regard there should be
321   a 1-1 correspondence between GDB "symtab"'s and MODULE symbol records.
322
323   Each DNTT_TYPE_MODULE must have an associated DNTT_TYPE_END symbol.
324
325   NAME points to a VT entry providing the module's name.  Note C
326   source files are considered nameless modules.
327
328   ALIAS point to a VT entry providing a secondary name.
329
330   ADDRESS points to an SLT entry from which line number and code locations
331   may be determined.  */
332
333struct dntt_type_module
334{
335  unsigned int extension:       1;
336  unsigned int kind:            10;     /* DNTT_TYPE_MODULE */
337  unsigned int unused:          21;
338  vtpointer name;
339  vtpointer alias;
340  dnttpointer unused2;
341  sltpointer address;
342};
343
344/* DNTT_TYPE_FUNCTION,
345   DNTT_TYPE_ENTRY,
346   DNTT_TYPE_BLOCKDATA,
347   DNTT_TYPE_MEMFUNC:
348
349   A DNTT_TYPE_FUNCTION symbol is emitted for each function definition;
350   a DNTT_TYPE_ENTRY symbols is used for secondary entry points.  Both
351   symbols used the dntt_type_function structure.
352   A DNTT_TYPE_BLOCKDATA symbol is emitted ...?
353   A DNTT_TYPE_MEMFUNC symbol is emitted for inlined member functions (C++).
354
355   Each of DNTT_TYPE_FUNCTION must have a matching DNTT_TYPE_END.
356
357   GLOBAL is nonzero if the function has global scope.
358
359   LANGUAGE describes the function's source language.
360
361   OPT_LEVEL describes the optimization level the function was compiled
362   with.
363
364   VARARGS is nonzero if the function uses varargs.
365
366   NAME points to a VT entry providing the function's name.
367
368   ALIAS points to a VT entry providing a secondary name for the function.
369
370   FIRSTPARAM points to a LNTT entry which describes the parameter list.
371
372   ADDRESS points to an SLT entry from which line number and code locations
373   may be determined.
374
375   ENTRYADDR is the memory address corresponding the function's entry point
376
377   RETVAL points to a LNTT entry describing the function's return value.
378
379   LOWADDR is the lowest memory address associated with this function.
380
381   HIADDR is the highest memory address associated with this function.  */
382
383struct dntt_type_function
384{
385  unsigned int extension:       1;
386  unsigned int kind:            10;     /* DNTT_TYPE_FUNCTION,
387                                           DNTT_TYPE_ENTRY,
388                                           DNTT_TYPE_BLOCKDATA
389                                           or DNTT_TYPE_MEMFUNC */
390  unsigned int global:          1;
391  unsigned int language:        4;
392  unsigned int nest_level:      5;
393  unsigned int opt_level:       2;
394  unsigned int varargs:         1;
395  unsigned int lang_info:       4;
396  unsigned int inlined:         1;
397  unsigned int localalloc:      1;
398  unsigned int expansion:       1;
399  unsigned int unused:          1;
400  vtpointer name;
401  vtpointer alias;
402  dnttpointer firstparam;
403  sltpointer address;
404  CORE_ADDR entryaddr;
405  dnttpointer retval;
406  CORE_ADDR lowaddr;
407  CORE_ADDR hiaddr;
408};
409
410/* DNTT_TYPE_BEGIN:
411
412   A DNTT_TYPE_BEGIN symbol is emitted to begin a new nested scope.
413   Every DNTT_TYPE_BEGIN symbol must have a matching DNTT_TYPE_END symbol.
414
415   CLASSFLAG is nonzero if this is the beginning of a c++ class definition.
416
417   ADDRESS points to an SLT entry from which line number and code locations
418   may be determined.  */
419
420struct dntt_type_begin
421{
422  unsigned int extension:       1;
423  unsigned int kind:            10;
424  unsigned int classflag:       1;
425  unsigned int unused:          20;
426  sltpointer address;
427};
428
429/* DNTT_TYPE_END:
430
431   A DNTT_TYPE_END symbol is emitted when closing a scope started by
432   a DNTT_TYPE_MODULE, DNTT_TYPE_FUNCTION, DNTT_TYPE_WITH,
433   DNTT_TYPE_COMMON, DNTT_TYPE_BEGIN, and DNTT_TYPE_CLASS_SCOPE symbols.
434
435   ENDKIND describes what type of scope the DNTT_TYPE_END is closing
436   (one of the above 6 kinds).
437
438   CLASSFLAG is nonzero if this is the end of a c++ class definition.
439
440   ADDRESS points to an SLT entry from which line number and code locations
441   may be determined.
442
443   BEGINSCOPE points to the LNTT entry which opened the scope.  */
444
445struct dntt_type_end
446{
447  unsigned int extension:       1;
448  unsigned int kind:            10;
449  unsigned int endkind:         10;
450  unsigned int classflag:       1;
451  unsigned int unused:          10;
452  sltpointer address;
453  dnttpointer beginscope;
454};
455
456/* DNTT_TYPE_IMPORT is unused by GDB.  */
457/* DNTT_TYPE_LABEL is unused by GDB.  */
458
459/* DNTT_TYPE_FPARAM:
460
461   A DNTT_TYPE_FPARAM symbol is emitted for a function argument.  When
462   chained together the symbols represent an argument list for a function.
463
464   REGPARAM is nonzero if this parameter was passed in a register.
465
466   INDIRECT is nonzero if this parameter is a pointer to the parameter
467   (pass by reference or pass by value for large items).
468
469   LONGADDR is nonzero if the parameter is a 64bit pointer.
470
471   NAME is a pointer into the VT for the parameter's name.
472
473   LOCATION describes where the parameter is stored.  Depending on the
474   parameter type LOCATION could be a register number, or an offset
475   from the stack pointer.
476
477   TYPE points to a NTT entry describing the type of this parameter.
478
479   NEXTPARAM points to the LNTT entry describing the next parameter.  */
480
481struct dntt_type_fparam
482{
483  unsigned int extension:       1;
484  unsigned int kind:            10;
485  unsigned int regparam:        1;
486  unsigned int indirect:        1;
487  unsigned int longaddr:        1;
488  unsigned int copyparam:       1;
489  unsigned int dflt:            1;
490  unsigned int doc_ranges:      1;
491  unsigned int misc_kind:       1;
492  unsigned int unused:          14;
493  vtpointer name;
494  CORE_ADDR location;
495  dnttpointer type;
496  dnttpointer nextparam;
497  int misc;
498};
499
500/* DNTT_TYPE_SVAR:
501
502   A DNTT_TYPE_SVAR is emitted to describe a variable in static storage.
503
504   GLOBAL is nonzero if the variable has global scope.
505
506   INDIRECT is nonzero if the variable is a pointer to an object.
507
508   LONGADDR is nonzero if the variable is in long pointer space.
509
510   STATICMEM is nonzero if the variable is a member of a class.
511
512   A_UNION is nonzero if the variable is an anonymous union member.
513
514   NAME is a pointer into the VT for the variable's name.
515
516   LOCATION provides the memory address for the variable.
517
518   TYPE is a pointer into either the GNTT or LNTT which describes
519   the type of this variable.  */
520
521struct dntt_type_svar
522{
523  unsigned int extension:       1;
524  unsigned int kind:            10;
525  unsigned int global:          1;
526  unsigned int indirect:        1;
527  unsigned int longaddr:        1;
528  unsigned int staticmem:       1;
529  unsigned int a_union:         1;
530  unsigned int unused1:         1;
531  unsigned int thread_specific: 1;
532  unsigned int unused2:         14;
533  vtpointer name;
534  CORE_ADDR location;
535  dnttpointer type;
536  unsigned int offset;
537  unsigned int displacement;
538};
539
540/* DNTT_TYPE_DVAR:
541
542   A DNTT_TYPE_DVAR is emitted to describe automatic variables and variables
543   held in registers.
544
545   GLOBAL is nonzero if the variable has global scope.
546
547   INDIRECT is nonzero if the variable is a pointer to an object.
548
549   REGVAR is nonzero if the variable is in a register.
550
551   A_UNION is nonzero if the variable is an anonymous union member.
552
553   NAME is a pointer into the VT for the variable's name.
554
555   LOCATION provides the memory address or register number for the variable.
556
557   TYPE is a pointer into either the GNTT or LNTT which describes
558   the type of this variable.  */
559
560struct dntt_type_dvar
561{
562  unsigned int extension:       1;
563  unsigned int kind:            10;
564  unsigned int global:          1;
565  unsigned int indirect:        1;
566  unsigned int regvar:          1;
567  unsigned int a_union:         1;
568  unsigned int unused:          17;
569  vtpointer name;
570  int location;
571  dnttpointer type;
572  unsigned int offset;
573};
574
575/* DNTT_TYPE_CONST:
576
577   A DNTT_TYPE_CONST symbol is emitted for program constants.
578
579   GLOBAL is nonzero if the constant has global scope.
580
581   INDIRECT is nonzero if the constant is a pointer to an object.
582
583   LOCATION_TYPE describes where to find the constant's value
584   (in the VT, memory, or embedded in an instruction).
585
586   CLASSMEM is nonzero if the constant is a member of a class.
587
588   NAME is a pointer into the VT for the constant's name.
589
590   LOCATION provides the memory address, register number or pointer
591   into the VT for the constant's value.
592
593   TYPE is a pointer into either the GNTT or LNTT which describes
594   the type of this variable.  */
595
596struct dntt_type_const
597{
598  unsigned int extension:       1;
599  unsigned int kind:            10;
600  unsigned int global:          1;
601  unsigned int indirect:        1;
602  unsigned int location_type:   3;
603  unsigned int classmem:        1;
604  unsigned int unused:          15;
605  vtpointer name;
606  CORE_ADDR location;
607  dnttpointer type;
608  unsigned int offset;
609  unsigned int displacement;
610};
611
612/* DNTT_TYPE_TYPEDEF and DNTT_TYPE_TAGDEF:
613
614   The same structure is used to describe typedefs and tagdefs.
615
616   DNTT_TYPE_TYPEDEFS are associated with C "typedefs".
617
618   DNTT_TYPE_TAGDEFs are associated with C "struct", "union", and "enum"
619   tags, which may have the same name as a typedef in the same scope.
620   Also they are associated with C++ "class" tags, which implicitly have
621   the same name as the class type.
622
623   GLOBAL is nonzero if the typedef/tagdef has global scope.
624
625   TYPEINFO is used to determine if full type information is available
626   for a tag.  (usually 1, but can be zero for opaque types in C).
627
628   NAME is a pointer into the VT for the constant's name.
629
630   TYPE points to the underlying type for the typedef/tagdef in the
631   GNTT or LNTT.  */
632
633struct dntt_type_type
634{
635  unsigned int extension:       1;
636  unsigned int kind:            10;    /* DNTT_TYPE_TYPEDEF or
637                                          DNTT_TYPE_TAGDEF.  */
638  unsigned int global:          1;
639  unsigned int typeinfo:        1;
640  unsigned int unused:          19;
641  vtpointer name;
642  dnttpointer type;                    /* Underlying type, which for TAGDEF's may be
643                                          DNTT_TYPE_STRUCT, DNTT_TYPE_UNION,
644                                          DNTT_TYPE_ENUM, or DNTT_TYPE_CLASS.
645                                          For TYPEDEF's other underlying types
646                                          are also possible.  */
647};
648
649/* DNTT_TYPE_POINTER:
650
651   Used to describe a pointer to an underlying type.
652
653   POINTSTO is a pointer into the GNTT or LNTT for the type which this
654   pointer points to.
655
656   BITLENGTH is the length of the pointer (not the underlying type). */
657
658struct dntt_type_pointer
659{
660  unsigned int extension:       1;
661  unsigned int kind:            10;
662  unsigned int unused:          21;
663  dnttpointer pointsto;
664  unsigned int bitlength;
665};
666
667
668/* DNTT_TYPE_ENUM:
669
670   Used to describe enumerated types.
671
672   FIRSTMEM is a pointer to a DNTT_TYPE_MEMENUM in the GNTT/LNTT which
673   describes the first member (and contains a pointer to the chain of
674   members).
675
676   BITLENGTH is the number of bits used to hold the values of the enum's
677   members.  */
678
679struct dntt_type_enum
680{
681  unsigned int extension:       1;
682  unsigned int kind:    10;
683  unsigned int unused:          21;
684  dnttpointer firstmem;
685  unsigned int bitlength;
686};
687
688/* DNTT_TYPE_MEMENUM
689
690   Used to describe members of an enumerated type.
691
692   CLASSMEM is nonzero if this member is part of a class.
693
694   NAME points into the VT for the name of this member.
695
696   VALUE is the value of this enumeration member.
697
698   NEXTMEM points to the next DNTT_TYPE_MEMENUM in the chain.  */
699
700struct dntt_type_memenum
701{
702  unsigned int extension:       1;
703  unsigned int kind:    10;
704  unsigned int classmem:        1;
705  unsigned int unused:          20;
706  vtpointer name;
707  unsigned int value;
708  dnttpointer nextmem;
709};
710
711/* DNTT_TYPE_SET
712
713   Used to describe PASCAL "set" type.
714
715   DECLARATION describes the bitpacking of the set.
716
717   SUBTYPE points to a DNTT entry describing the type of the members.
718
719   BITLENGTH is the size of the set.  */ 
720
721struct dntt_type_set
722{
723  unsigned int extension:       1;
724  unsigned int kind:    10;
725  unsigned int declaration:     2;
726  unsigned int unused:          19;
727  dnttpointer subtype;
728  unsigned int bitlength;
729};
730
731/* DNTT_TYPE_SUBRANGE
732
733   Used to describe subrange type.
734
735   DYN_LOW describes the lower bound of the subrange:
736
737     00 for a constant lower bound (found in LOWBOUND).
738
739     01 for a dynamic lower bound with the lower bound found in the
740     memory address pointed to by LOWBOUND.
741
742     10 for a dynamic lower bound described by an variable found in the
743     DNTT/LNTT (LOWBOUND would be a pointer into the DNTT/LNTT).
744
745   DYN_HIGH is similar to DYN_LOW, except it describes the upper bound.
746
747   SUBTYPE points to the type of the subrange.
748
749   BITLENGTH is the length in bits needed to describe the subrange's
750   values.  */
751
752struct dntt_type_subrange
753{
754  unsigned int extension:       1;
755  unsigned int kind:    10;
756  unsigned int dyn_low:         2;
757  unsigned int dyn_high:        2;
758  unsigned int unused:          17;
759  int lowbound;
760  int highbound;
761  dnttpointer subtype;
762  unsigned int bitlength;
763};
764
765/* DNTT_TYPE_ARRAY
766
767   Used to describe an array type.
768
769   DECLARATION describes the bit packing used in the array.
770
771   ARRAYISBYTES is nonzero if the field in arraylength describes the
772   length in bytes rather than in bits.  A value of zero is used to
773   describe an array with size 2**32.
774
775   ELEMISBYTES is nonzero if the length if each element in the array
776   is describes in bytes rather than bits.  A value of zero is used
777   to an element with size 2**32.
778
779   ELEMORDER is nonzero if the elements are indexed in increasing order.
780
781   JUSTIFIED if the elements are left justified to index zero.
782
783   ARRAYLENGTH is the length of the array.
784
785   INDEXTYPE is a DNTT pointer to the type used to index the array.
786
787   ELEMTYPE is a DNTT pointer to the type for the array elements.
788
789   ELEMLENGTH is the length of each element in the array (including
790   any padding).
791
792   Multi-dimensional arrays are represented by ELEMTYPE pointing to
793   another DNTT_TYPE_ARRAY.  */
794
795struct dntt_type_array
796{
797  unsigned int extension:       1;
798  unsigned int kind:    10;
799  unsigned int declaration:     2;
800  unsigned int dyn_low:         2;
801  unsigned int dyn_high:        2;
802  unsigned int arrayisbytes:    1;
803  unsigned int elemisbytes:     1;
804  unsigned int elemorder:       1;
805  unsigned int justified:       1;
806  unsigned int unused:          11;
807  unsigned int arraylength;
808  dnttpointer indextype;
809  dnttpointer elemtype;
810  unsigned int elemlength;
811};
812
813/* DNTT_TYPE_STRUCT
814
815   DNTT_TYPE_STRUCT is used to describe a C structure.
816
817   DECLARATION describes the bitpacking used.
818
819   FIRSTFIELD is a DNTT pointer to the first field of the structure
820   (each field contains a pointer to the next field, walk the list
821   to access all fields of the structure).
822
823   VARTAGFIELD and VARLIST are used for Pascal variant records.
824
825   BITLENGTH is the size of the structure in bits.  */
826
827struct dntt_type_struct
828{
829  unsigned int extension:       1;
830  unsigned int kind:    10;
831  unsigned int declaration:     2;
832  unsigned int unused:          19;
833  dnttpointer firstfield;
834  dnttpointer vartagfield;
835  dnttpointer varlist;
836  unsigned int bitlength;
837};
838
839/* DNTT_TYPE_UNION
840
841   DNTT_TYPE_UNION is used to describe a C union.
842
843   FIRSTFIELD is a DNTT pointer to the beginning of the field chain.
844
845   BITLENGTH is the size of the union in bits.  */
846
847struct dntt_type_union
848{
849  unsigned int extension:       1;
850  unsigned int kind:    10;
851  unsigned int unused:          21;
852  dnttpointer firstfield;
853  unsigned int bitlength;
854};
855
856/* DNTT_TYPE_FIELD
857
858   DNTT_TYPE_FIELD describes one field in a structure or union
859   or C++ class.
860
861   VISIBILITY is used to describe the visibility of the field
862   (for c++.  public = 0, protected = 1, private = 2).
863
864   A_UNION is nonzero if this field is a member of an anonymous union.
865
866   STATICMEM is nonzero if this field is a static member of a template.
867
868   NAME is a pointer into the VT for the name of the field.
869
870   BITOFFSET gives the offset of this field in bits from the beginning
871   of the structure or union this field is a member of.
872
873   TYPE is a DNTT pointer to the type describing this field.
874
875   BITLENGTH is the size of the entry in bits.
876
877   NEXTFIELD is a DNTT pointer to the next field in the chain.  */
878
879struct dntt_type_field
880{
881  unsigned int extension:       1;
882  unsigned int kind:    10;
883  unsigned int visibility:      2;
884  unsigned int a_union:         1;
885  unsigned int staticmem:       1;
886  unsigned int unused:          17;
887  vtpointer name;
888  unsigned int bitoffset;
889  dnttpointer type;
890  unsigned int bitlength;
891  dnttpointer nextfield;
892};
893
894/* DNTT_TYPE_VARIANT is unused by GDB.  */
895/* DNTT_TYPE_FILE is unused by GDB.  */
896
897/* DNTT_TYPE_FUNCTYPE
898
899   I think this is used to describe a function type (e.g., would
900   be emitted as part of a function-pointer description).
901
902   VARARGS is nonzero if this function uses varargs.
903
904   FIRSTPARAM is a DNTT pointer to the first entry in the parameter
905   chain.
906
907   RETVAL is a DNTT pointer to the type of the return value.  */
908
909struct dntt_type_functype
910{
911  unsigned int extension:       1;
912  unsigned int kind:            10;
913  unsigned int varargs:         1;
914  unsigned int info:            4;
915  unsigned int unused:          16;
916  unsigned int bitlength;
917  dnttpointer firstparam;
918  dnttpointer retval;
919};
920
921/* DNTT_TYPE_WITH is emitted by C++ to indicate "with" scoping semantics.
922   (Probably also emitted by PASCAL to support "with"...).
923   
924   C++ example: Say "memfunc" is a method of class "c", and say
925   "m" is a data member of class "c". Then from within "memfunc",
926   it is legal to reference "m" directly (e.g. you don't have to
927   say "this->m". The symbol table indicates
928   this by emitting a DNTT_TYPE_WITH symbol within the function "memfunc",
929   pointing to the type symbol for class "c".
930 
931   In GDB, this symbol record is unnecessary,
932   because GDB's symbol lookup algorithm
933   infers the "with" semantics when it sees a "this" argument to the member
934   function. So GDB can safely ignore the DNTT_TYPE_WITH record.
935
936   A DNTT_TYPE_WITH has a matching DNTT_TYPE_END symbol.  */
937
938struct dntt_type_with
939{
940  unsigned int extension:       1;    /* always zero */
941  unsigned int kind:            10;   /* always DNTT_TYPE_WITH */
942  unsigned int addrtype:        2;    /* 0 => STATTYPE                */
943                                      /* 1 => DYNTYPE                 */
944                                      /* 2 => REGTYPE                 */
945  unsigned int indirect:        1;    /* 1 => pointer to object       */
946  unsigned int longaddr:        1;    /* 1 => in long pointer space   */
947  unsigned int nestlevel:       6;    /* # of nesting levels back     */
948  unsigned int doc_ranges:      1;    /* 1 => location is range list  */
949  unsigned int unused:          10;
950  long location;                      /* where stored (allocated)     */
951  sltpointer address;
952  dnttpointer type;                   /* type of with expression      */
953  vtpointer name;                     /* name of with expression      */
954  unsigned long  offset;              /* byte offset from location    */
955};                                   
956
957/* DNTT_TYPE_COMMON is unsupported by GDB.  */
958/* A DNTT_TYPE_COMMON symbol must have a matching DNTT_TYPE_END symbol */
959
960/* DNTT_TYPE_COBSTRUCT is unsupported by GDB.  */
961/* DNTT_TYPE_XREF is unsupported by GDB.  */
962/* DNTT_TYPE_SA is unsupported by GDB.  */
963/* DNTT_TYPE_MACRO is unsupported by GDB */
964
965/* DNTT_TYPE_BLOCKDATA has the same structure as DNTT_TYPE_FUNCTION */
966
967/* The following are the C++ specific SOM records */
968
969/*  The purpose of the DNTT_TYPE_CLASS_SCOPE is to bracket C++ methods
970    and indicate the method name belongs in the "class scope" rather
971    than in the module they are being defined in. For example:
972
973    class c {
974    ...
975    void memfunc(); // member function
976    };
977
978    void c::memfunc()   // definition of class c's "memfunc"
979    {
980    ...
981    }
982
983    main()
984    {
985    ...
986    }
987
988    In the above, the name "memfunc" is not directly visible from "main".
989    I.e., you have to say "break c::memfunc".
990    If it were a normal function (not a method), it would be visible
991    via the simple "break memfunc". Since "memfunc" otherwise looks
992    like a normal FUNCTION in the symbol table, the bracketing
993    CLASS_SCOPE is what is used to indicate it is really a method.
994   
995
996   A DNTT_TYPE_CLASS_SCOPE symbol must have a matching DNTT_TYPE_END symbol.  */
997
998struct dntt_type_class_scope
999{
1000  unsigned int extension:   1;     /* Always zero.  */
1001  unsigned int kind:       10;     /* Always DNTT_TYPE_CLASS_SCOPE.  */
1002  unsigned int unused:     21; 
1003  sltpointer address         ;     /* Pointer to SLT entry.  */
1004  dnttpointer type           ;     /* Pointer to class type DNTT.  */
1005};
1006
1007/* C++ reference parameter.
1008   The structure of this record is the same as DNTT_TYPE_POINTER -
1009   refer to struct dntt_type_pointer.  */
1010
1011/* The next two describe C++ pointer-to-data-member type, and
1012   pointer-to-member-function type, respectively.
1013   DNTT_TYPE_PTRMEM and DNTT_TYPE_PTRMEMFUNC have the same structure.  */
1014
1015struct dntt_type_ptrmem
1016{
1017  unsigned int extension:   1;     /* Always zero.  */
1018  unsigned int kind:       10;     /* Always DNTT_TYPE_PTRMEM.  */
1019  unsigned int unused:     21;
1020  dnttpointer pointsto       ;     /* Pointer to class DNTT.  */
1021  dnttpointer memtype        ;     /* Type of member.  */
1022};
1023
1024struct dntt_type_ptrmemfunc
1025{
1026  unsigned int extension:   1;     /* Always zero.  */
1027  unsigned int kind:       10;     /* Always DNTT_TYPE_PTRMEMFUNC.  */
1028  unsigned int unused:     21;
1029  dnttpointer pointsto       ;     /* Pointer to class DNTT.  */
1030  dnttpointer memtype        ;     /* Type of member.  */
1031};
1032
1033/* The DNTT_TYPE_CLASS symbol is emitted to describe a class type.
1034   "memberlist" points to a chained list of FIELD or GENFIELD records
1035   indicating the class members. "parentlist" points to a chained list
1036   of INHERITANCE records indicating classes from which we inherit
1037   fields.  */
1038
1039struct dntt_type_class
1040{
1041  unsigned int extension:   1;     /* Always zero.  */
1042  unsigned int kind:       10;     /* Always DNTT_TYPE_CLASS.  */
1043  unsigned int abstract:    1;     /* Is this an abstract class?  */
1044  unsigned int class_decl:  2;     /* 0=class,1=union,2=struct.  */
1045  unsigned int expansion:   1;     /* 1=template expansion.  */
1046  unsigned int unused:     17;     
1047  dnttpointer memberlist     ;     /* Ptr to chain of [GEN]FIELDs.  */
1048  unsigned long vtbl_loc     ;     /* Offset in obj of ptr to vtbl.  */
1049  dnttpointer parentlist     ;     /* Ptr to K_INHERITANCE list.  */
1050  unsigned long bitlength    ;     /* Total at this level.  */
1051  dnttpointer identlist      ;     /* Ptr to chain of class ident's.  */
1052  dnttpointer friendlist     ;     /* Ptr to K_FRIEND list.  */
1053  dnttpointer templateptr    ;     /* Ptr to template.  */
1054  dnttpointer nextexp        ;     /* Ptr to next expansion.  */
1055};
1056
1057/* Class members are indicated via either the FIELD record (for
1058   data members, same as for C struct fields), or by the GENFIELD record
1059   (for member functions).  */
1060
1061struct dntt_type_genfield
1062{
1063  unsigned int extension:   1;     /* Always zero.  */
1064  unsigned int kind:       10;     /* Always DNTT_TYPE_GENFIELD.  */
1065  unsigned int visibility:  2;     /* Pub = 0, prot = 1, priv = 2.  */
1066  unsigned int a_union:     1;     /* 1 => anonymous union member.  */
1067  unsigned int unused:     18;
1068  dnttpointer field          ;     /* Pointer to field or qualifier.  */
1069  dnttpointer nextfield      ;     /* Pointer to next field.  */
1070};
1071
1072/* C++ virtual functions.  */
1073
1074struct dntt_type_vfunc
1075{
1076  unsigned int extension:   1;     /* always zero */
1077  unsigned int kind:       10;     /* always DNTT_TYPE_VFUNC */
1078  unsigned int pure:        1;     /* pure virtual function ?       */
1079  unsigned int unused:     20;
1080  dnttpointer funcptr        ;     /* points to FUNCTION symbol     */
1081  unsigned long vtbl_offset  ;     /* offset into vtbl for virtual  */
1082};
1083
1084/* Not precisely sure what this is intended for - DDE ignores it.  */
1085
1086struct dntt_type_memaccess
1087{
1088  unsigned int extension:   1;     /* always zero */
1089  unsigned int kind:       10;     /* always DNTT_TYPE_MEMACCESS */
1090  unsigned int unused:     21;
1091  dnttpointer classptr       ;     /* pointer to base class         */
1092  dnttpointer field          ;     /* pointer field                 */
1093};
1094
1095/* The DNTT_TYPE_INHERITANCE record describes derived classes.
1096   In particular, the "parentlist" field of the CLASS record points
1097   to a list of INHERITANCE records for classes from which we
1098   inherit members.  */
1099
1100struct dntt_type_inheritance
1101{
1102  unsigned int extension:   1;     /* always zero */
1103  unsigned int kind:       10;     /* always DNTT_TYPE_INHERITANCE */
1104  unsigned int Virtual:     1;     /* virtual base class ?          */
1105  unsigned int visibility:  2;     /* pub = 0, prot = 1, priv = 2   */
1106  unsigned int unused:     18;
1107  dnttpointer classname      ;     /* first parent class, if any    */
1108  unsigned long offset       ;     /* offset to start of base class */
1109  dnttpointer next           ;     /* pointer to next K_INHERITANCE */
1110  unsigned long future[2]    ;     /* padding to 3-word block end   */
1111};
1112
1113/* C++ "friend" classes ... */
1114
1115struct dntt_type_friend_class
1116{
1117  unsigned int extension:   1;     /* always zero */
1118  unsigned int kind:       10;     /* always DNTT_TYPE_FRIEND_CLASS */
1119  unsigned int unused:     21;
1120  dnttpointer classptr       ;     /* pointer to class DNTT         */
1121  dnttpointer next           ;     /* next DNTT_FRIEND              */
1122};
1123
1124struct dntt_type_friend_func
1125{
1126  unsigned int extension:   1;     /* always zero */
1127  unsigned int kind:       10;     /* always DNTT_TYPE_FRIEND_FUNC */
1128  unsigned int unused:     21;
1129  dnttpointer funcptr        ;     /* pointer to function           */
1130  dnttpointer classptr       ;     /* pointer to class DNTT         */
1131  dnttpointer next           ;     /* next DNTT_FRIEND              */
1132  unsigned long future[2]    ;     /* padding to 3-word block end   */
1133};
1134
1135/* DDE appears to ignore the DNTT_TYPE_MODIFIER record.
1136   It could perhaps be used to give better "ptype" output in GDB;
1137   otherwise it is probably safe for GDB to ignore it also.  */
1138
1139struct dntt_type_modifier
1140{
1141  unsigned int extension:   1;     /* always zero */
1142  unsigned int kind:       10;     /* always DNTT_TYPE_MODIFIER */
1143  unsigned int m_const:     1;     /* const                         */
1144  unsigned int m_static:    1;     /* static                        */
1145  unsigned int m_void:      1;     /* void                          */
1146  unsigned int m_volatile:  1;     /* volatile                      */
1147  unsigned int m_duplicate: 1;     /* duplicate                     */
1148  unsigned int unused:     16;
1149  dnttpointer type           ;     /* subtype                       */
1150  unsigned long future       ;     /* padding to 3-word block end   */
1151};
1152
1153/* I'm not sure what this was intended for - DDE ignores it.  */
1154
1155struct dntt_type_object_id
1156{
1157  unsigned int extension:   1;     /* always zero */
1158  unsigned int kind:       10;     /* always DNTT_TYPE_OBJECT_ID */
1159  unsigned int indirect:    1;     /* Is object_ident addr of addr? */
1160  unsigned int unused:     20;
1161  unsigned long object_ident ;     /* object identifier             */
1162  unsigned long offset       ;     /* offset to start of base class */
1163  dnttpointer next           ;     /* pointer to next K_OBJECT_ID   */
1164  unsigned long segoffset    ;     /* for linker fixup              */
1165  unsigned long future       ;     /* padding to 3-word block end   */
1166};
1167
1168/* No separate dntt_type_memfunc; same as dntt_type_func */
1169
1170/* Symbol records to support templates. These only get used
1171   in DDE's "describe" output (like GDB's "ptype").  */
1172
1173/* The TEMPLATE record is the header for a template-class.
1174   Like the CLASS record, a TEMPLATE record has a memberlist that
1175   points to a list of template members. It also has an arglist
1176   pointing to a list of TEMPLATE_ARG records.  */
1177
1178struct dntt_type_template
1179{
1180  unsigned int extension:   1;     /* always zero */
1181  unsigned int kind:       10;     /* always DNTT_TYPE_TEMPLATE */
1182  unsigned int abstract:    1;     /* is this an abstract class?    */
1183  unsigned int class_decl:  2;     /* 0=class,1=union,2=struct      */
1184  unsigned int unused:     18;
1185  dnttpointer memberlist     ;     /* ptr to chain of K_[GEN]FIELDs */
1186  long unused2               ;     /* offset in obj of ptr to vtbl  */
1187  dnttpointer parentlist     ;     /* ptr to K_INHERITANCE list     */
1188  unsigned long bitlength    ;     /* total at this level           */
1189  dnttpointer identlist      ;     /* ptr to chain of class ident's */
1190  dnttpointer friendlist     ;     /* ptr to K_FRIEND list          */
1191  dnttpointer arglist        ;     /* ptr to argument list          */
1192  dnttpointer expansions     ;     /* ptr to expansion list         */
1193};
1194
1195/* Template-class arguments are a list of TEMPL_ARG records
1196   chained together. The "name" field is the name of the formal.
1197   E.g.:
1198   
1199     template <class T> class q { ... };
1200   
1201   Then "T" is the name of the formal argument.  */
1202
1203struct dntt_type_templ_arg
1204{
1205  unsigned int extension:   1;     /* always zero */
1206  unsigned int kind:       10;     /* always DNTT_TYPE_TEMPL_ARG */
1207  unsigned int usagetype:   1;     /* 0 type-name 1 expression     */
1208  unsigned int unused:     20;
1209  vtpointer name             ;     /* name of argument             */
1210  dnttpointer type           ;     /* for non type arguments       */
1211  dnttpointer nextarg        ;     /* Next argument if any         */
1212  long future[2]             ;     /* padding to 3-word block end  */
1213};
1214
1215/* FUNC_TEMPLATE records are sort of like FUNCTION, but are emitted
1216   for template member functions. E.g.,
1217   
1218     template <class T> class q
1219     {
1220        ...
1221        void f();
1222        ...
1223     };
1224   
1225   Within the list of FIELDs/GENFIELDs defining the member list
1226   of the template "q", "f" would appear as a FUNC_TEMPLATE.
1227   We'll also see instances of FUNCTION "f" records for each
1228   instantiation of the template.  */
1229
1230struct dntt_type_func_template
1231{
1232  unsigned int extension:   1;     /* always zero */
1233  unsigned int kind:       10;     /* always DNTT_TYPE_FUNC_TEMPLATE */
1234  unsigned int public:      1;     /* 1 => globally visible        */
1235  unsigned int language:    4;     /* type of language             */
1236  unsigned int level:       5;     /* nesting level (top level = 0)*/
1237  unsigned int optimize:    2;     /* level of optimization        */
1238  unsigned int varargs:     1;     /* ellipses.  Pascal/800 later  */ 
1239  unsigned int info:        4;     /* lang-specific stuff; F_xxxx  */
1240  unsigned int inlined:     1;
1241  unsigned int localloc:    1;     /* 0 at top, 1 at end of block  */
1242  unsigned int unused:      2;
1243  vtpointer name             ;     /* name of function             */
1244  vtpointer alias            ;     /* alternate name, if any       */
1245  dnttpointer firstparam     ;     /* first FPARAM, if any         */
1246  dnttpointer retval         ;     /* return type, if any          */
1247  dnttpointer arglist        ;     /* ptr to argument list         */
1248};
1249
1250/* LINK is apparently intended to link together function template
1251   definitions with their instantiations. However, it is not clear
1252   why this would be needed, except to provide the information on
1253   a "ptype" command. And as far as I can tell, aCC does not
1254   generate this record.  */
1255
1256struct dntt_type_link
1257{
1258  unsigned int extension:   1;     /* always zero */
1259  unsigned int kind:       10;     /* always DNTT_TYPE_LINK */
1260  unsigned int linkKind:    4;     /* always LINK_UNKNOWN          */
1261  unsigned int unused:     17;
1262  long future1               ;     /* expansion                    */
1263  dnttpointer ptr1           ;     /* link from template           */
1264  dnttpointer ptr2           ;     /* to expansion                 */
1265  long future[2]             ;     /* padding to 3-word block end  */
1266};
1267
1268/* end of C++ specific SOM's.  */
1269
1270/* DNTT_TYPE_DYN_ARRAY_DESC is unused by GDB */
1271/* DNTT_TYPE_DESC_SUBRANGE is unused by GDB */
1272/* DNTT_TYPE_BEGIN_EXT is unused by GDB */
1273/* DNTT_TYPE_INLN is unused by GDB */
1274/* DNTT_TYPE_INLN_LIST is unused by GDB */
1275/* DNTT_TYPE_ALIAS is unused by GDB */
1276
1277struct dntt_type_doc_function
1278{
1279  unsigned int extension: 1;   /* always zero                  */
1280  unsigned int kind:     10;   /* K_DOC_FUNCTION or            */
1281                               /* K_DOC_MEMFUNC                */
1282  unsigned int global:    1;   /* 1 => globally visible        */
1283  unsigned int language:  4;   /* type of language             */
1284  unsigned int level:     5;   /* nesting level (top level = 0)*/
1285  unsigned int optimize:  2;   /* level of optimization        */
1286  unsigned int varargs:   1;   /* ellipses.  Pascal/800 later  */
1287  unsigned int info:      4;   /* lang-specific stuff; F_xxxx  */
1288  unsigned int inlined:   1;
1289  unsigned int localloc:  1;   /* 0 at top, 1 at end of block  */
1290  unsigned int expansion: 1;   /* 1 = function expansion       */
1291  unsigned int doc_clone: 1;
1292  vtpointer name;              /* name of function             */
1293  vtpointer alias;             /* alternate name, if any       */
1294  dnttpointer firstparam;      /* first FPARAM, if any         */
1295  sltpointer address;          /* code and text locations      */
1296  CORE_ADDR entryaddr;         /* address of entry point       */
1297  dnttpointer retval;          /* return type, if any          */
1298  CORE_ADDR lowaddr;           /* lowest address of function   */
1299  CORE_ADDR hiaddr;            /* highest address of function  */
1300  dnttpointer inline_list;     /* pointer to first inline    */
1301  ltpointer lt_offset;         /* start of frag/cp line table  */
1302  ctxtpointer ctxt_offset;     /* start of context table for this routine */
1303};
1304
1305/* DNTT_TYPE_DOC_MEMFUNC is unused by GDB */
1306
1307/* DNTT_TYPE_GENERIC and DNTT_TYPE_BLOCK are convience structures
1308   so we can examine a DNTT entry in a generic fashion.  */
1309struct dntt_type_generic
1310{
1311  unsigned int word[9];
1312};
1313
1314struct dntt_type_block
1315{
1316  unsigned int extension:       1;
1317  unsigned int kind:            10;
1318  unsigned int unused:          21;
1319  unsigned int word[2];
1320};
1321
1322/* One entry in a DNTT (either the LNTT or GNTT). 
1323   This is a union of the above 60 or so structure definitions.  */
1324
1325union dnttentry
1326{
1327  struct dntt_type_srcfile dsfile;
1328  struct dntt_type_module dmodule;
1329  struct dntt_type_function dfunc;
1330  struct dntt_type_function dentry;
1331  struct dntt_type_begin dbegin;
1332  struct dntt_type_end dend;
1333  struct dntt_type_fparam dfparam;
1334  struct dntt_type_svar dsvar;
1335  struct dntt_type_dvar ddvar;
1336  struct dntt_type_const dconst;
1337  struct dntt_type_type dtype;
1338  struct dntt_type_type dtag;
1339  struct dntt_type_pointer dptr;
1340  struct dntt_type_enum denum;
1341  struct dntt_type_memenum dmember;
1342  struct dntt_type_set dset;
1343  struct dntt_type_subrange dsubr;
1344  struct dntt_type_array darray;
1345  struct dntt_type_struct dstruct;
1346  struct dntt_type_union dunion;
1347  struct dntt_type_field dfield;
1348  struct dntt_type_functype dfunctype;
1349  struct dntt_type_with dwith;
1350  struct dntt_type_function dblockdata;
1351  struct dntt_type_class_scope dclass_scope;
1352  struct dntt_type_pointer dreference;
1353  struct dntt_type_ptrmem dptrmem;
1354  struct dntt_type_ptrmemfunc dptrmemfunc;
1355  struct dntt_type_class dclass;
1356  struct dntt_type_genfield dgenfield;
1357  struct dntt_type_vfunc dvfunc;
1358  struct dntt_type_memaccess dmemaccess;
1359  struct dntt_type_inheritance dinheritance;
1360  struct dntt_type_friend_class dfriend_class;
1361  struct dntt_type_friend_func dfriend_func;
1362  struct dntt_type_modifier dmodifier;
1363  struct dntt_type_object_id dobject_id;
1364  struct dntt_type_template dtemplate;
1365  struct dntt_type_templ_arg dtempl_arg;
1366  struct dntt_type_func_template dfunc_template;
1367  struct dntt_type_link dlink;
1368  struct dntt_type_doc_function ddocfunc;
1369  struct dntt_type_generic dgeneric;
1370  struct dntt_type_block dblock;
1371};
1372
1373/* Source line entry types.  */
1374enum slttype
1375{
1376  SLT_NORMAL,
1377  SLT_SRCFILE,
1378  SLT_MODULE,
1379  SLT_FUNCTION,
1380  SLT_ENTRY,
1381  SLT_BEGIN,
1382  SLT_END,
1383  SLT_WITH,
1384  SLT_EXIT,
1385  SLT_ASSIST,
1386  SLT_MARKER,
1387  SLT_CLASS_SCOPE,
1388  SLT_INLN,
1389  SLT_NORMAL_OFFSET,
1390};
1391
1392/* A normal source line entry.  Simply provides a mapping of a source
1393   line number to a code address.
1394
1395   SLTDESC will always be SLT_NORMAL or SLT_EXIT.  */
1396
1397struct slt_normal
1398{
1399  unsigned int sltdesc: 4;
1400  unsigned int line:    28;
1401  CORE_ADDR address;
1402};
1403
1404struct slt_normal_off
1405{
1406  unsigned int sltdesc: 4;
1407  unsigned int offset:  6;
1408  unsigned int line:    22;
1409  CORE_ADDR address;
1410};
1411
1412/* A special source line entry.  Provides a mapping of a declaration
1413   to a line number.  These entries point back into the DNTT which
1414   references them.  */
1415
1416struct slt_special
1417{
1418  unsigned int sltdesc: 4;
1419  unsigned int line:    28;
1420  dnttpointer backptr;
1421};
1422
1423/* Used to describe nesting.
1424
1425   For nested languages, an slt_assist entry must follow each SLT_FUNC
1426   entry in the SLT.  The address field will point forward to the
1427   first slt_normal entry within the function's scope.  */
1428
1429struct slt_assist
1430{
1431  unsigned int sltdesc: 4;
1432  unsigned int unused:  28;
1433  sltpointer address;
1434};
1435
1436struct slt_generic
1437{
1438  unsigned int word[2];
1439};
1440
1441union sltentry
1442{
1443  struct slt_normal snorm;
1444  struct slt_normal_off snormoff;
1445  struct slt_special sspec;
1446  struct slt_assist sasst;
1447  struct slt_generic sgeneric;
1448};
1449
1450/* $LINES$ declarations
1451   This is the line table used for optimized code, which is only present
1452   in the new $PROGRAM_INFO$ debug space.  */
1453
1454#define DST_LN_ESCAPE_FLAG1   15
1455#define DST_LN_ESCAPE_FLAG2   14
1456#define DST_LN_CTX_SPEC1      13 
1457#define DST_LN_CTX_SPEC2      12
1458
1459/* Escape function codes:  */
1460
1461typedef enum
1462{
1463  dst_ln_pad,          /* pad byte */
1464  dst_ln_escape_1,     /* reserved */
1465  dst_ln_dpc1_dln1,    /* 1 byte line delta, 1 byte pc delta */
1466  dst_ln_dpc2_dln2,    /* 2 bytes line delta, 2 bytes pc delta */
1467  dst_ln_pc4_ln4,      /* 4 bytes ABSOLUTE line number, 4 bytes ABSOLUTE pc */
1468  dst_ln_dpc0_dln1,    /* 1 byte line delta, pc delta = 0 */
1469  dst_ln_ln_off_1,     /* statement escape, stmt # = 1 (2nd stmt on line) */
1470  dst_ln_ln_off,       /* statement escape, stmt # = next byte */
1471  dst_ln_entry,        /* entry escape, next byte is entry number */
1472  dst_ln_exit,         /* exit escape */
1473  dst_ln_stmt_end,     /* gap escape, 4 bytes pc delta */
1474  dst_ln_stmt_cp,      /* current stmt is a critical point */
1475  dst_ln_escape_12,    /* reserved */
1476  dst_ln_escape_13,    /* this is an exception site record */
1477  dst_ln_nxt_byte,     /* next byte contains the real escape code */
1478  dst_ln_end,          /* end escape, final entry follows */
1479  dst_ln_escape1_END_OF_ENUM
1480}
1481dst_ln_escape1_t;
1482
1483typedef enum
1484{
1485  dst_ln_ctx_1,         /* next byte describes context switch with 5-bit */
1486                        /* index into the image table and 3-bit run length. */
1487                        /* If run length is 0, end with another cxt specifier or ctx_end */
1488  dst_ln_ctx_2,         /* next 2 bytes switch context: 13 bit index, 3 bit run length */
1489  dst_ln_ctx_4,         /* next 4 bytes switch context: 29 bit index, 3 bit run length */
1490  dst_ln_ctx_end,       /* end current context */
1491  dst_ln_col_run_1,     /* next byte is column position of start of next statement, */
1492                        /* following byte is length of statement */
1493  dst_ln_col_run_2,     /* next 2 bytes is column position of start of next statement, */
1494                        /* following 2 bytes is length of statement */
1495  dst_ln_init_base1,    /* next 4 bytes are absolute PC, followed by 1 byte of line number */
1496  dst_ln_init_base2,    /* next 4 bytes are absolute PC, followed by 2 bytes of line number */
1497  dst_ln_init_base3,    /* next 4 bytes are absolute PC, followed by 3 bytes of line number */
1498  dst_ln_escape2_END_OF_ENUM
1499}
1500dst_ln_escape2_t;           
1501
1502typedef union
1503{
1504  struct
1505  {
1506    unsigned int     pc_delta : 4;      /* 4 bit pc delta */
1507    int              ln_delta : 4;      /* 4 bit line number delta */
1508  }
1509  delta;
1510
1511  struct
1512  {
1513    unsigned int     esc_flag : 4;      /* alias for pc_delta  */
1514    unsigned int     esc_code : 4;      /* escape function code (dst_ln_escape1_t, or ...2_t */
1515  }
1516  esc;
1517
1518  struct
1519  {
1520    unsigned int     esc_flag   : 4;      /* dst_ln_ctx_spec1, or dst_ln_ctx_spec2 */
1521    unsigned int     run_length : 2;     
1522    unsigned int     ctx_index  : 2;      /* ...spec2 contains index;  ...spec1, index - 4 */
1523  }
1524  ctx_spec;
1525
1526  char               sdata;               /* signed data byte */
1527  unsigned char      udata;               /* unsigned data byte */
1528}
1529dst_ln_entry_t,
1530  * dst_ln_entry_ptr_t;
1531
1532/* Warning: although the above union occupies only 1 byte the compiler treats
1533   it as having size 2 (the minimum size of a struct).  Therefore a sequence of
1534   dst_ln_entry_t's cannot be described as an array, and walking through such a
1535   sequence requires convoluted code such as
1536        ln_ptr = (dst_ln_entry_ptr_t) (char*) ln_ptr + 1
1537   We regret the inconvenience.  */
1538
1539/* Structure for interpreting the byte following a dst_ln_ctx1 entry.  */
1540typedef struct
1541{
1542    unsigned int          ctx1_index : 5;      /* 5 bit index into context table */
1543    unsigned int          ctx1_run_length : 3; /* 3 bit run length */
1544} dst_ln_ctx1_t,
1545  *dst_ln_ctx1_ptr_t;
1546
1547/* Structure for interpreting the bytes following a dst_ln_ctx2 entry.  */
1548typedef struct
1549{
1550    unsigned int          ctx2_index : 13;     /* 13 bit index into context table */
1551    unsigned int          ctx2_run_length : 3; /* 3 bit run length */
1552} dst_ln_ctx2_t,
1553  *dst_ln_ctx2_ptr_t;
1554
1555/* Structure for interpreting the bytes following a dst_ln_ctx4 entry.  */
1556typedef struct
1557{
1558    unsigned int          ctx4_index : 29;     /* 29 bit index into context table */
1559    unsigned int          ctx4_run_length : 3; /* 3 bit run length */
1560} dst_ln_ctx4_t,
1561  *dst_ln_ctx4_ptr_t;
1562
1563
1564/*  PXDB definitions.
1565 
1566   PXDB is a post-processor which takes the executable file
1567   and massages the debug information so that the debugger may
1568   start up and run more efficiently.  Some of the tasks
1569   performed by PXDB are:
1570 
1571   o   Remove duplicate global type and variable information
1572       from the GNTT,
1573 
1574   o   Append the GNTT onto the end of the LNTT and place both
1575       back in the LNTT section,
1576 
1577   o   Build quick look-up tables (description follows) for
1578       files, procedures, modules, and paragraphs (for Cobol),
1579       placing these in the GNTT section,
1580 
1581   o   Reconstruct the header appearing in the header section
1582       to access this information.
1583 
1584   The "quick look-up" tables are in the $GNTT$ sub-space, in
1585   the following order:
1586 
1587       Procedures    -sorted by address
1588       Source files  -sorted by address (of the
1589                      generated code from routines)
1590       Modules       -sorted by address
1591       Classes       -<unsorted?>
1592       Address Alias -sorted by index <?>
1593       Object IDs    -sorted by object identifier
1594 
1595   Most quick entries have (0-based) indices into the LNTT tables to
1596   the full entries for the item it describes.
1597 
1598   The post-PXDB header is in the $HEADER$ sub-space.  Alas, it
1599   occurs in different forms, depending on the optimization level
1600   in the compilation step and whether PXDB was run or not. The
1601   worst part is the forms aren't self-describing, so we'll have
1602   to grovel in the bits to figure out what kind we're looking at
1603   (see hp_get_header in hp-psymtab-read.c).  */
1604
1605/* PXDB versions.  */
1606
1607#define PXDB_VERSION_CPLUSPLUS  1
1608#define PXDB_VERSION_7_4        2
1609#define PXDB_VERSION_CPP_30     3
1610#define PXDB_VERSION_DDE_3_2A   4
1611#define PXDB_VERSION_DDE_3_2    5
1612#define PXDB_VERSION_DDE_4_0    6
1613
1614#define PXDB_VERSION_2_1        1
1615
1616/* Header version for the case that there is no DOC info
1617   but the executable has been processed by pxdb (the easy
1618   case, from "cc -g").  */
1619
1620typedef struct PXDB_struct
1621{
1622  int              pd_entries;   /* # of entries in function look-up table */
1623  int              fd_entries;   /* # of entries in file look-up table */
1624  int              md_entries;   /* # of entries in module look-up table */
1625  unsigned int     pxdbed : 1;   /* 1 => file has been preprocessed      */
1626  unsigned int     bighdr : 1;   /* 1 => this header contains 'time' word */
1627  unsigned int     sa_header : 1;/* 1 => created by SA version of pxdb */
1628                                   /*   used for version check in xdb */
1629  unsigned int     inlined: 1;   /* one or more functions have been inlined */
1630  unsigned int     spare:12;
1631  short            version;      /* pxdb header version */
1632  int              globals;      /* index into the DNTT where GNTT begins */
1633  unsigned int     time;         /* modify time of file before being pxdbed */
1634  int              pg_entries;   /* # of entries in label look-up table */
1635  int              functions;    /* actual number of functions */
1636  int              files;        /* actual number of files */
1637  int              cd_entries;   /* # of entries in class look-up table */
1638  int              aa_entries;   /* # of entries in addr alias look-up table */
1639  int              oi_entries;   /* # of entries in object id look-up table */
1640} PXDB_header, *PXDB_header_ptr;
1641
1642/* Header version for the case that there is no DOC info and the
1643   executable has NOT been processed by pxdb.  */
1644
1645typedef struct XDB_header_struct
1646{
1647  long gntt_length; 
1648  long lntt_length; 
1649  long slt_length; 
1650  long vt_length; 
1651  long xt_length; 
1652} XDB_header;
1653
1654/* Header version for the case that there is DOC info and the
1655   executable has been processed by pxdb. */
1656
1657typedef struct DOC_info_PXDB_header_struct
1658{
1659  unsigned int xdb_header: 1;         /* bit set if this is post-3.1 xdb */ 
1660  unsigned int doc_header: 1;         /* bit set if this is doc-style header */
1661  unsigned int version: 8;            /* version of pxdb see defines
1662                                         PXDB_VERSION_* in this file.  */
1663  unsigned int reserved_for_flags: 16;/* for future use; -- must be
1664                                         set to zero.  */
1665  unsigned int has_aux_pd_table: 1;   /* $GNTT$ has aux PD table */
1666  unsigned int has_expr_table: 1;     /* space has $EXPR$ */       
1667  unsigned int has_range_table: 1;    /* space has $RANGE$ */       
1668  unsigned int has_context_table: 1;  /* space has $SRC_CTXT$ */   
1669  unsigned int has_lines_table: 1;    /* space contains a $LINES$
1670                                         subspace for line tables.  */
1671  unsigned int has_lt_offset_map: 1;  /* space contains an lt_offset
1672                                         subspace for line table mapping.  */
1673  /* The following fields are the same as those in the PXDB_header in $DEBUG$ */
1674  int           pd_entries;   /* # of entries in function look-up table */
1675  int           fd_entries;   /* # of entries in file look-up table */
1676  int           md_entries;   /* # of entries in module look-up table */
1677  unsigned int  pxdbed : 1;   /* 1 => file has been preprocessed      */
1678  unsigned int  bighdr : 1;   /* 1 => this header contains 'time' word */
1679  unsigned int  sa_header : 1;/* 1 => created by SA version of pxdb */
1680                              /*   used for version check in xdb */
1681  unsigned int  inlined: 1;   /* one or more functions have been inlined */
1682  unsigned int  spare : 28;
1683  int           globals;      /* index into the DNTT where GNTT begins */
1684  unsigned int  time;         /* modify time of file before being pxdbed */
1685  int           pg_entries;   /* # of entries in label look-up table */
1686  int           functions;    /* actual number of functions */
1687  int           files;        /* actual number of files */
1688  int           cd_entries;   /* # of entries in class look-up table */
1689  int           aa_entries;   /* # of entries in addr alias look-up table */
1690  int           oi_entries;   /* # of entries in object id look-up table */
1691} DOC_info_PXDB_header;
1692
1693/* Header version for the case that there is DOC info and the
1694   executable has NOT been processed by pxdb.  */
1695
1696typedef struct DOC_info_header_struct
1697{
1698  unsigned int xdb_header: 1;   /* bit set if this is post-3.1 xdb */ 
1699  unsigned int doc_header: 1;     /* bit set if this is doc-style header*/
1700  unsigned int version: 8;      /* version of debug/header
1701                                   format. For 10.0 the value
1702                                   will be 1. For "Davis" the value is 2.  */
1703  unsigned int reserved_for_flags: 18; /* for future use; -- must be set to zero.  */
1704  unsigned int has_range_table: 1;     /* space contains a $RANGE$ subspace for variable ranges.  */
1705  unsigned int has_context_table: 1;   /* space contains a $CTXT$ subspace for context/inline table.  */
1706  unsigned int has_lines_table: 1;     /* space contains a $LINES$ subspace for line tables. */
1707  unsigned int has_lt_offset_map: 1;   /* space contains an lt_offset subspace for line table mapping.  */
1708
1709  long   gntt_length;  /* same as old header */
1710  long   lntt_length;  /* same as old header */
1711  long   slt_length;   /* same as old header */
1712  long   vt_length;    /* same as old header */
1713  long   xt_length;    /* same as old header */
1714  long   ctxt_length;  /* present only if version >= 2 */
1715  long   range_length; /* present only if version >= 2 */
1716  long   expr_length;  /* present only if version >= 2 */
1717
1718} DOC_info_header;
1719
1720typedef union GenericDebugHeader_union
1721{
1722   PXDB_header          no_doc;
1723   DOC_info_PXDB_header doc;
1724   XDB_header           no_pxdb_no_doc;
1725   DOC_info_header      no_pxdb_doc;
1726} GenericDebugHeader;
1727
1728
1729/*  Procedure Descriptor:
1730    An element of the procedure quick look-up table.  */
1731
1732typedef struct quick_procedure
1733{
1734  long           isym;          /* 0-based index of first symbol
1735                                   for procedure in $LNTT$,
1736                                   i.e. the procedure itself.  */
1737  CORE_ADDR      adrStart;      /* memory adr of start of proc  */
1738  CORE_ADDR      adrEnd;        /* memory adr of end of proc    */
1739  char          *sbAlias;       /* alias name of procedure      */
1740  char          *sbProc;        /* real name of procedure       */
1741  CORE_ADDR      adrBp;         /* address of entry breakpoint  */
1742  CORE_ADDR      adrExitBp;     /* address of exit breakpoint   */
1743  int            icd;           /* member of this class (index) */     
1744  unsigned int   ipd;           /* index of template for this   */
1745                                /* function (index)           */
1746  unsigned int   unused:    5;
1747  unsigned int   no_lt_offset: 1;/* no entry in lt_offset table */
1748  unsigned int   fTemplate: 1;  /* function template            */
1749  unsigned int   fExpansion: 1; /* function expansion           */
1750  unsigned int   linked   : 1;  /* linked with other expansions */
1751  unsigned int   duplicate: 1;  /* clone of another procedure   */
1752  unsigned int   overloaded:1;  /* overloaded function          */
1753  unsigned int   member:    1;  /* class member function        */
1754  unsigned int   constructor:1; /* constructor function         */
1755  unsigned int   destructor:1;  /* destructor function          */
1756  unsigned int   Static:    1;  /* static function              */
1757  unsigned int   Virtual:   1;  /* virtual function             */
1758  unsigned int   constant:  1;  /* constant function            */
1759  unsigned int   pure:      1;  /* pure (virtual) function      */
1760  unsigned int   language:  4;  /* procedure's language         */
1761  unsigned int   inlined:   1;  /* function has been inlined    */
1762  unsigned int   Operator:  1;  /* operator function            */
1763  unsigned int   stub:      1;  /* bodyless function            */
1764  unsigned int   optimize:  2;  /* optimization level           */
1765  unsigned int   level:     5;  /* nesting level (top=0)        */
1766} quick_procedure_entry, *quick_procedure_entry_ptr;
1767
1768/*  Source File Descriptor:
1769    An element of the source file quick look-up table.  */
1770
1771typedef struct quick_source
1772{
1773  long           isym;          /* 0-based index in $LNTT$ of
1774                                   first symbol for this file.     */
1775  CORE_ADDR      adrStart;      /* mem adr of start of file's code */
1776  CORE_ADDR      adrEnd;        /* mem adr of end of file's code   */
1777  char          *sbFile;        /* name of source file             */
1778  unsigned int   fHasDecl: 1;   /* do we have a .d file?           */
1779  unsigned int   fWarned:  1;   /* have warned about age problems? */
1780  unsigned int   fSrcfile: 1;   /* 0 => include 1=> source         */
1781  unsigned short ilnMac;        /* lines in file (0 if don't know) */
1782  int            ipd;           /* 0-based index of first procedure
1783                                   in this file, in the quick
1784                                   look-up table of procedures.    */
1785  unsigned int  *rgLn;          /* line pointer array, if any      */
1786} quick_file_entry, *quick_file_entry_ptr;
1787
1788/*  Module Descriptor:
1789    An element of the module quick reference table.  */
1790
1791typedef struct quick_module
1792{
1793  long           isym;             /* 0-based index of first
1794                                      symbol for module.        */
1795  CORE_ADDR      adrStart;         /* adr of start of mod.      */
1796  CORE_ADDR      adrEnd;           /* adr of end of mod.        */
1797  char          *sbAlias;          /* alias name of module      */
1798  char          *sbMod;            /* real name of module       */
1799  unsigned int   imports:       1; /* module have any imports?  */
1800  unsigned int   vars_in_front: 1; /* module globals in front?  */
1801  unsigned int   vars_in_gaps:  1; /* module globals in gaps?   */
1802  unsigned int   language:      4; /* type of language          */
1803  unsigned int   unused      : 25;
1804  unsigned int   unused2;          /* space for future stuff    */
1805} quick_module_entry, *quick_module_entry_ptr;
1806
1807/*  Auxiliary Procedure Descriptor:
1808    An element of the auxiliary procedure quick look-up table.  */
1809
1810typedef struct quick_aux_procedure
1811{
1812  long   isym_inln;     /* start on inline list for proc */
1813  long   spare;
1814} quick_aux_procedure_entry, *quick_aux_procedure_entry_ptr;
1815
1816/*  Paragraph Descriptor:
1817    An element of the paragraph quick look-up table.  */
1818
1819typedef struct quick_paragraph
1820{
1821  long             isym;       /* first symbol for label (index)  */
1822  CORE_ADDR        adrStart;   /* memory adr of start of label    */
1823  CORE_ADDR        adrEnd;     /* memory adr of end of label      */
1824  char            *sbLab;      /* name of label                   */
1825  unsigned int     inst;       /* Used in xdb to store inst @ bp  */
1826  unsigned int     sect:    1; /* true = section, false = parag.  */
1827  unsigned int     unused: 31; /* future use                      */
1828} quick_paragraph_entry, *quick_paragraph_entry_ptr;
1829
1830/* Class Descriptor:
1831   An element of the class quick look-up table.  */
1832
1833typedef struct quick_class
1834{
1835  char           *sbClass;      /* name of class                */
1836  long            isym;         /* class symbol (tag)           */
1837  unsigned int    type : 2;     /* 0=class, 1=union, 2=struct   */
1838  unsigned int    fTemplate : 1;/* class template               */
1839  unsigned int    expansion : 1;/* template expansion           */
1840  unsigned int    unused    :28;
1841  sltpointer      lowscope;     /* beginning of defined scope   */
1842  sltpointer      hiscope;      /* end of defined scope         */
1843} quick_class_entry, *quick_class_entry_ptr;
1844
1845/* Address Alias Entry
1846   An element of the address alias quick look-up table.  */
1847
1848typedef struct quick_alias
1849{
1850  CORE_ADDR     low;
1851  CORE_ADDR     high;
1852  int           index;
1853  unsigned int  unused : 31;
1854  unsigned int  alternate : 1;  /* alternate unnamed aliases?   */
1855} quick_alias_entry, *quick_alias_entry_ptr;
1856
1857/* Object Identification Entry
1858   An element of the object identification quick look-up table.  */
1859
1860typedef struct quick_obj_ID
1861{
1862  CORE_ADDR    obj_ident;       /* class identifier         */
1863  long         isym;            /* class symbol             */
1864  long         offset;          /* offset to object start   */
1865} quick_obj_ID_entry, *quick_obj_ID_entry_ptr;
1866
1867#endif /* HP_SYMTAB_INCLUDED */
Note: See TracBrowser for help on using the repository browser.