source: branches/libc-0.6/src/binutils/include/hp-symtab.h

Last change on this file was 10, checked in by bird, 22 years ago

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