1 /***************************************************************************
2 * (c) Copyright 1988 - 1993 HEWLETT-PACKARD COMPANY. All rights reserved. *
3 ***************************************************************************/
5 /***************************************************************************
6 * This program is "free" software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; Version 2, June 1991.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this include file; if not, write to the Free Software Foundation,
17 * Inc, 675 Mass Ave, Cambridge, MA 02139, USA
19 ***************************************************************************/
21 /***************************************************************************
23 * Hewlett-Packard Company will not respond to external queries regarding
24 * the distribution or content of this include file. The University of
25 * Utah Center for Software Science (CSS) is the contact point for its
26 * distribution. CSS distributes this file under the terms of the GNU
27 * General Public License, as above: WITHOUT ANY WARRANTY. CSS makes NO
28 * WARRANTY as to the file's accuracy or timeliness. This file is NOT
31 * The current distributed version of this file is available by
32 * anonymous ftp from jaguar.cs.utah.edu in dist/hpux-symtab.h.
33 * The GNU General Public License is in dist/COPYING.
34 * Email may be directed to pa-gdb-bugs@cs.utah.edu.
36 ***************************************************************************/
38 #ifndef _SYMTAB_INCLUDED /* allow multiple inclusions */
39 #define _SYMTAB_INCLUDED
43 * SYMBOLIC DEBUG FORMAT ACD
48 * ---- 1. INTRODUCTION
51 * This document describes the current format for data tables which
52 * appear in HP-UX / HPE object files (a.out files). These tables
53 * will be generated by the compilers, fixed up by the linker, and
54 * used by various programs (primarily the symbolic debugger(s)) to
55 * reconstruct information about the program. The form of this
56 * document is a C include file annotated with comments.
58 * On PA-RISC, a major goal was that the linker need not know
59 * anything about the format. To this end, it was decided that the
60 * debug information be composed of several unloadable subspaces
61 * within an unloadable space (named $DEBUG$), and that link time
62 * updates to the debug information be made through the standard
63 * mechanism of a list of fixups. The linker will perform the
64 * required fixups for the debug spaces, and subspaces from
65 * separate compilation units will be concatenated. However, at
66 * exec time, the loader would know that the debug space is not to
69 * Similarly, on the series 300, several debug tables are present
70 * in the a.out format which are not loaded at exec time. Debug
71 * tables are simply concatenated into larger tables at link time
72 * and all fixups are then performed by pxdb.
76 * ---- 2. SUMMARY OF STRUCTURES
79 * The debug information consists of six tables: a header table
80 * and five special tables. The header table will contain one
81 * header record for each compilation unit. Each header record
82 * identifies the size (in bytes) of the five tables generated by
83 * that compilation unit. Two of the tables are very similar. The
84 * GNTT and LNTT both contain name and type information (NTT for
85 * Name and Type Table). The GNTT contains information about
86 * globals, and is thus limited to variables, types, and constants.
87 * The LNTT is for information about locals. The LNTT must
88 * therefore contain scoping information such as procedure nesting,
89 * begin-end blocks, etc. The GNTT and LNTT are both DNTTs (Debug
90 * Name and Type Tables), so the prefix DNTT is attached to objects
91 * (like a DNTTPOINTER) that are relevant to both the GNTT and
92 * LNTT. The SLT contains information relating source (or listing)
93 * lines to code addresses. The SLT and LNTT contain pointers
94 * between the two tables, so that the scoping information
95 * contained in the LNTT can also be used with the SLT. The VT
96 * contains ascii strings (such as variable names) and the values
97 * of named constants. The five tables are summarized below:
100 * Table Abbr Contains Points into
101 * ============= ==== ========================= ===============
102 * Global symbols GNTT global name-and-type info GNTT
103 * Local symbols LNTT local name-and-type info GNTT,LNTT,SLT,VT
104 * source line SLT source/listing line info LNTT,SLT
105 * value VT names and constants -
106 * xref XT File offsets and Attributes XT,VT
109 * The pointers needed within the debug tables are in fact indexes
110 * into the tables. The GNTT, LNTT, and SLT each consist of a series
111 * of equal-sized entries. Some DNTT entries begin a data structure
112 * and some are extension entries. Some SLT entries are "special"
113 * (point back to the LNTT), others are "assist" (point forward in
114 * the SLT), but most are "normal" (point to code).
116 * There can be pointers from the LNTT to the GNTT, as it is common
117 * to have local variables of a global type. However, there are
118 * never pointers from the GNTT to the LNTT, as global variables
119 * are never of a local type.
121 * The tables are defined to be as machine-independent as possible,
122 * but the debugger may need to "know" some facts about the system
123 * and language it is dealing with.
125 * The GNTT and LNTT are the only tables that require fixups to be
126 * generated by the compiler and acted upon by the linker. There
127 * are other fixups to be done, but these are all done by the pre-
132 * ---- 3. LOW-LEVEL TYPE DECLARATIONS
136 * Code or data address:
138 * For the series 300:
144 * A PA-RISC short pointer.
149 #define public global
152 typedef long ADDRESS
;
153 typedef unsigned long ADRT
, *pADRT
;
158 * Sizeof (LANGTYPE) = 4 bits, for a maximum of 16 possible
162 typedef unsigned int LANGTYPE
;
164 #define LANG_UNKNOWN 0
167 #define LANG_HPPASCAL 3
168 #define LANG_HPMODCAL 4
169 #define LANG_HPCOBOL 5
170 #define LANG_HPBASIC 6
173 #define LANG_CPLUSPLUS 8
180 * 32-bit, machine-dependent and context-dependent specifiers of
181 * variable storage location.
184 typedef unsigned long STATTYPE
; /* static-type location */
185 typedef long DYNTYPE
; /* dynamic-type location */
186 typedef unsigned long REGTYPE
; /* register-type location */
188 #define STATNIL (-1) /* no location for STATTYPE */
191 * Loc type Series 300 PA-RISC
192 * ======== ================ ===============
194 * STATTYPE Absolute address A PA-RISC
195 * into process short pointer.
200 * DYNTYPE A6-register- SP-register
201 * relative byte relative byte
202 * offset (+/-). offset (+/-)
204 * REGTYPE Register number Register number
205 * (see below). (see below).
207 * All location types are always byte (not word) pointers when they
208 * address memory, and they always point to the first byte
209 * containing the object, skipping any padding bytes. For example,
210 * if in Pascal a CHAR is allocated in the last byte of a whole
211 * word, the pointer is to that byte. (In C, four different CHAR
212 * variables might be packed into one word.)
216 * Meaning of STATTYPE for CONST entries:
218 * Sizeof (LOCDESCTYPE) = 3 bits, for a maximum of 8 possible
222 typedef unsigned int LOCDESCTYPE
;
224 #define LOC_IMMED 0 /* immediate constant */
225 #define LOC_PTR 1 /* standard STATTYPE */
226 #define LOC_VT 2 /* value table byte offset */
229 * Register numbers for REGTYPE (Series 300 only):
277 * generic floating point registers;
278 * actual register determined at runtime
291 #define REG_FGEN10 50
292 #define REG_FGEN11 51
293 #define REG_FGEN12 52
294 #define REG_FGEN13 53
295 #define REG_FGEN14 54
296 #define REG_FGEN15 55
301 * Sizeof (BASETYPE) = 5 bits, for a maximum of 32 possible
305 typedef unsigned int BASETYPE
;
307 #define T_UNDEFINED 0 /* unheard of */
308 #define T_BOOLEAN 1 /* true/false or LOGICAL */
309 #define T_CHAR 2 /* ASCII, signed if used as int */
310 #define T_INT 3 /* signed integer */
311 #define T_UNS_INT 4 /* unsigned integer */
312 #define T_REAL 5 /* binary or decimal real */
313 #define T_COMPLEX 6 /* pair of reals */
314 #define T_STRING200 7 /* Series 300 string type */
315 #define T_LONGSTRING200 8 /* Series 300 long string type */
316 #define T_TEXT 9 /* for Pascal TEXT file */
317 #define T_FLABEL 10 /* for any program labels */
318 #define T_FTN_STRING_SPEC 11 /* PA-RISC FORTRAN string type */
319 #define T_MOD_STRING_SPEC 12 /* PA-RISC Modcal/Pascal string */
320 #define T_PACKED_DECIMAL 13 /* packed decimal */
321 #define T_REAL_3000 14 /* HP3000 format real */
322 #define T_MOD_STRING_3000 15 /* HP3000 Modcal/Pascal string */
323 #define T_ANYPTR 16 /* Pascal any-pointer */
324 #define T_GLOBAL_ANYPTR 17 /* Pascal global any-pointer */
325 #define T_LOCAL_ANYPTR 18 /* Pascal local any-pointer */
326 #define T_COMPLEXS3000 19 /* HP3000 format complex */
327 #define T_FTN_STRING_S300_COMPAT 20 /* 9000/s300 compatible fortran string */
328 #define T_FTN_STRING_VAX_COMPAT 21 /* VAX compatible fortran string */
329 #define T_BOOLEAN_S300_COMPAT 22 /* 9000/s300 compatible fortran logical */
330 #define T_BOOLEAN_VAX_COMPAT 23 /* VAX compatible fortran logical */
331 #define T_WIDE_CHAR 24 /* ANSI/C wchar_t pseudo-type */
332 #define T_LONG 25 /* signed long */
333 #define T_UNS_LONG 26 /* unsigned long */
334 #define T_DOUBLE 27 /* binary or decimal double */
336 #define T_TEMPLATE_ARG 28 /* template argument immediate type */
337 #endif /* TEMPLATES */
339 /* THE HIGHEST BASE_TYPE ALLOWABLE is 31 (see DNTTP_IMMEDIATE) */
341 * The string types are reserved for cases where the language has
342 * an explicit string type separate from "array of char".
344 * The ANSI/C wchar_t typedef defines a special base-type to
345 * the debugger. The interpretation of wide-characters during
346 * input or display (i.e. their mapping to/from "external"
347 * characters) is defined by the ANSI/C functions mbtowc() and
348 * wctomb(), the "multi-byte" translation functions.
350 * T_FLABEL is used for CONSTs which are actually FORTRAN labels.
351 * The T_FLABEL is needed for the following: in FORTRAN there is
352 * the ASSIGN statement (ASSIGN <label> TO <integer variable>),
353 * which places the address of the statement prefixed with the
354 * label <label> into the integer variable. This integer variable
355 * can then be used as a label (e.g. GOTO <integer variable>).
356 * The user may wish to display the contents of the integer variable
357 * as a label. The DNTT LABEL entry is not sufficient, as the label
358 * need not be on an executable statement (e.g. a FORMAT statement),
359 * and the DNTT LABEL can only be used with executable statements.
361 * The bitlength in a DNTT entry further qualifies the basetype.
362 * Here is a summary of the legal values for bitlength. See the
363 * appropriate sections below for details.
365 * T_UNDEFINED any probably treat as int
366 * T_BOOLEAN 1 one-bit value
367 * 16,32 FORTRAN LOGICAL
368 * T_CHAR 1..8 size of char (really can be < 8 bits in C)
369 * T_INT 2..n probably n <= 64; incl. sign bit
370 * T_UNS_INT 1..n probably n <= 64
371 * T_REAL 32 short binary
374 * T_COMPLEX 64 two short binaries
375 * 128 two long binaries
377 * T_STRING200 n * 8 maximum allocated memory, including
378 * length byte and/or terminator byte
379 * T_FTN_STRING_SPEC (to be determined)
380 * T_MOD_STRING_SPEC (to be determined)
381 * T_TEXT n size of the element buffer only
382 * T_FLABEL n * 8 size of the format label
383 * T_PACKED_DECIMAL (to be determined)
384 * T_WIDE_CHAR 32 determined by HP's NLS/Ansi-C committees
387 typedef unsigned int BITS
;
393 struct DNTTP_IMMEDIATE
{
394 BITS extension
: 1; /* always set to 1 */
395 BITS immediate
: 1; /* always set to 1 */
396 BITS global
: 1; /* always set to 0 */
397 BASETYPE type
: 5; /* immediate basetype */
398 BITS bitlength
: 24; /* immediate bitlength */
402 * Note that for type T_TEMPLATE_ARG bitlength is an positioning
403 * index into the chain of DNTT_TEMPLATE_ARG hanging out of
404 * the DNTT_TEMPLATE arglist field.
407 struct DNTTP_NONIMMED
{
408 BITS extension
: 1; /* always set to 1 */
409 BITS immediate
: 1; /* always set to 0 */
410 BITS global
: 1; /* 1 => GNTT, 0 => LNTT */
411 BITS index
: 29; /* DNTT table index */
415 struct DNTTP_IMMEDIATE dntti
;
416 struct DNTTP_NONIMMED dnttp
;
417 long word
; /* for generic access */
418 } DNTTPOINTER
; /* one word */
423 * A DNTTPOINTER of DNTTNIL means a nil pointer. In the DNTT
424 * immediate case there is always at least one zero bit (the global
425 * bit) to distinguish that case from nil pointer (-1). In the
426 * non-immediate, non-nil case DNTTPOINTER is the block index, base
427 * zero, of another DNTT entry; the global bit indicates which table
428 * it is an index into, the GNTT or LNTT. Each block is 12 bytes.
430 * Extension bits really have nothing to do with DNTT pointers, but
431 * are needed for constructing the DNTT. See the next section.
433 * Bitlength is the MINIMUM (packed) size of the object. In lieu
434 * of other information (i.e., outside of a structure or array),
435 * the object is assumed to be right-justified in the minimum
436 * number of whole bytes required to hold the bitlength. An
437 * immediate DNTTPOINTER is only allowed if the type is a simple
438 * BASETYPE. Otherwise, a separate DNTT entry must be used.
445 * Signed entry index, base zero, into the source line table.
446 * Each entry is eight bytes.
449 typedef long SLTPOINTER
;
457 * Unsigned byte offset into the value table. Note that VTNIL
458 * is not actually a nil pointer, but rather a pointer to a nil
459 * string (see section 6).
462 typedef long VTPOINTER
;
470 * Signed entry index, base zero, into the cross reference table.
471 * Each entry is four bytes.
474 typedef long XREFPOINTER
;
480 * Values for "declaration" fields describing packing method
485 #define DECLCRUNCHED 2
489 * ---- 4. DEBUG HEADER
493 * The header table is composed of five word header records. For
494 * each compilation unit, the compiler must generate a header
495 * record, indicating the length (in bytes) of the five tables
496 * (GNTT, LNTT, SLT, VT and XT) produced for that compilation unit.
507 #define extension_header 0x80000000
510 * The purpose of the header record is as follows: the five tables
511 * are each contained in a separate subspace on PA-RISC or in a
512 * separate section of the a.out file on the series 300. Therefore
513 * at link time, the tables from different compilation units will
514 * be con- catenated separately, GNTTs to GNTTS, SLTs to SLTs, etc.
515 * However, the preprocessor requires the number of compilation
516 * units, and the size of each of the five tables produced by each
517 * compilation unit. The header records supply this size
518 * information, and the number of header records equals the number
519 * of compilation units.
521 * For PA-RISC, the header_extension flag (MSB) is set in the
522 * gntt_length word in each header-record by the HP-UX 3.1+ s800 C
523 * compiler to indicate the header contains an xt_length and is 5
524 * words long. This bit is used to distinguish SOM's that were
525 * created with the pre-SA compiler (HP-UX 3.0, /bin/cc vers.
526 * A.00.15 or earlier) from SOM's that contain an $XT$ subspace.
528 * For PA-RISC, pxdb and xdb version A.02.xx can be used on
529 * >>all<< SOM's (4 or 5 word XDB headers) that have not already
530 * been pxdb'd. Earlier versions of either are completely
531 * incompatible with SOM's containing an $XT$ (HP-UXS 3.1 or later)
532 * because of the header-length.
534 * For the series 300, the header_extension flag is not used (i.e.
535 * the gntt_length occupies a full 32 bits).
539 * ---- 5. DEBUG SYMBOL TABLE (DNTT) ENTRY FORMAT
543 * The DNTT consists of a series of three-word blocks. Each block
544 * starts with an "extension bit". Each structure in the union
545 * "dnttentry" begins in an "initial block" with a bit which is
546 * always zero. If a structure is more than three words (one
547 * block) long, it occupies one or more additional "extension
548 * blocks", each of which starts with a bit set to one to
549 * distinguish it from an initial block.
551 * Note well that every DNTTPOINTER has a high bit of one and that
552 * every DNTT structure bigger than one block is carefully arranged
553 * so that a DNTTPOINTER resides in the fourth and seventh words.
554 * (The extension bit is in the DNTTPOINTER to avoid wasting space
555 * due to structure packing rules.)
558 #define DNTTBLOCKSIZE 12
560 /* The second field in each structure is "kind", which acts like a
561 * Pascal variant tag to denote the type of the structure. The
562 * "unused" fields are just included for clarity. The whole union
563 * "dnttentry" is declared after the definition of KINDTYPE and all
564 * the various structures (below).
567 typedef int KINDTYPE
;
569 #define K_NIL (-1) /* guaranteed illegal value */
594 #define K_SUBRANGE 19
601 #define K_FUNCTYPE 26
602 #define K_COBSTRUCT 29
607 #define K_BLOCKDATA 33
609 #define K_MODIFIER 45 /* used for C too so we can qualify type */
612 #define K_CLASS_SCOPE 34
613 #define K_REFERENCE 35
615 #define K_PTRMEMFUNC 37
617 #define K_GENFIELD 39
619 #define K_MEMACCESS 41
620 #define K_INHERITANCE 42
621 #define K_FRIEND_CLASS 43
622 #define K_FRIEND_FUNC 44
623 #define K_OBJECT_ID 46
626 #define K_TEMPLATE 48
627 #define K_TEMPL_ARG 49
628 #define K_FUNC_TEMPLATE 50
630 #endif /* TEMPLATES */
636 #else /* TEMPLATES */
637 #define K_MAX K_MEMFUNC
638 #endif /* TEMPLATES */
640 #define K_MAX K_BLOCKDATA
644 * ---- 5.1. FILE-CLASS ("FILE") DNTT ENTRIES
648 struct DNTT_SRCFILE
{
649 /*0*/ BITS extension
: 1; /* always zero */
650 KINDTYPE kind
: 10; /* always K_SRCFILE */
651 LANGTYPE language
: 4; /* type of language */
653 /*1*/ VTPOINTER name
; /* name of source/listing file */
654 /*2*/ SLTPOINTER address
; /* code and text locations */
658 * One SRCFILE is emitted for the start of each source file, the
659 * start of each included file, and the return from each included
660 * file. Additional SRCFILE entries must also be output before each
661 * DNTT_FUNC entry. This guarantees the debuggers know which file a
662 * function came from. Specifically, the rules are as follows:
665 * Source block: contiguous block of one or more lines of text in a
666 * source-file, bounded by beginning or end-of-file or include
667 * directives (conceptually identical to the "basic block" in
668 * optimizer jargon). No distinction is made between blocks
669 * that contain compilable code and those that don't.
671 * Code segment: contiguous LINEAR block of DNTT (and associated
672 * SLT) entries that are generated from the same "source block".
673 * "SLT_SRC" is used here to actually refer to an SLT_SPEC entry
674 * of type SLT_SRCFILE. Same goes for SLT_FUNC.
676 * 1. One DNTT_SRCFILE and SLT_SRC must be emitted at the head of each
677 * code segment to facilitate reading backwards through the DNTT or
678 * SLT tables from any point in the segment to determine the
679 * enclosing source file. If the source-file changes within the
680 * body of a function/subprogram, a DNTT_SRCFILE/SLT_SRC pair must
681 * be emitted prior to any additional DNTT or SLT entries generated
682 * by the remainder of that function/subprogram.
684 * 2. One DNTT_SRCFILE/SLT_SRC pair is always emitted *immediately*
685 * before any DNTT_FUNC/SLT_FUNC. Exception: a DNTT_SA and
686 * associated DNTT_XREF may appear between a DNTT_FUNC and it's
687 * preceding DNTT_SRCFILE. There can be nothing between the
688 * SLT_SRC and the SLT_FUNC. The DNTT_SRCFILE (preceding the
689 * DNTT_FUNC) must name the file containing the functions
690 * declaration. The SLT_FUNC must contain the line number of the
691 * line in the function's declaration where the function's name
692 * appears. This line number must match the line number that
693 * appears in the XT record denoting the function's declaration.
694 * The SLT_END associated with the SLT_FUNC must contain the line
695 * number of the source line containing the scope-closing token
696 * (i.e. "}" or "end").
698 * 3. One DNTT_SRCFILE/SLT_SRC pair must be emitted for a source file
699 * that otherwise would not be mentioned in the DNTT i.e. source
700 * files that do not generate a code segment. This is required for
701 * Static analysis only.
704 * "address" points to a special SLT entry (for the line number
705 * only), but the code location is known from context in the SLT. *
707 * NOTE: Listing files and listing file line numbers may be used in
708 * place of source files and source file line numbers. A
709 * special compiler option will designate which is generated
712 * SRCFILE names are exactly as seen by the compiler, i.e. they
713 * may be relative, absolute, or whatever. C include file names
714 * must be given as absolute paths if found "in the usual place",
715 * i.e., /usr/include/...
719 * ---- 5.2. CODE-CLASS ("SCOPING") DNTT ENTRIES
724 /*0*/ BITS extension
: 1; /* always zero */
725 KINDTYPE kind
: 10; /* always K_MODULE */
727 /*1*/ VTPOINTER name
; /* name of module */
728 /*2*/ VTPOINTER alias
; /* alternate name, if any */
729 /*3*/ DNTTPOINTER dummy
; /* 4th word must be DNTTPOINTER */
730 /*4*/ SLTPOINTER address
; /* code and text locations */
734 * One MODULE is emitted for the start of each Pascal/Modcal module
735 * or C source file (C sources are considered a nameless module).
736 * "address" points to a special SLT entry, but the code location
737 * is known from context in the SLT.
739 * In the case of languages that do not support modules (such as
740 * FORTRAN) a DNTT_MODULE and DNTT_END pair are not used. Every
741 * MODULE must have a matching END (see below). If a Pascal/Modcal
742 * module has a module body (some code), the latter must be represented
743 * by a FUNCTION-END pair as well (see below).
745 * For items within a module, the public bit is true if that item
746 * is exported by the module. If the public bit of an item is set,
747 * that item is visible within any module or procedure that imports
748 * the module containing the item. If the public bit of an item
749 * is not set, then the item is only visible within the module.
751 * The "dummy" field exists only because the first word of each
752 * extension block must be a DNTTPOINTER; it is important only
753 * that the extension bit of the DNTTPOINTER be set.
755 * The MODULE DNTT should be used only in the LNTT.
762 /*0*/ BITS extension
: 1; /* always zero */
763 KINDTYPE kind
: 10; /* always K_LINK */
764 BITS linkKind
: 4; /* always LINK_UNKNOWN */
766 /*1*/ long future1
; /* expansion */
767 /*2*/ DNTTPOINTER ptr1
; /* link from template */
768 /*3*/ DNTTPOINTER ptr2
; /* to expansion */
769 /*4*/ long future
[2];
773 struct DNTT_TFUNC_LINK
775 /*0*/ BITS extension
: 1; /* always zero */
776 KINDTYPE kind
: 10; /* always K_LINK */
777 BITS linkKind
: 4; /* always LINK_FUNC_TEMPLATE */
779 /*1*/ long args
; /* expansion */
780 /*2*/ DNTTPOINTER pTemplate
; /* link from template */
781 /*3*/ DNTTPOINTER pExpansion
; /* to expansion */
782 /*4*/ long future
[2];
785 /* temporary until we get a new cfront */
787 struct DNTT_TFUNC_LINK
789 /*0*/ BITS extension
: 1; /* always zero */
790 KINDTYPE kind
: 10; /* always K_LINK */
791 BITS linkKind
: 4; /* always LINK_FUNC_TEMPLATE */
793 /*2*/ DNTTPOINTER pTemplate
; /* link from template */
794 /*3*/ DNTTPOINTER pExpansion
; /* to expansion */
795 /*1*/ long args
; /* expansion */
796 /*4*/ long future
[2];
800 * Note the linkKind bit. The idea is that we might have other
801 * LINKs in the future that share the same format but where we would
802 * call the fields another name. It's hard to debug a program
803 * where fields are called link_word1 and link_word2.
806 #define LINK_UNKNOWN 0
807 #define LINK_FUNC_TEMPLATE 1
809 struct DNTT_FUNC_TEMPLATE
{
810 /*0*/ BITS extension
: 1; /* always zero */
811 KINDTYPE kind
: 10; /* K_FUNC_TEMPLATE */
812 BITS
public: 1; /* 1 => globally visible */
813 LANGTYPE language
: 4; /* type of language */
814 BITS level
: 5; /* nesting level (top level = 0)*/
815 BITS optimize
: 2; /* level of optimization */
816 BITS varargs
: 1; /* ellipses. Pascal/800 later */
817 BITS info
: 4; /* lang-specific stuff; F_xxxx */
820 BITS localloc
: 1; /* 0 at top, 1 at end of block */
825 /*1*/ VTPOINTER name
; /* name of function */
826 /*2*/ VTPOINTER alias
; /* alternate name, if any */
827 /*3*/ DNTTPOINTER firstparam
; /* first FPARAM, if any */
828 /*4*/ DNTTPOINTER retval
; /* return type, if any */
829 /*5*/ DNTTPOINTER arglist
; /* ptr to argument list */
833 * DNTT_FUNC_TEMPLATEs only appear in the GNTT. Functions and
834 * classes templates cannot be local. (Their instantions may be).
836 #endif /* TEMPLATES */
839 /*0*/ BITS extension
: 1; /* always zero */
840 KINDTYPE kind
: 10; /* K_FUNCTION, K_ENTRY, */
841 /* K_BLOCKDATA, or K_MEMFUNC */
842 BITS
public: 1; /* 1 => globally visible */
843 LANGTYPE language
: 4; /* type of language */
844 BITS level
: 5; /* nesting level (top level = 0)*/
845 BITS optimize
: 2; /* level of optimization */
846 BITS varargs
: 1; /* ellipses. Pascal/800 later */
847 BITS info
: 4; /* lang-specific stuff; F_xxxx */
850 BITS localloc
: 1; /* 0 at top, 1 at end of block */
852 BITS expansion
: 1; /* 1 = function expansion */
854 #else /* TEMPLATES */
856 #endif /* TEMPLATES */
860 /*1*/ VTPOINTER name
; /* name of function */
861 /*2*/ VTPOINTER alias
; /* alternate name, if any */
862 /*3*/ DNTTPOINTER firstparam
; /* first FPARAM, if any */
863 /*4*/ SLTPOINTER address
; /* code and text locations */
864 /*5*/ ADDRESS entryaddr
; /* address of entry point */
865 /*6*/ DNTTPOINTER retval
; /* return type, if any */
866 /*7*/ ADDRESS lowaddr
; /* lowest address of function */
867 /*8*/ ADDRESS hiaddr
; /* highest address of function */
871 * Additional function semantics: Values for DNTT_FUNC.info
874 /* In command-line C proc-call... */
875 #define F_ARGMODE_COMPAT_C 0 /* all real params passed as double */
876 #define F_ARGMODE_ANSI_C 1 /* floats-is-floats but PASS as dbl */
877 #define F_ARGMODE_ANSI_C_PROTO 2 /* all real params passed as declared */
879 /* special DNTT_FUNC semantics */
880 #define F_ARGMODE_BLKDATA 3 /* Fortran "block data" construct */
881 /* NOT A FUNCTION! */
882 /* F_ARGMODE_BLKDATA is retained for backward compatability only */
885 #define CPP_OVERLOADED 0x1 /* overloaded function */
886 #define CPP_MEMBERFUNC 0x2 /* member function */
887 #define CPP_INLINE 0x4 /* inline function */
888 #define CPP_OPERATOR 0x8 /* operator function */
892 * Struct DNTT_FUNC is used for dfunc and dentry, and dblockdata types.
893 * One FUNCTION or ENTRY is emitted for each formal function
894 * declaration (with a body) or secondary entry point,
895 * respectively. They are not emitted for bodyless declarations
896 * (FORWARD, EXTERNAL, "int x ();" etc.). A dblockdata is emitted for
897 * Fortran BLOCK DATA constructs only.
899 * "address" always points to a special SLT entry.
901 * For FUNCTION types, the "entryaddr" field is the code address of
902 * the primary entry point of the function. The "lowaddr" field is
903 * the lowest code address of the function. The "hiaddr" field
904 * is the highest code address of the function. This both gives
905 * the size of the function and helps in mapping code locations
906 * to functions when there are anonymous (non-debuggable) functions
907 * present. These three fields should be filled in by the generation
910 * For ENTRY types, the "entryaddr" field points to the proper code
911 * location for calling the function at the secondary entrypoint,
912 * and the "lowaddr" and "hiaddr" fields are nil (zero). For a
913 * FORTRAN subroutine with alternate entries, DNTT_DVARs are required
914 * to represent the parameters, see the DNTT_FPARAM definition for
917 * For BLOCKDATA types, the "public" bit should be set to 1, the
918 * "level", "optimize", "varargs" and "info" fields should all be 0.
919 * The "firstparam" field should be DNTTNIL. The "entryaddr" and
920 * "lowaddr" fields should be 0, and the "highaddr" field should be
921 * FFFFFFFC (-4). The "retval" field should be set to T_UNDEFINED,
922 * with length 0. An SLT_FUNCTION/SNT_END pair should be emitted
923 * for each DNTT_FUNC (BLOCKDATA).
925 * Every FUNCTION or BLOCKDATA must have a matching END (see below).
927 * For languages in which a functions return value is set by assigning
928 * the value to the function name (such as FORTRAN & Pascal), a DVAR
929 * entry should also be emitted for the function. The address of this
930 * DVAR for the function should be the address of the answer spot for
931 * the function. This will allow the user to display the current
932 * return value while the function is executing.
934 * The "varargs" field indicates whether the function was declared as
935 * having a variable-length parameter list. This is currently possible
936 * only via ANSI/C function-prototype "ellipses" (...). The "info" field
937 * provides additional language-specific characteristics of the function
938 * and/or its parameter-list.
940 * The localloc (local variables location) is currently only used
941 * in the following context: If the function
942 * language is LANG_CPLUSPLUS, then 0 means that locals are
943 * at the beginning of the block, and 1 means that locals appears
944 * at the end of a block. For all other languages
945 * this bit is not used.
947 * The FUNCTION DNTT should be used only in the LNTT.
952 /*0*/ BITS extension
: 1; /* always zero */
953 KINDTYPE kind
: 10; /* always K_BEGIN */
955 BITS classflag
: 1; /* beginning of class def'n */
960 /*1*/ SLTPOINTER address
; /* code and text locations */
964 * BEGINs are emitted as required to open a new (nested) scope for
965 * any type of variable or label, at any level within MODULE-END
966 * and FUNCTION-END pairs. Every BEGIN must have a matching END
967 * (see below). "address" points to a special SLT entry, but the
968 * code location is known from context in the SLT. Because a DNTT
969 * BEGIN-END is used to indicate a new scope, the Pascal BEGIN-
970 * END pair does not produce a DNTT BEGIN-END, while the C { }
973 * The BEGIN DNTT should be used only in the LNTT.
978 /*0*/ BITS extension
: 1; /* always zero */
979 KINDTYPE kind
: 10; /* always K_COMMON */
981 /*1*/ VTPOINTER name
; /* name of common block */
982 /*2*/ VTPOINTER alias
; /* alternate name, if any */
986 * COMMONs are used to indicate that a group of variables are members
987 * of a given FORTRAN common block. For each common block, a DNTT_
988 * COMMON is emitted, followed by a DNTT_SVAR for each member of the
989 * common block, and finally a DNTT_END. If type information is
990 * required for a member of the common block (such as an array), it
991 * may also be within the DNTT_COMMON, DNTT_END pair.
993 * The COMMON DNTT should be used only in the LNTT.
998 /*0*/ BITS extension
: 1; /* always zero */
999 KINDTYPE kind
: 10; /* always K_WITH */
1000 BITS addrtype
: 2; /* 0 => STATTYPE */
1003 BITS indirect
: 1; /* 1 => pointer to object */
1004 BITS longaddr
: 1; /* 1 => in long pointer space */
1005 BITS nestlevel
: 6; /* # of nesting levels back */
1007 /*1*/ long location
; /* where stored (allocated) */
1008 /*2*/ SLTPOINTER address
;
1009 /*3*/ DNTTPOINTER type
; /* type of with expression */
1010 /*4*/ VTPOINTER name
; /* name of with expression */
1011 /*5*/ unsigned long offset
; /* byte offset from location */
1015 * WITHs are emitted to open a with scope. Like a BEGIN, a
1016 * WITH requires a matching END to close the scope. A single WITH
1017 * statement possessing more than one record expression, should
1018 * be handled as multiple nested withs with only one expression
1019 * each. The "addrtype" field indicates the addressing mode used
1020 * for the record expression, and along with the "indirect" field,
1021 * tells how to interpret the "location" and "offset" fields. Thus,
1022 * depending upon the value of "addrtype", "location" may contain
1023 * a short pointer, an offset from the local frame pointer, or a
1024 * register number. If "nestlevel" is non-zero and "addrtype" is
1025 * DYNTYPE, the address for the record expression is computed by
1026 * tracing back "nestlevel" static links and using "location" as
1027 * an offset from the frame pointer at that level. (This situation
1028 * occurs only on the FOCUS architecture.) The use of the
1029 * "offset" field is the same as for the DNTT_SVAR entry (see below).
1030 * The "type" field is the type of the record expression. The "name"
1031 * field is the symbolic representation of the record expression
1032 * (ex. "p[i]^"). "address" points to a special SLT, but the code
1033 * location is known from context in the SLT.
1035 * The WITH DNTT should be used only in the LNTT.
1039 /*0*/ BITS extension
: 1; /* always zero */
1040 KINDTYPE kind
: 10; /* always K_END */
1041 KINDTYPE endkind
: 10; /* DNTT kind closing scope for */
1043 BITS classflag
: 1; /* end of class def'n */
1048 /*1*/ SLTPOINTER address
; /* code and text locations */
1049 /*2*/ DNTTPOINTER beginscope
; /* start of scope */
1050 }; /* three words */
1053 * ENDs are emitted as required to close a scope started by a
1054 * MODULE, FUNCTION, WITH, COMMON, or BEGIN (but not an ENTRY).
1055 * Each points back to the DNTT entry that opened the scope.
1056 * "endkind" indicates which kind of DNTT entry is associated with
1057 * the END and is filled in by the preprocessor. "address" points
1058 * to a special SLT entry, but the code location is known from context
1061 * The END DNTT should be used only in the LNTT.
1065 struct DNTT_IMPORT
{
1066 /*0*/ BITS extension
: 1; /* always zero */
1067 KINDTYPE kind
: 10; /* always K_IMPORT */
1068 BITS
explicit: 1; /* module directly imported */
1070 /*1*/ VTPOINTER module
; /* module imported from */
1071 /*2*/ VTPOINTER item
; /* name of item imported */
1072 }; /* three words */
1075 * Within a module, there is one IMPORT entry for each imported
1076 * module, function, or variable. The item field is nil when an
1077 * entire module is imported. Used only by Pascal/Modcal. Note
1078 * that exported functions and variables have their public bits set.
1080 * The "explicit" flag indicates the module was directly imported.
1081 * When not set, the module was imported by an imported module.
1083 * The IMPORT DNTT should be used only in the LNTT.
1088 /*0*/ BITS extension
: 1; /* always zero */
1089 KINDTYPE kind
: 10; /* always K_LABEL */
1091 /*1*/ VTPOINTER name
; /* name of label */
1092 /*2*/ SLTPOINTER address
; /* code and text locations */
1093 }; /* three words */
1096 * One LABEL is emitted for each source program statement label,
1097 * referencing the matching physical line (SLT entry). An SLT
1098 * pointer is used, instead of just a linenumber, so a code
1099 * location is known for setting a breakpoint. This is the only
1100 * case of SLTPOINTER that points to a normal (not special) SLT
1103 * If a label appears at the very end of a function (after all
1104 * executable code), a normal SLT entry must be emitted for it
1105 * anyway. In this case the SLT entry points to an exit (return)
1108 * Numeric labels are named as the equivalent character string with
1109 * no leading zeroes, except in those languages where the leading
1110 * zeroes are significant (i.e. COBOL).
1112 * The LABEL DNTT should be used only in the LNTT.
1117 * ---- 5.3. STORAGE-CLASS ("NAME") DNTT ENTRIES
1120 struct DNTT_FPARAM
{
1121 /*0*/ BITS extension
: 1; /* always zero */
1122 KINDTYPE kind
: 10; /* always K_FPARAM */
1123 BITS regparam
: 1; /* 1 => REGTYPE, not DYNTYPE */
1124 BITS indirect
: 1; /* 1 => pass by reference */
1125 BITS longaddr
: 1; /* 1 => in long pointer space */
1126 BITS copyparam
: 1; /* 1 => Copied to a local */
1127 /* only for fortran strings */
1129 BITS dflt
: 1; /* default parameter value? */
1134 /*1*/ VTPOINTER name
; /* name of parameter */
1135 /*2*/ DYNTYPE location
; /* where stored */
1136 /*3*/ DNTTPOINTER type
; /* type information */
1137 /*4*/ DNTTPOINTER nextparam
; /* next FPARAM, if any */
1138 /*5*/ int misc
; /* assorted uses */
1142 * FPARAMs are chained together in parameter list order (left to
1143 * right) from every FUNCTION, ENTRY, or FUNCTYPE (see below), one
1144 * for each parameter, whether or not the type is explicitly
1145 * declared. For unnamed parameters, the FPARAM name is "*".
1147 * "regparam" implies that the storage location given is to be
1148 * interpreted as a REGTYPE, not a DYNTYPE, that is, the parameter
1149 * was passed in a register.
1151 * "indirect" implies that the storage location given contains a
1152 * data pointer to the parameter described, not the parameter
1153 * itself, due to a call by reference (Pascal VAR, for instance).
1154 * In the case where a call-by-value parameter is too big to be
1155 * passed in the parameter list (e.g., a copied-value parameter in
1156 * Pascal), the "location" must be given as the actual (post-copy)
1157 * location of the parameter.
1159 * "longaddr" is meaningful only for varparams, and indicates that
1160 * the storage location given contains a 64 bit PA-RISC long
1161 * pointer. The long pointer could be in 2 consecutive words, or
1162 * in the case of a regparam, two consecutive registers.
1164 * "copyparam" implies that the parameter has been copied to a local,
1165 * and thus the location is relative to the sp of the current procedure,
1166 * not the sp of the previous procdeure.
1168 * "misc" is for assorted values. Current uses are:
1169 * (1) if the parameter is of type T_FTN_STRING_S300
1170 * then the "misc" field contains the SP relative
1171 * offset of the word containing the length of
1174 * In the case of a FORTRAN routine with alternate entries, DNTT
1175 * DVARs also must be emited for each parameter. The reason is
1176 * that with FORTRAN alternate entries, the same parameter can
1177 * be in two different entry's parameter lists, in a different
1178 * location (ex. the parameter "x" in "subroutine a(x,y,z)" and
1179 * "entry b(v,w,x)") and yet they both represent the same parameter.
1180 * Thus in order to insure a consistant address for such parameters,
1181 * the compiler allocates a local temporary, and the prologue code
1182 * for each entry copies the parameters into the local temps. So, to
1183 * insure that the debugger can find the parameters, a DNTT DVAR
1184 * must be generated for each temporary, with the name of the DVAR
1185 * being the name of the FPARAM for which the temp. was allocated.
1187 * The FPARAM DNTT should be used only in the LNTT.
1192 /*0*/ BITS extension
: 1; /* always zero */
1193 KINDTYPE kind
: 10; /* always K_SVAR */
1194 BITS
public: 1; /* 1 => globally visible */
1195 BITS indirect
: 1; /* 1 => pointer to object */
1196 BITS longaddr
: 1; /* 1 => in long pointer space */
1198 BITS staticmem
: 1; /* 1 => member of a class */
1199 BITS a_union
: 1; /* 1 => anonymous union member */
1204 /*1*/ VTPOINTER name
; /* name of object (variable) */
1205 /*2*/ STATTYPE location
; /* where stored (allocated) */
1206 /*3*/ DNTTPOINTER type
; /* type information */
1207 /*4*/ unsigned long offset
; /* post indirection byte offset */
1208 /*5*/ unsigned long displacement
; /* pre indirection byte offset */
1212 /*0*/ BITS extension
: 1; /* always zero */
1213 KINDTYPE kind
: 10; /* always K_DVAR */
1214 BITS
public: 1; /* 1 => globally visible */
1215 BITS indirect
: 1; /* 1 => pointer to object */
1216 BITS regvar
: 1; /* 1 => REGTYPE, not DYNTYPE */
1218 BITS a_union
: 1; /* 1 => anonymous union member */
1223 /*1*/ VTPOINTER name
; /* name of object (variable) */
1224 /*2*/ DYNTYPE location
; /* where stored (allocated) */
1225 /*3*/ DNTTPOINTER type
; /* type information */
1226 /*4*/ unsigned long offset
; /* post indirection byte offset */
1227 /* for use in cobol structures */
1231 * SVARs describe static variables (with respect to storage, not
1232 * visibility) and DVARs describe dynamic variables, and also
1233 * describe register variables. Note that SVARs have an extra
1234 * word, "offset", not needed for the other types. This provides
1235 * for direct data which is indexed from a base, and indirect data
1236 * which is accessed through a pointer, then indexed.
1238 * The "location" field of an SVAR will require a fixup. An
1239 * example of when the offset field can be useful, is a FORTRAN
1240 * common block. In a common block declaration such as "common
1241 * /marx/ groucho, harpo, chico", the symbol "marx" is the only
1242 * global symbol. If "marx" is accessed indirectly, then the
1243 * address of "harpo" would contain the address of "marx" in the
1244 * location field (with the indirect bit on), and the offset of
1245 * "harpo" from "marx" in the offset field. If "marx" is not
1246 * indirect, then location field can be filled in by a fixup of the
1247 * form address(marx) + offset of harpo, and the offset field is
1250 * The compilers must emit SVARs even for data objects the linker
1251 * does not know about by name, such as variables in common blocks.
1253 * As in the FPARAM entry, the longaddr field indicates the use
1254 * of a PA-RISC long pointer, and is valid only if the indirect
1255 * flag is true. The "regvar" field also has the same meaning as in
1258 * For languages in which a functions return value is set by assigning
1259 * the value to the function name (such as FORTRAN & Pascal), a DVAR
1260 * entry should also be emitted for the function. The address of this
1261 * DVAR for the function should be the address of the answer spot for
1262 * the function. This will allow the user to display the current
1263 * return value while the function is executing.
1265 * For a FORTRAN subroutine with alternate entries, DNTT_DVARs are
1266 * required to represent the parameters, see the DNTT_FPARAM
1267 * definition for the details.
1269 * The SVAR can be used in both the GNTT and LNTT, while the DVAR
1270 * is only applicable to the LNTT.
1275 /*0*/ BITS extension
: 1; /* always zero */
1276 KINDTYPE kind
: 10; /* always K_CONST */
1277 BITS
public: 1; /* 1 => globally visible */
1278 BITS indirect
: 1; /* 1 => pointer to object */
1279 LOCDESCTYPE locdesc
: 3; /* meaning of location field */
1281 BITS classmem
: 1; /* 1 => member of a class */
1286 /*1*/ VTPOINTER name
; /* name of object */
1287 /*2*/ STATTYPE location
; /* where stored */
1288 /*3*/ DNTTPOINTER type
; /* type information */
1289 /*4*/ unsigned long offset
; /* post indirection byte offset */
1290 /*5*/ unsigned long displacement
; /* pre indirection byte offset */
1294 * The value of locdesc determines the meaning of location.
1295 * Compilers are free to use any of the three types (LOC_IMMED,
1296 * LOC_PTR, LOC_VT) as feasible and appropriate. They might, for
1297 * example, merely dump all CONST values into the VT, with some
1298 * redundancy, if they could do no better. Ideally, each compiler
1299 * would use all three types according to whether the constant is
1300 * stored in an immediate instruction (so a copy is needed here),
1301 * in code or data space, or nowhere else, respectively.
1303 * If locdesc == LOC_PTR, CONST is very much like an SVAR, and the
1304 * indirect and offset values are relevant.
1306 * The CONST DNTT can be used in both the GNTT and LNTT.
1311 * ---- 5.4. TYPE-CLASS ("TYPE") DNTT ENTRIES
1316 /*0*/ BITS extension
: 1; /* always zero */
1317 KINDTYPE kind
: 10; /* either K_TYPEDEF or K_TAGDEF */
1318 BITS
public: 1; /* 1 => globally visible */
1319 BITS typeinfo
: 1; /* 1 => type info available */
1321 /*1*/ VTPOINTER name
; /* name of type or tag */
1322 /*2*/ DNTTPOINTER type
; /* type information */
1323 }; /* three words */
1326 * The DNTT_TYPE type is used for dtype and dtag entries. TYPEDEFs
1327 * are just a way of remembering names associated with types
1328 * declared in Pascal, via "type" sections, or in C, via "typedef"s.
1329 * TAGDEFs are used for C "struct", "union", and "enum" tags, which
1330 * may be named identically to "typedef"s in the same scope.
1331 * TAGDEFs always point at STRUCTs, UNIONs, or ENUMs (see below),
1332 * and provide a way to "hang" a name onto a subtree.
1334 * Note that named types point directly to the underlying
1335 * structures, not to intervening TYPEDEFs or TAGDEFs. Type
1336 * information in TYPEDEFs and TAGDEFs point to the same structures
1337 * independent of named instantiations of the types.
1341 * typedef struct S { + typedef enum E { ... } EEE;
1345 * would generate something like this (shown graphically)
1347 * TYPEDEF "pS" + TYPEDEF "EEE"
1358 * Note also that variables (of a named non-base type) must point to
1359 * TYPEDEF or TAGDEF dntt, and not the underlying structures. If
1360 * this is not done, the removal of duplicate global information is
1363 * The "typeinfo" flag only applies to TAGDEFs. When not set, it is
1364 * used to indicate that an underlying struct, union, or enum is
1365 * named, but the actual type is not declared. In general,
1366 * "typeinfo" will be set to 1. It will be set to a 0 if the type
1367 * subtree is not available. Consider the C file:
1369 * typedef struct s *Sptr;
1372 * which is a valid compilation unit with "struct s" defined in
1373 * another file. For this case, the "typeinfo" for TAGDEF "s" will
1374 * be set to 0, and "type" points to a "nil" DNTT_STRUCT (i.e. a
1375 * DNTT_STRUCT entry with its "firstfield", "vartagfield", and
1376 * "varlist" fields set to DNTTNIL and its "declaration" and
1377 * "bitlength" fields set to 0). Graphically:
1386 * \---<firstfield>---> DNTTNIL
1387 * \--<vartagfield>--> DNTTNIL
1388 * \-<varlist>------> DNTTNIL
1389 * \- other fields > all set to 0
1392 * Thus, whenever "typeinfo" is 0, "type" must point to an
1393 * appropriate DNTT entry which has all its fields correctly NIL'ed.
1394 * This applies to *named* DNTT_STRUCT's, DNTT_UNION's, and
1397 * The TYPEDEF and TAGDEF DNTTs may be used in both the GNTT and
1403 struct DNTT_POINTER
{
1404 /*0*/ BITS extension
: 1; /* always zero */
1406 KINDTYPE kind
: 10; /* K_POINTER or K_REFERENCE */
1408 KINDTYPE kind
: 10; /* always K_POINTER */
1411 /*1*/ DNTTPOINTER pointsto
; /* type of object */
1412 /*2*/ unsigned long bitlength
; /* size of pointer, not object */
1413 }; /* three words */
1417 /*0*/ BITS extension
: 1; /* always zero */
1418 KINDTYPE kind
: 10; /* always K_ENUM */
1420 /*1*/ DNTTPOINTER firstmem
; /* first MEMENUM (member) */
1421 /*2*/ unsigned long bitlength
; /* packed size */
1422 }; /* three words */
1424 struct DNTT_MEMENUM
{
1425 /*0*/ BITS extension
: 1; /* always zero */
1426 KINDTYPE kind
: 10; /* always K_MEMENUM */
1428 BITS classmem
: 1; /* 1 => member of a class */
1433 /*1*/ VTPOINTER name
; /* name of member */
1434 /*2*/ unsigned long value
; /* equivalent number */
1435 /*3*/ DNTTPOINTER nextmem
; /* next MEMENUM, else ENUM type */
1439 * Each ENUM begins a chain of (name, value) pairs. The nextmem
1440 * field of the last memenum, should be DNTT NIL. The POINTER,
1441 * ENUM, and MEMENUM DNTTs can all be used in both the GNTT and
1447 /*0*/ BITS extension
: 1; /* always zero */
1448 KINDTYPE kind
: 10; /* always K_SET */
1449 BITS declaration
: 2; /* normal, packed, or crunched */
1451 /*1*/ DNTTPOINTER subtype
; /* type implies bounds of set */
1452 /*2*/ unsigned long bitlength
; /* packed size */
1453 }; /* three words */
1456 struct DNTT_SUBRANGE
{
1457 /*0*/ BITS extension
: 1; /* always zero */
1458 KINDTYPE kind
: 10; /* always K_SUBRANGE */
1459 BITS dyn_low
: 2; /* >0 => nonconstant low bound */
1460 BITS dyn_high
: 2; /* >0 => nonconstant high bound */
1462 /*1*/ long lowbound
; /* meaning depends on subtype */
1463 /*2*/ long highbound
; /* meaning depends on subtype */
1464 /*3*/ DNTTPOINTER subtype
; /* immediate type or ENUM */
1465 /*4*/ unsigned long bitlength
; /* packed size */
1470 /*0*/ BITS extension
: 1; /* always zero */
1471 KINDTYPE kind
: 10; /* always K_ARRAY */
1472 BITS declaration
: 2; /* normal, packed, or crunched */
1473 BITS dyn_low
: 2; /* >0 => nonconstant low bound */
1474 BITS dyn_high
: 2; /* >0 => nonconstant high bound */
1475 BITS arrayisbytes
: 1; /* 1 => array size is in bytes */
1476 BITS elemisbytes
: 1; /* 1 => elem. size is in bytes */
1477 BITS elemorder
: 1; /* 0 => in increasing order */
1478 BITS justified
: 1; /* 0 => left justified */
1480 /*1*/ unsigned long arraylength
; /* size of whole array */
1481 /*2*/ DNTTPOINTER indextype
; /* how to index the array */
1482 /*3*/ DNTTPOINTER elemtype
; /* type of each array element */
1483 /*4*/ unsigned long elemlength
; /* size of one element */
1487 * The dyn_low and dyn_high fields are non-zero only if the
1488 * DNTT_SUBRANGE is defining the range of an array index, otherwise
1489 * they are always zero. The dyn_low and dyn_high bits are
1490 * duplicated in the DNTT_SUBRANGE defining the range of the array
1491 * index (so sllic can fix the pointers). "dyn_low" indicates
1492 * whether the lower bound for the subscript of the array is
1493 * dynamic. If the dyn_low field is zero, then the lowbound field
1494 * of the DNTT_SUBRANGE entry, pointed to by the indextype field in
1495 * the DNTT_ARRAY entry, is interpreted as a constant lower bound.
1496 * If the dyn_low field is 1, then the lowbound field of the DNTT
1497 * SUBRANGE is interpreted as a DYNTYPE giving a local address where
1498 * the lower bound can be found. If the dyn_low field is 2, then
1499 * the lowbound field of the DNTT_SUBRANGE is interpreted as a
1500 * DNTTPOINTER to a variable whose value is the lower bound (needed
1501 * if the lower bound is a static variable). The dyn_low value of 3
1502 * is not used. The "dyn_high" bit has a similar meaning relating
1503 * to the upper bound. If an upper bound for an array parameter is
1504 * not given (like assumed size arrays in FORTRAN, or "char foo[]"
1505 * in C) then the upper bound in the DNTT_SUBRANGE should be the
1506 * largest integer that fits in a long integer, so that any value
1507 * the user can give is legal.
1509 * "arrayisbytes" indicates that the field "arraylength" contains
1510 * the length in bytes rather then bits. This is needed on PA-RISC
1511 * where an array could be up to 2**32 bytes. A value of zero for
1512 * bitsize will be used to represent 2**32.
1514 * "elemisbytes" indicates that the field "elemlength" contains the
1515 * elem. length in bytes rather then bits. The "elemlength" field
1516 * contains the not the "true" size of an array element, but the
1517 * size allocated to each element within the array (the "true" size
1518 * plus any wasted bits on the left or right). As an example for a
1519 * Pascal array of a 13 bit structure, the array element size might
1520 * equal 16, with the justified field equal to 0 to indicate the
1521 * structure is left justified within the 16 bits. The "true" size
1522 * of the structure would be found in the size field of the
1523 * DNTT_STRUCT pointed to by the "elemtype" field of the DNTT_ARRAY.
1525 * "indextype" typically points to a SUBRANGE for bounds.
1526 * "elemtype" may point to another ARRAY for multi-dimensional
1527 * arrays. Row or column precedence in the language is reflected in
1528 * the order of the ARRAY entries on the chain. For example, in
1529 * Pascal, which is row-precedent, an array declared [1..2, 3..4,
1530 * 5..6] would result in "array 1..2 of array 3..4 of array 5..6 of
1531 * ...". The same declaration in FORTRAN, which is
1532 * column-precedent, would result in "array 5..6 of array 3..4 of
1533 * array 1..2 of ...". This makes index-to-address conversion much
1534 * easier. Either way an expression handler must know the
1535 * precedence for the language.
1537 * The SET, SUBRANGE, and ARRAY DNTTs can be used in both the GNTT
1542 struct DNTT_STRUCT
{
1543 /*0*/ BITS extension
: 1; /* always zero */
1544 KINDTYPE kind
: 10; /* always K_STRUCT */
1545 BITS declaration
: 2; /* normal, packed, or crunched */
1547 /*1*/ DNTTPOINTER firstfield
; /* first FIELD, if any */
1548 /*2*/ DNTTPOINTER vartagfield
; /* variant tag FIELD, or type */
1549 /*3*/ DNTTPOINTER varlist
; /* first VARIANT, if any */
1550 /*4*/ unsigned long bitlength
; /* total at this level */
1554 * The "declaration", "vartagfield", and "varlist" fields apply to
1555 * Pascal/Modcal records only and are nil for record structures in
1556 * other languages. If there is a tag, then the "vartagfield" points
1557 * to the FIELD DNTT describing the tag. Otherwise, the "vartagfield"
1558 * points to the tag type.
1560 * The STRUCT DNTT may be used in both the GNTT and LNTT.
1565 /*0*/ BITS extension
: 1; /* always zero */
1566 KINDTYPE kind
: 10; /* always K_UNION */
1568 /*1*/ DNTTPOINTER firstfield
; /* first FIELD entry */
1569 /*2*/ unsigned long bitlength
; /* total at this level */
1570 }; /* three words */
1573 * This type supports C unions only and is not used otherwise.
1575 * Since STRUCTUREs and UNIONs are not packable inside of outer
1576 * STRUCTUREs and UNIONs, their bitlengths tell their actual (not
1577 * necessarily packed) size, according only as to how they are
1578 * internally packed.
1580 * The STRUCT DNTT may be used in both the GNTT and LNTT.
1585 /*0*/ BITS extension
: 1; /* always zero */
1586 KINDTYPE kind
: 10; /* always K_FIELD */
1588 BITS visibility
:2; /* pub = 0, prot = 1, priv = 2 */
1589 BITS a_union
: 1; /* 1 => anonymous union member */
1591 BITS staticMem
: 1; /* 1 -> static member of a template */
1593 #else /* TEMPLATES */
1595 #endif /* TEMPLATES */
1599 /*1*/ VTPOINTER name
; /* name of field, if any */
1600 /*2*/ unsigned long bitoffset
; /* of object itself in STRUCT */
1601 /*3*/ DNTTPOINTER type
; /* type information */
1602 /*4*/ unsigned long bitlength
; /* size at this level */
1603 /*5*/ DNTTPOINTER nextfield
; /* next FIELD in STRUCT, if any */
1607 * This type describes the fields in Pascal records and C
1608 * structures and unions. The bitoffset is from the start of the
1609 * STRUCT or UNION that started the chain, to the start of the
1610 * object itself, ignoring any padding. Note that bitoffset
1611 * does not have to be on a byte boundary. For unions, each
1612 * bitoffset should be zero since all fields overlap.
1614 * The bitlength field is the same as that of the type except for C
1615 * bit fields, which may be a different size than the base type.
1617 * The FIELD DNTT can be used in both the GNTT and LNTT.
1621 struct DNTT_VARIANT
{
1622 /*0*/ BITS extension
: 1; /* always zero */
1623 KINDTYPE kind
: 10; /* always K_VARIANT */
1625 /*1*/ long lowvarvalue
; /* meaning depends on vartype */
1626 /*2*/ long hivarvalue
; /* meaning depends on vartype */
1627 /*3*/ DNTTPOINTER varstruct
; /* this variant STRUCT, if any */
1628 /*4*/ unsigned long bitoffset
; /* of variant, in outer STRUCT */
1629 /*5*/ DNTTPOINTER nextvar
; /* next VARIANT, if any */
1633 * "varstruct" points to the STRUCT which in turn describes the
1634 * contents of the variant. The latter might in turn point to
1635 * VARIANTs of its own, and to FIELDs which point to other STRUCTs.
1636 * "lowvarvalue" and "hivarvalue" are the range of values for which
1637 * this variant applys; more than one dntt VARIANT may be necessary
1638 * to describe the range (e.g., 'a'..'n','q':). A type field is un-
1639 * necessary, as the type can be obtained from the "vartagfield"
1640 * field of the STRUCT DNTT.
1642 * The VARIANT DNTT can be used in both the GNTT and LNTT.
1647 /*0*/ BITS extension
: 1; /* always zero */
1648 KINDTYPE kind
: 10; /* always K_FILE */
1649 BITS ispacked
: 1; /* 1 => file is packed */
1651 /*1*/ unsigned long bitlength
; /* of whole element buffer */
1652 /*2*/ unsigned long bitoffset
; /* of current element in buffer */
1653 /*3*/ DNTTPOINTER elemtype
; /* type and size of of element */
1657 * Pascal/Modcal is the only language of interest with built-in file
1658 * buffering. For Pascal/Modcal files, the symbol table tells the file
1659 * element type, the sizes of the current element (via "elemtype")
1660 * and the whole buffer (via "bitlength"), and the locations of the
1661 * element buffer (from the parent "NAME" entry) and the element
1662 * itself within the buffer, following header information (from
1665 * The FILE DNTT can be used in both the GNTT and LNTT.
1669 struct DNTT_FUNCTYPE
{
1670 /*0*/ BITS extension
: 1; /* always zero */
1671 KINDTYPE kind
: 10; /* always K_FUNCTYPE */
1672 BITS varargs
: 1; /* func-proto ellipses. */
1673 BITS info
: 4; /* lang-specific stuff; F_xxxx */
1675 /*1*/ unsigned long bitlength
; /* size of function pointer */
1676 /*2*/ DNTTPOINTER firstparam
; /* first FPARAM, if any */
1677 /*3*/ DNTTPOINTER retval
; /* return type, if any */
1681 * This type supports function variables in a limited way,
1682 * including the parameter types (if any) and the return value type
1685 * See DNTT_FUNC for discussion of various fields.
1687 * The FUNCTYPE DNTT can be used in both the GNTT and LNTT.
1691 struct DNTT_COBSTRUCT
{
1692 /*0*/ BITS extension
: 1; /* always zero */
1693 KINDTYPE kind
: 10; /* always K_COBSTRUCT */
1694 BITS hasoccurs
: 1; /* descendant has OCCURS clause */
1695 BITS istable
: 1; /* is a table item? */
1697 /*1*/ DNTTPOINTER parent
; /* next higher data item */
1698 /*2*/ DNTTPOINTER child
; /* 1st descendant data item */
1699 /*3*/ DNTTPOINTER sibling
; /* next data item at this level */
1700 /*4*/ DNTTPOINTER synonym
; /* next data item w/ same name */
1701 /*5*/ BITS catusage
: 6; /* category or usage of item */
1702 BITS pointloc
: 8; /* location of decimal point */
1703 BITS numdigits
:10; /* number of digits */
1705 /*6*/ DNTTPOINTER table
; /* array entry describing table */
1706 /*7*/ VTPOINTER editpgm
; /* name of edit subprogram */
1707 /*8*/ unsigned long bitlength
; /* size of item in bits */
1711 * This entry is used to describe COBOL data items and table items.
1712 * A Cobol variable will begin with a DNTT_SVAR, DNTT_DVAR, or DNTT_
1713 * FPARAM whose "type" field is a DNTTPOINTER to a DNTT_COBSTRUCT.
1715 * "parent", "child", "sibling", and "synonym" are DNTTPOINTER to
1716 * other DNTT_SVAR, DNTT_DVAR, or DNTT_FPARAMs having these particular
1717 * relationships with the current DNTT_COBSTRUCT (or are set to DNTTNIL
1718 * if no such relationship exists).
1720 * "hasoccurs" is set to 1 if the descendent of this COBOL element
1721 * (pointed to by "child") has an OCCURS ... DEPENDING ON clause.
1723 * "istable" is set to 1 if this COBOL data item is a table. In this
1724 * case, "table" will point to a DNTT_ARRAY entry describing the table.
1726 * The COBSTRUCT DNTT can be used in both the GNTT and LNTT.
1730 * Used for C too so pulled out of ifdef CPLUSPLUS.
1733 struct DNTT_MODIFIER
{
1734 /*0*/ BITS extension
: 1; /* always zero */
1735 KINDTYPE kind
: 10; /* always K_MODIFIER */
1736 BITS m_const
: 1; /* const */
1737 BITS m_static
: 1; /* static */
1738 BITS m_void
: 1; /* void */
1739 BITS m_volatile
: 1; /* volatile */
1740 BITS m_duplicate
: 1; /* duplicate */
1742 /*1*/ DNTTPOINTER type
; /* subtype */
1746 struct DNTT_GENFIELD
{
1747 /*0*/ BITS extension
: 1; /* always zero */
1748 KINDTYPE kind
: 10; /* always K_GENFIELD */
1749 BITS visibility
: 2; /* pub = 0, prot = 1, priv = 2 */
1750 BITS a_union
: 1; /* 1 => anonymous union member */
1752 /*1*/ DNTTPOINTER field
; /* pointer to field or qualifier */
1753 /*2*/ DNTTPOINTER nextfield
; /* pointer to next field */
1754 }; /* three words */
1756 struct DNTT_MEMACCESS
{
1757 /*0*/ BITS extension
: 1; /* always zero */
1758 KINDTYPE kind
: 10; /* always K_MEMACCESS */
1760 /*1*/ DNTTPOINTER classptr
; /* pointer to base class */
1761 /*2*/ DNTTPOINTER field
; /* pointer field */
1762 }; /* three words */
1765 /*0*/ BITS extension
: 1; /* always zero */
1766 KINDTYPE kind
: 10; /* always K_VFUNCTION */
1767 BITS pure
: 1; /* pure virtual function ? */
1769 /*1*/ DNTTPOINTER funcptr
; /* function name */
1770 /*2*/ unsigned long vtbl_offset
; /* offset into vtbl for virtual */
1771 }; /* three words */
1773 struct DNTT_CLASS_SCOPE
{
1774 /*0*/ BITS extension
: 1; /* always zero */
1775 KINDTYPE kind
: 10; /* always K_CLASS_SCOPE */
1777 /*1*/ SLTPOINTER address
; /* pointer to SLT entry */
1778 /*2*/ DNTTPOINTER type
; /* pointer to class type DNTT */
1779 }; /* three words */
1781 struct DNTT_FRIEND_CLASS
{
1782 /*0*/ BITS extension
: 1; /* always zero */
1783 KINDTYPE kind
: 10; /* always K_FRIEND_CLASS */
1785 /*1*/ DNTTPOINTER classptr
; /* pointer to class DNTT */
1786 /*2*/ DNTTPOINTER next
; /* next DNTT_FRIEND */
1787 }; /* three words */
1789 struct DNTT_FRIEND_FUNC
{
1790 /*0*/ BITS extension
: 1; /* always zero */
1791 KINDTYPE kind
: 10; /* always K_FRIEND_FUNC */
1793 /*1*/ DNTTPOINTER funcptr
; /* pointer to function */
1794 /*2*/ DNTTPOINTER classptr
; /* pointer to class DNTT */
1795 /*3*/ DNTTPOINTER next
; /* next DNTT_FRIEND */
1799 /*0*/ BITS extension
: 1; /* always zero */
1800 KINDTYPE kind
: 10; /* always K_CLASS */
1801 BITS abstract
: 1; /* is this an abstract class? */
1802 BITS class_decl
: 2; /* 0=class,1=union,2=struct */
1804 BITS expansion
: 1; /* 1=template expansion */
1806 #else /* TEMPLATES */
1808 #endif /* TEMPLATES */
1809 /*1*/ DNTTPOINTER memberlist
; /* ptr to chain of K_[GEN]FIELDs */
1810 /*2*/ unsigned long vtbl_loc
; /* offset in obj of ptr to vtbl */
1811 /*3*/ DNTTPOINTER parentlist
; /* ptr to K_INHERITANCE list */
1812 /*4*/ unsigned long bitlength
; /* total at this level */
1813 /*5*/ DNTTPOINTER identlist
; /* ptr to chain of class ident's */
1814 /*6*/ DNTTPOINTER friendlist
; /* ptr to K_FRIEND list */
1816 /*7*/ DNTTPOINTER templateptr
; /* ptr to template */
1817 /*8*/ DNTTPOINTER nextexp
; /* ptr to next expansion */
1818 #else /* TEMPLATES */
1819 /*7*/ unsigned long future2
;
1820 /*8*/ unsigned long future3
;
1821 #endif /* TEMPLATES */
1825 struct DNTT_TEMPLATE
{
1826 /*0*/ BITS extension
: 1; /* always zero */
1827 KINDTYPE kind
: 10; /* always K_TEMPLATE */
1828 BITS abstract
: 1; /* is this an abstract class? */
1829 BITS class_decl
: 2; /* 0=class,1=union,2=struct */
1831 /*1*/ DNTTPOINTER memberlist
; /* ptr to chain of K_[GEN]FIELDs */
1832 /*2*/ long unused2
; /* offset in obj of ptr to vtbl */
1833 /*3*/ DNTTPOINTER parentlist
; /* ptr to K_INHERITANCE list */
1834 /*4*/ unsigned long bitlength
; /* total at this level */
1835 /*5*/ DNTTPOINTER identlist
; /* ptr to chain of class ident's */
1836 /*6*/ DNTTPOINTER friendlist
; /* ptr to K_FRIEND list */
1837 /*7*/ DNTTPOINTER arglist
; /* ptr to argument list */
1838 /*8*/ DNTTPOINTER expansions
; /* ptr to expansion list */
1842 * DNTT_TEMPLATEs only appear in the GNTT. Functions and
1843 * classes templates cannot be local. (Their instantions may be).
1846 struct DNTT_TEMPL_ARG
{
1847 /*0*/ BITS extension
: 1; /* always zero */
1848 KINDTYPE kind
: 10; /* always K_TEMPL_ARG */
1849 BITS usagetype
:1; /* 0 type-name 1 expression */
1851 /*1*/ VTPOINTER name
; /* name of argument */
1852 /*2*/ DNTTPOINTER type
; /* for non type arguments */
1853 /*3*/ DNTTPOINTER nextarg
; /* Next argument if any */
1854 /*4*/ long unused2
[2];
1858 * Pxdb fills in the prevexp, and nextexp in the
1859 * DNTT_CLASS. Pxdb also fills in the expansions field in the
1862 #endif /* TEMPLATES */
1864 struct DNTT_PTRMEM
{
1865 /*0*/ BITS extension
: 1; /* always zero */
1866 KINDTYPE kind
: 10; /* K_PTRMEM or K_PTRMEMFUNC */
1868 /*1*/ DNTTPOINTER pointsto
; /* pointer to class DNTT */
1869 /*2*/ DNTTPOINTER memtype
; /* type of member */
1870 }; /* three words */
1872 struct DNTT_INHERITANCE
{
1873 /*0*/ BITS extension
: 1; /* always zero */
1874 KINDTYPE kind
: 10; /* K_INHERITANCE */
1875 BITS Virtual
: 1; /* virtual base class ? */
1876 BITS visibility
: 2; /* pub = 0, prot = 1, priv = 2 */
1878 /*1*/ DNTTPOINTER classname
; /* first parent class, if any */
1879 /*2*/ unsigned long offset
; /* offset to start of base class */
1880 /*3*/ DNTTPOINTER next
; /* pointer to next K_INHERITANCE */
1883 struct DNTT_OBJECT_ID
{
1884 /*0*/ BITS extension
: 1; /* always zero */
1885 KINDTYPE kind
: 10; /* K_OBJECT_ID */
1887 /*1*/ unsigned long object_ident
; /* object identifier */
1888 /*2*/ unsigned long offset
; /* offset to start of base class */
1889 /*3*/ DNTTPOINTER next
; /* pointer to next K_OBJECT_ID */
1890 /*4*/ unsigned long segoffset
; /* for linker fixup */
1896 * This entry is used to retrieve cross-reference information from
1897 * the XREF Table (XT). A DNTT_XREF entry immediately follows the
1898 * DNTT_SVAR, DNTT_DVAR, DNTT_TYPE, etc. entry to which it pertains.
1900 * The XREFPOINTER points into the XT table where the information
1901 * about the previous DNTT entry is contained. If no entries are
1902 * generated in the XT table, the xreflist field should contain
1903 * XREFNIL. The language field contains the source language
1904 * (LANG_xxx) value of the DNTT object.
1906 * The XREF DNTT can be used in both the GNTT and LNTT.
1910 /*0*/ BITS extension
: 1; /* always zero */
1911 KINDTYPE kind
: 10; /* always K_XREF */
1912 BITS language
: 4; /* language of DNTT object */
1914 /*1*/ XREFPOINTER xreflist
; /* index into XREF subspace */
1915 /*2*/ long extra
; /* free */
1916 }; /* three words */
1921 * This entry is used with static analysis info. It supplies the
1922 * name and kind for a few special cases not currently handled by a
1923 * DNTT_SVAR, DNTT_DVAR, DNTT_TYPE, etc. It is used for a local
1924 * entity that has a global scope.
1926 * Example: a function, has a DNTT_FUNCTION entry in the LNTT;
1927 * but it can be seen globally, thus a K_SA will be emitted in
1928 * the GNTT, with the functions name and a base_kind of K_FUNCTION;
1929 * the DNTT_XREF will follow the DNTT_SA, not the DNTT_FUNCTION.
1931 * The DNTT_SA is also used for C macros.
1933 * The XREF DNTT can be used in both the GNTT and LNTT.
1937 /*0*/ BITS extension
: 1; /* always zero */
1938 KINDTYPE kind
: 10; /* always K_SA */
1939 KINDTYPE base_kind
:10; /* K_FUNCTION, K_LABEL, etc */
1941 /*1*/ VTPOINTER name
;
1942 /*2*/ long extra
; /* free */
1943 }; /* three words */
1947 * ---- 5.5. OVERALL DNTT ENTRY FORMAT
1952 * Generic entry for easy access:
1955 struct DNTT_GENERIC
{ /* rounded up to whole number of blocks */
1956 unsigned long word
[9];
1959 struct DNTT_BLOCK
{ /* easy way to deal with one block */
1960 /*0*/ BITS extension
: 1; /* always zero */
1961 KINDTYPE kind
: 10; /* kind of dnttentry */
1963 /*1*/ unsigned long word
[2];
1972 struct DNTT_SRCFILE dsfile
;
1974 struct DNTT_MODULE dmodule
;
1975 struct DNTT_FUNC dfunc
;
1976 struct DNTT_FUNC dentry
;
1977 struct DNTT_FUNC dblockdata
;
1978 struct DNTT_BEGIN dbegin
;
1979 struct DNTT_END dend
;
1980 struct DNTT_IMPORT dimport
;
1981 struct DNTT_LABEL dlabel
;
1982 struct DNTT_WITH dwith
;
1983 struct DNTT_COMMON dcommon
;
1985 struct DNTT_FPARAM dfparam
;
1986 struct DNTT_SVAR dsvar
;
1987 struct DNTT_DVAR ddvar
;
1988 struct DNTT_CONST dconst
;
1990 struct DNTT_TYPE dtype
;
1991 struct DNTT_TYPE dtag
;
1992 struct DNTT_POINTER dptr
;
1993 struct DNTT_ENUM denum
;
1994 struct DNTT_MEMENUM dmember
;
1995 struct DNTT_SET dset
;
1996 struct DNTT_SUBRANGE dsubr
;
1997 struct DNTT_ARRAY darray
;
1998 struct DNTT_STRUCT dstruct
;
1999 struct DNTT_UNION dunion
;
2000 struct DNTT_FIELD dfield
;
2001 struct DNTT_VARIANT dvariant
;
2002 struct DNTT_FILE dfile
;
2003 struct DNTT_FUNCTYPE dfunctype
;
2004 struct DNTT_COBSTRUCT dcobstruct
;
2007 struct DNTT_CLASS_SCOPE dclass_scope
;
2008 struct DNTT_POINTER dreference
;
2009 struct DNTT_PTRMEM dptrmem
;
2010 struct DNTT_PTRMEM dptrmemfunc
;
2011 struct DNTT_CLASS dclass
;
2012 struct DNTT_GENFIELD dgenfield
;
2013 struct DNTT_VFUNC dvfunc
;
2014 struct DNTT_MEMACCESS dmemaccess
;
2015 struct DNTT_INHERITANCE dinheritance
;
2016 struct DNTT_FRIEND_CLASS dfriend_class
;
2017 struct DNTT_FRIEND_FUNC dfriend_func
;
2018 struct DNTT_MODIFIER dmodifier
;
2019 struct DNTT_OBJECT_ID dobject_id
;
2020 struct DNTT_FUNC dmemfunc
;
2022 struct DNTT_TEMPLATE dtemplate
;
2023 struct DNTT_TEMPL_ARG dtempl_arg
;
2024 struct DNTT_FUNC_TEMPLATE dfunctempl
;
2025 struct DNTT_LINK dlink
; /* generic */
2026 struct DNTT_TFUNC_LINK dtflink
;
2027 #endif /* TEMPLATES */
2030 struct DNTT_XREF dxref
;
2033 struct DNTT_GENERIC dgeneric
;
2034 struct DNTT_BLOCK dblock
;
2039 * ---- 6. SOURCE LINE TABLE (SLT) ENTRY FORMAT
2043 * Type of SLT special entry:
2045 * Sizeof (SLTTYPE) = 4 bits, for a maximum of 16 possible special
2046 * slttypes. Note that SLT_NIL is the same as SLTNIL.
2049 typedef unsigned int SLTTYPE
;
2051 #define SLT_NIL SLTNIL
2053 #define SLT_NORMAL 0 /* note that the field is unsigned */
2054 #define SLT_SRCFILE 1
2055 #define SLT_MODULE 2
2056 #define SLT_FUNCTION 3
2062 #define SLT_ASSIST 9
2063 #define SLT_MARKER 10
2065 #define SLT_CLASS_SCOPE 11
2069 SLTTYPE sltdesc
: 4; /* always zero */
2070 BITS line
: 28; /* where in source text */
2071 ADDRESS address
; /* where in function */
2075 SLTTYPE sltdesc
: 4; /* special entry type */
2076 BITS line
: 28; /* where in source text */
2077 DNTTPOINTER backptr
; /* where in DNTT */
2081 SLTTYPE sltdesc
: 4; /* always nine */
2083 SLTPOINTER address
; /* first SLT normal */
2086 struct SLT_GENERIC
{
2087 unsigned long word
[2];
2092 struct SLT_NORM snorm
;
2093 struct SLT_SPEC sspec
;
2094 struct SLT_ASST sasst
;
2095 struct SLT_GENERIC sgeneric
;
2098 #define SLTBLOCKSIZE 8
2099 #define SLT_LN_PROLOGUE 0x0fffffff
2102 * This table consists of a series of entries, each of which is
2103 * either normal, special, or assist according to the sltdesc field
2104 * of the first word. Normal entries contain an address (actually
2105 * a code offset relative to the beginning of the current function)
2106 * and a source/listing line (by line number). Listing line numbers
2107 * may be used in place of source line numbers based upon a compiler
2108 * option. This will also be reflected in the DNTT_SRCFLE entries.
2109 * Special entries also provide a line number (where something was
2110 * declared) and point back to the DNTT which references them. This
2111 * is used for quick determination of scope, including source/listing
2112 * file, after an interrupt. Even if there are multiple source/listing
2113 * files, all source/listing line information is accumulated in this
2116 * The SLT was originally designed to be unnested, even for those
2117 * languages whose LNTT must reflect their nesting. The debuggers
2118 * depend upon this. For those languages that are nested the SLT
2119 * must now be nested and an SLT_ASST must immediately follow each
2120 * SLT_SPEC of type FUNC. The "address" field will be filled in by
2121 * the compiler back-ends to point forward to the first SLT_NORM in
2122 * the FUNC's scope. The "firstnorm" is set to one if this SLT_NORM
2123 * is the first SLT_NORM looking sequentially forward in the SLT.
2125 * The one exception to the normal/special/assist rule is the EXIT SLT.
2126 * The EXIT SLT is used to identify exit points for a routine. The
2127 * EXIT SLT is a special only in the sense that the sltdesc field
2128 * is not equal to SLT_NORMAL. However, it contains a line number
2129 * and address like a normal SLT. The EXIT SLT is used in place of
2130 * a NORMAL SLT for all exit statements (such as "return" in C and
2131 * FORTRAN, or the "end" of a procedure body in Pascal).
2133 * The SLT_MARKER is for use in "Chunk-Per-Som". The address field
2134 * contains a new base address (replacing the current procedure's
2135 * low-address field. This new base address will be added to succeding
2136 * SLT_NORMALs and SLT_EXITs to produce an absolute address.
2138 * To distinguish prologue (function setup) code emitted at the END
2139 * of a function from the last line (normal SLT) of the function, a
2140 * normal SLT entry with a line number of SLT_LN_PRLOGUE is used.
2141 * Such SLT entries are only emitted if there is trailing prologue
2142 * code, and they are always the last SLT emitted for the function
2143 * except for the special SLT entry for the function END. For com-
2144 * pilers that emit the prologue code before the main body, no
2145 * special prologue SLT entry is required.
2147 * One SLT entry is emitted for (the FIRST physical line of) each
2148 * executable statement, for each construct that generates a DNTT
2149 * entry which points to an SLT entry, and for the prologue code,
2150 * if any. The user cannot set a breakpoint without a corresponding
2151 * SLT entry. Compilers must emit multiple SLT entries for parts
2152 * of a composite statement (such as FOR) and for multiple statements
2153 * appearing on one source line.
2155 * For compatibility, the high bits of DNTTPOINTERs in SLT entries
2156 * are also set to 1, even though they are not needed here.
2158 * The global bit on DNTTPOINTERs in SLT entries should always be 0,
2159 * as the LNTT contains all the scoping information.
2163 * ---- 7. VALUE TABLE (VT) ENTRY FORMAT
2166 * This table contains symbol names plus values for DNTT_CONST
2167 * entries of type LOC_VT. All strings are null-terminated, as in C.
2168 * There are no restrictions on the lengths of values nor the order
2169 * in which they may appear. All symbol names are exactly as given
2170 * by the user, e.g. there are no prepended underscores.
2172 * CONST values are not (and need not be) terminated in any way.
2173 * They may be forced to word boundaries if necessary, with
2174 * resulting wasted bytes.
2176 * The first byte of the table must be zero (a null string
2177 * terminator), so that the null VTPOINTER results in a null name.
2181 * ---- 8. XREF TABLE (XT) ENTRY FORMAT
2183 * This table contains static information about each named object in
2184 * a compilation unit. It consists of a collection of of lists,
2185 * each list associated with a DNTT object via the DNTT_XREF that
2186 * follows the object. The DNTT_XREF contains an XREFPOINTER which
2187 * is an offset into the XT table, and denotes the beginning of the
2190 * Each list is actually one or more of linear sub-list that are
2191 * linked together. Each sublist begins with an XREFNAME entry,
2192 * which names a (current) source file. Following the XREFNAME is
2193 * one or more XREFINFO entries, one for each appearance of the
2194 * object's name in the current file. These entries list what type
2195 * of reference and the line no. within the file. Column numbers
2196 * are currently unsupported. The XREFINFO1 structure is normally
2197 * used. The XREFINFO2A/B structure pair is only used for compilers
2198 * which support line numbers greater than 16 bits long. An
2199 * XREFLINK marks the end of a sublist, so a typical sequence looks
2202 * XREFNAME, XREFINFO1, XREFINFO1, ... , XREFLINK
2204 * Note that all elements of a sublist must appear in sequence
2205 * (linearly). If the list must be continued, the XREFLINK serves
2206 * as a continuation pointer from one sublist to the next, and
2207 * contains another offset into the XT where the next sublist is
2208 * found for the same named object. If there is no additional
2209 * sublist, the XREFLINK contains a 0 index, denoting the end of the
2212 * Lists for the same named object may appear in different
2213 * compilation units. It is the responsibility of PXDB to link
2218 #define XTBLOCKSIZE 4
2226 BITS tag
: 3; /* always XINFO1 */
2227 BITS definition
: 1; /* True => definition */
2228 BITS declaration
: 1; /* True => declaration */
2229 BITS modification
: 1; /* True => modification */
2230 BITS use
: 1; /* True => use */
2231 BITS call
: 1; /* True => call */
2232 BITS column
: 8; /* Unsigned Byte for Column within line */
2233 BITS line
: 16; /* Unsigned 16-bits for line # relative */
2234 /* to beginning of current inlude file. */
2239 BITS tag
: 3; /* always XINFO2A */
2240 BITS definition
: 1; /* True => definition */
2241 BITS declaration
: 1; /* True => declaration */
2242 BITS modification
: 1; /* True => modification */
2243 BITS use
: 1; /* True => use */
2244 BITS call
: 1; /* True => call */
2245 BITS extra
: 16; /* ? */
2246 BITS column
: 8; /* ? */
2251 BITS line
: 32; /* Unsigned 32-bits for line # relative */
2252 /* to beginning of current file. */
2256 BITS tag
: 3; /* always XLINK for XREFLINK */
2257 BITS next
: 29; /* index of next list. If */
2258 /* zero then this is the end of line. */
2259 /* a.k.a. continuation pointer */
2262 BITS tag
: 3; /* always XNAME for XREFNAME */
2263 BITS filename
: 29; /* VTPOINTER to file name */
2267 struct XREFINFO1 xrefshort
;
2268 struct XREFINFO2A xreflong
;
2269 struct XREFINFO2B xrefline
;
2270 struct XREFLINK xlink
;
2271 struct XREFNAME xfname
;
2276 * ---- 9. ORDERING OF TABLE ENTRIES
2279 * LNTT and SLT entries must be emitted and kept in source file
2280 * order wherever possible. As a minimum, named LNTT entries must
2281 * be emitted and kept within the proper scope, though some
2282 * compilers may emit them at the end of a scope instead of the
2283 * beginning. In general, the debugger must know the emission
2284 * rules for the language it is dealing with, and search the LNTT
2285 * accordingly, or else always search in both directions.
2287 * Items in the GNTT are all global, so the public bit must always
2288 * be set. Within the LNTT, the public bit indicates that the item
2289 * is exported by the module in which it resides, and is visible
2290 * within a module or procedure that imports the containing module.
2292 * Compilers and linkers are encouraged to make multiple references
2293 * to DNTT, SLT, and VT entries (even chains of DNTT entries) where
2294 * possible to reduce redundancy with no loss of data. They are
2295 * also encouraged to emit entries grouped so that related entries
2296 * are physically close, as long as no scope rules are violated.
2298 * SLT entries must be emitted in sorted line number order within
2299 * each file, except for special SLT entries for ENTRYs and
2300 * FUNCTIONs only. They may be out of line number order (due to
2301 * nested functions, etc.) so long as the next normal SLT entry is
2302 * the proper place to breakpoint the entity. For example, there
2303 * can be numerous ENTRY types after a FUNCTION, all referring to
2304 * the same code location. (If there are no normal SLT entries
2305 * before the next FUNCTION or MODULE entry and a SLT_ASST does not
2306 * immediately follow the SLT_SPEC for a FUNC, the entity has no
2307 * breakpointable locations.)
2309 * SLT entries must be sorted in ascending code address order
2310 * WITHIN EACH MODULE or FUNCTION body. It is impossible to
2311 * require that they be sorted both by file line number and code
2312 * address because function object code may be emitted or linked
2313 * out of source order in a segment.
2315 * It is reasonable to expect sequential SLT entries may have the
2316 * same line numbers or code locations (but not both, as that would
2317 * be redundant). This might be due to multiple statements on one
2318 * source line or several scope levels starting at one place in the
2321 * Thus, for nested languages like Pascal and Modcal, the LNTT
2322 * entries must be nested to reflect the program's scope. The SLT
2323 * entries should also be nested with an SLT_ASST entry following
2324 * each SLT_SPEC of type FUNC.
2329 * ---- 10. LINKER CONSIDERATIONS
2331 * As stated earlier, all fixups to the debug information are
2332 * done through the generation of a list of fixups for the GNTT
2333 * and LNTT subspaces within the debug space. Other than these
2334 * fixups, the only other task for the linker is the concatenation
2335 * of the debug spaces from separate compilation units.
2340 * --- 11. PREPROCESSOR
2344 * The preprocessor (PXDB) which must be run on the debug info in
2345 * the executable program file massages this debug info so that the
2346 * debugger may start up and run more efficiently. Some of the
2347 * tasks performed by PXDB are: remove duplicate global type and
2348 * variable information from the GNTT, append the GNTT onto the end
2349 * of the LNTT and place both back in the LNTT section, build quick
2350 * look-up tables for files, procedures, modules, and paragraphs
2351 * (for Cobol), placing these in the GNTT section, and reconstruct
2352 * the header appearing in the header section to access this
2355 * This post-PXDB header is as follows:
2358 struct PXDB_header
{
2359 int pd_entries
; /* # of entries in function look-up table */
2360 int fd_entries
; /* # of entries in file look-up table */
2361 int md_entries
; /* # of entries in module look-up table */
2362 BITS pxdbed
: 1; /* 1 => file has been preprocessed */
2363 BITS bighdr
: 1; /* 1 => this header contains 'time' word */
2364 BITS sa_header
: 1;/* 1 => created by SA version of pxdb */
2365 /* used for version check in xdb */
2367 BITS inlined
: 1; /* one or more functions have been inlined */
2369 short version
; /* pxdb header version */
2370 #else /* CPLUSPLUS */
2372 #endif /* CPLUSPLUS */
2373 int globals
; /* index into the DNTT where GNTT begins */
2374 BITS time
; /* modify time of file before being pxdbed */
2375 int pg_entries
; /* # of entries in label look-up table */
2376 int functions
; /* actual number of functions */
2377 int files
; /* actual number of files */
2379 int cd_entries
; /* # of entries in class look-up table */
2380 int aa_entries
; /* # of entries in addr alias look-up table */
2381 int oi_entries
; /* # of entries in object id look-up table */
2385 #define PXDB_VERSION_CPLUSPLUS 1
2386 #define PXDB_VERSION_7_4 2
2387 #define PXDB_VERSION_CPP_30 3
2389 #define PXDB_VERSION_2_1 1
2392 * The structures for the quick look-up tables in the
2393 * post-PXDB GNTT section are:
2397 * Source File Descriptor:
2399 * An element of the source file quick look-up table
2402 typedef struct FDS
{
2403 long isym
; /* first symbol for file */
2404 ADRT adrStart
; /* mem adr of start of file's code */
2405 ADRT adrEnd
; /* mem adr of end of file's code */
2406 char *sbFile
; /* name of source file */
2407 BITS fHasDecl
: 1; /* do we have a .d file? */
2408 BITS fWarned
: 1; /* have warned about age problems? */
2409 unsigned short ilnMac
; /* lines in file (0 if don't know) */
2410 int ipd
; /* first proc for file, in PD [] */
2411 BITS
*rgLn
; /* line pointer array, if any */
2415 * Procedure Descriptor:
2417 * An element of the procedure quick look-up table
2420 typedef struct PDS
{
2421 long isym
; /* first symbol for proc */
2422 ADRT adrStart
; /* memory adr of start of proc */
2423 ADRT adrEnd
; /* memory adr of end of proc */
2424 char *sbAlias
; /* alias name of procedure */
2425 char *sbProc
; /* real name of procedure */
2426 ADRT adrBp
; /* address of entry breakpoint */
2427 ADRT adrExitBp
; /* address of exit breakpoint */
2429 int icd
; /* member of this class */
2430 #else /* CPLUSPLUS */
2431 BITS inst
; /* instruction at entry */
2432 #endif /* CPLUSPLUS */
2434 BITS ipd
; /* index of template for this function */
2435 #else /* TEMPLATES */
2436 BITS instExit
; /* instruction at exit */
2437 #endif /* TEMPLATES */
2441 BITS fTemplate
: 1; /* function template */
2442 BITS fExpansion
: 1; /* function expansion */
2443 BITS linked
: 1; /* linked with other expansions */
2444 #else /* TEMPLATES */
2446 #endif /* TEMPLATES */
2447 BITS duplicate
: 1; /* clone of another procedure */
2448 BITS overloaded
:1; /* overloaded function */
2449 BITS member
: 1; /* class member function */
2450 BITS constructor
:1; /* constructor function */
2451 BITS destructor
:1; /* destructor function */
2452 BITS Static
: 1; /* static function */
2453 BITS Virtual
: 1; /* virtual function */
2454 BITS constant
: 1; /* constant function */
2455 BITS pure
: 1; /* pure (virtual) function */
2456 BITS language
: 4; /* procedure's language */
2457 BITS inlined
: 1; /* function has been inlined */
2458 BITS Operator
: 1; /* operator function */
2459 BITS stub
: 1; /* bodyless function */
2462 BITS language
: 4; /* procedure's language */
2465 BITS optimize
: 2; /* optimization level */
2466 BITS level
: 5; /* nesting level (top=0) */
2470 * Module Descriptor:
2472 * An element of the module quick reference table
2475 typedef struct MDS
{
2476 long isym
; /* first symbol for module */
2477 ADRT adrStart
; /* adr of start of mod. */
2478 ADRT adrEnd
; /* adr of end of mod. */
2479 char *sbAlias
; /* alias name of module */
2480 char *sbMod
; /* real name of module */
2481 BITS imports
: 1; /* module have any imports? */
2482 BITS vars_in_front
: 1; /* module globals in front? */
2483 BITS vars_in_gaps
: 1; /* module globals in gaps? */
2485 BITS unused2
; /* space for future stuff */
2490 * Paragraph Descriptor:
2492 * An element of the paragraph quick look-up table
2495 typedef struct PGS
{
2496 long isym
; /* first symbol for label */
2497 ADRT adrStart
; /* memory adr of start of label */
2498 ADRT adrEnd
; /* memory adr of end of label */
2499 char *sbLab
; /* name of label */
2500 BITS inst
; /* Used in xdb to store inst @ bp */
2501 BITS sect
: 1; /* true = section, false = parag. */
2502 BITS unused
: 31; /* future use */
2509 * An element of the class quick look-up table
2512 typedef struct CDS
{
2513 char *sbClass
; /* name of class */
2514 long isym
; /* class symbol (tag) */
2515 BITS type
: 2; /* 0=class, 1=union, 2=struct */
2517 BITS fTemplate
: 1;/* class template */
2518 BITS expansion
: 1;/* template expansion */
2520 #else /* TEMPLATES */
2522 #endif /* TEMPLATES */
2523 SLTPOINTER lowscope
; /* beginning of defined scope */
2524 SLTPOINTER hiscope
; /* end of defined scope */
2528 * Address Alias Entry
2530 * An element of the address alias quick look-up table
2533 typedef struct AAS
{
2538 BITS alternate
: 1; /* alternate unnamed aliases? */
2542 * Object Identification Entry
2544 * An element of the object identification quick look-up table
2547 typedef struct OIS
{
2548 ADRT obj_ident
; /* class identifier */
2549 long isym
; /* class symbol */
2550 long offset
; /* offset to object start */
2553 #endif /*CPLUSPLUS*/
2559 #endif /* _SYMTAB_INCLUDED */