--- /dev/null
+/***************************************************************************
+ * (c) Copyright 1988 - 1993 HEWLETT-PACKARD COMPANY. All rights reserved. *
+ ***************************************************************************/
+
+/***************************************************************************
+ * This program is "free" software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; Version 2, June 1991.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this include file; if not, write to the Free Software Foundation,
+ * Inc, 675 Mass Ave, Cambridge, MA 02139, USA
+ *
+ ***************************************************************************/
+
+/***************************************************************************
+ *
+ * Hewlett-Packard Company will not respond to external queries regarding
+ * the distribution or content of this include file. The University of
+ * Utah Center for Software Science (CSS) is the contact point for its
+ * distribution. CSS distributes this file under the terms of the GNU
+ * General Public License, as above: WITHOUT ANY WARRANTY. CSS makes NO
+ * WARRANTY as to the file's accuracy or timeliness. This file is NOT
+ * SUPPORTED by CSS.
+ *
+ * The current distributed version of this file is available by
+ * anonymous ftp from jaguar.cs.utah.edu in dist/hpux-symtab.h.
+ * The GNU General Public License is in dist/COPYING.
+ * Email may be directed to pa-gdb-bugs@cs.utah.edu.
+ *
+ ***************************************************************************/
+
+#ifndef _SYMTAB_INCLUDED /* allow multiple inclusions */
+#define _SYMTAB_INCLUDED
+
+/*
+ *
+ * SYMBOLIC DEBUG FORMAT ACD
+ * $Revision$
+ *
+ *
+ *
+ * ---- 1. INTRODUCTION
+ *
+ *
+ * This document describes the current format for data tables which
+ * appear in HP-UX / HPE object files (a.out files). These tables
+ * will be generated by the compilers, fixed up by the linker, and
+ * used by various programs (primarily the symbolic debugger(s)) to
+ * reconstruct information about the program. The form of this
+ * document is a C include file annotated with comments.
+ *
+ * On PA-RISC, a major goal was that the linker need not know
+ * anything about the format. To this end, it was decided that the
+ * debug information be composed of several unloadable subspaces
+ * within an unloadable space (named $DEBUG$), and that link time
+ * updates to the debug information be made through the standard
+ * mechanism of a list of fixups. The linker will perform the
+ * required fixups for the debug spaces, and subspaces from
+ * separate compilation units will be concatenated. However, at
+ * exec time, the loader would know that the debug space is not to
+ * be loaded.
+ *
+ * Similarly, on the series 300, several debug tables are present
+ * in the a.out format which are not loaded at exec time. Debug
+ * tables are simply concatenated into larger tables at link time
+ * and all fixups are then performed by pxdb.
+ */
+
+/*
+ * ---- 2. SUMMARY OF STRUCTURES
+ *
+ *
+ * The debug information consists of six tables: a header table
+ * and five special tables. The header table will contain one
+ * header record for each compilation unit. Each header record
+ * identifies the size (in bytes) of the five tables generated by
+ * that compilation unit. Two of the tables are very similar. The
+ * GNTT and LNTT both contain name and type information (NTT for
+ * Name and Type Table). The GNTT contains information about
+ * globals, and is thus limited to variables, types, and constants.
+ * The LNTT is for information about locals. The LNTT must
+ * therefore contain scoping information such as procedure nesting,
+ * begin-end blocks, etc. The GNTT and LNTT are both DNTTs (Debug
+ * Name and Type Tables), so the prefix DNTT is attached to objects
+ * (like a DNTTPOINTER) that are relevant to both the GNTT and
+ * LNTT. The SLT contains information relating source (or listing)
+ * lines to code addresses. The SLT and LNTT contain pointers
+ * between the two tables, so that the scoping information
+ * contained in the LNTT can also be used with the SLT. The VT
+ * contains ascii strings (such as variable names) and the values
+ * of named constants. The five tables are summarized below:
+ *
+ *
+ * Table Abbr Contains Points into
+ * ============= ==== ========================= ===============
+ * Global symbols GNTT global name-and-type info GNTT
+ * Local symbols LNTT local name-and-type info GNTT,LNTT,SLT,VT
+ * source line SLT source/listing line info LNTT,SLT
+ * value VT names and constants -
+ * xref XT File offsets and Attributes XT,VT
+ *
+ *
+ * The pointers needed within the debug tables are in fact indexes
+ * into the tables. The GNTT, LNTT, and SLT each consist of a series
+ * of equal-sized entries. Some DNTT entries begin a data structure
+ * and some are extension entries. Some SLT entries are "special"
+ * (point back to the LNTT), others are "assist" (point forward in
+ * the SLT), but most are "normal" (point to code).
+ *
+ * There can be pointers from the LNTT to the GNTT, as it is common
+ * to have local variables of a global type. However, there are
+ * never pointers from the GNTT to the LNTT, as global variables
+ * are never of a local type.
+ *
+ * The tables are defined to be as machine-independent as possible,
+ * but the debugger may need to "know" some facts about the system
+ * and language it is dealing with.
+ *
+ * The GNTT and LNTT are the only tables that require fixups to be
+ * generated by the compiler and acted upon by the linker. There
+ * are other fixups to be done, but these are all done by the pre-
+ * processor.
+ */
+
+/*
+ * ---- 3. LOW-LEVEL TYPE DECLARATIONS
+ */
+
+/*
+ * Code or data address:
+ *
+ * For the series 300:
+ *
+ * A virtual Address
+ *
+ * For PA-RISC:
+ *
+ * A PA-RISC short pointer.
+ *
+ */
+
+#if __cplusplus
+#define public global
+#endif
+
+typedef long ADDRESS;
+typedef unsigned long ADRT, *pADRT;
+
+/*
+ * Language types:
+ *
+ * Sizeof (LANGTYPE) = 4 bits, for a maximum of 16 possible
+ * language types.
+ */
+
+typedef unsigned int LANGTYPE;
+
+#define LANG_UNKNOWN 0
+#define LANG_C 1
+#define LANG_HPF77 2
+#define LANG_HPPASCAL 3
+#define LANG_HPMODCAL 4
+#define LANG_HPCOBOL 5
+#define LANG_HPBASIC 6
+#define LANG_HPADA 7
+#ifdef CPLUSPLUS
+#define LANG_CPLUSPLUS 8
+#endif
+
+
+/*
+ * Location types:
+ *
+ * 32-bit, machine-dependent and context-dependent specifiers of
+ * variable storage location.
+ */
+
+typedef unsigned long STATTYPE; /* static-type location */
+typedef long DYNTYPE; /* dynamic-type location */
+typedef unsigned long REGTYPE; /* register-type location */
+
+#define STATNIL (-1) /* no location for STATTYPE */
+
+/*
+ * Loc type Series 300 PA-RISC
+ * ======== ================ ===============
+ *
+ * STATTYPE Absolute address A PA-RISC
+ * into process short pointer.
+ * space (could be
+ * code or data).
+ *
+ *
+ * DYNTYPE A6-register- SP-register
+ * relative byte relative byte
+ * offset (+/-). offset (+/-)
+ *
+ * REGTYPE Register number Register number
+ * (see below). (see below).
+ *
+ * All location types are always byte (not word) pointers when they
+ * address memory, and they always point to the first byte
+ * containing the object, skipping any padding bytes. For example,
+ * if in Pascal a CHAR is allocated in the last byte of a whole
+ * word, the pointer is to that byte. (In C, four different CHAR
+ * variables might be packed into one word.)
+ */
+
+/*
+ * Meaning of STATTYPE for CONST entries:
+ *
+ * Sizeof (LOCDESCTYPE) = 3 bits, for a maximum of 8 possible
+ * desctypes.
+ */
+
+typedef unsigned int LOCDESCTYPE;
+
+#define LOC_IMMED 0 /* immediate constant */
+#define LOC_PTR 1 /* standard STATTYPE */
+#define LOC_VT 2 /* value table byte offset */
+
+/*
+ * Register numbers for REGTYPE (Series 300 only):
+ */
+
+#define REG_D0 0
+#define REG_D1 1
+#define REG_D2 2
+#define REG_D3 3
+#define REG_D4 4
+#define REG_D5 5
+#define REG_D6 6
+#define REG_D7 7
+
+#define REG_A0 8
+#define REG_A1 9
+#define REG_A2 10
+#define REG_A3 11
+#define REG_A4 12
+#define REG_A5 13
+#define REG_A6 14
+#define REG_A7 15
+
+#define REG_FP0 16
+#define REG_FP1 17
+#define REG_FP2 18
+#define REG_FP3 19
+#define REG_FP4 20
+#define REG_FP5 21
+#define REG_FP6 22
+#define REG_FP7 23
+
+#define REG_FPA0 24
+#define REG_FPA1 25
+#define REG_FPA2 26
+#define REG_FPA3 27
+#define REG_FPA4 28
+#define REG_FPA5 29
+#define REG_FPA6 30
+#define REG_FPA7 31
+#define REG_FPA8 32
+#define REG_FPA9 33
+#define REG_FPA10 34
+#define REG_FPA11 35
+#define REG_FPA12 36
+#define REG_FPA13 37
+#define REG_FPA14 38
+#define REG_FPA15 39
+
+/*
+ * generic floating point registers;
+ * actual register determined at runtime
+ */
+
+#define REG_FGEN0 40
+#define REG_FGEN1 41
+#define REG_FGEN2 42
+#define REG_FGEN3 43
+#define REG_FGEN4 44
+#define REG_FGEN5 45
+#define REG_FGEN6 46
+#define REG_FGEN7 47
+#define REG_FGEN8 48
+#define REG_FGEN9 49
+#define REG_FGEN10 50
+#define REG_FGEN11 51
+#define REG_FGEN12 52
+#define REG_FGEN13 53
+#define REG_FGEN14 54
+#define REG_FGEN15 55
+
+/*
+ * Basetypes:
+ *
+ * Sizeof (BASETYPE) = 5 bits, for a maximum of 32 possible
+ * basetypes.
+ */
+
+typedef unsigned int BASETYPE;
+
+#define T_UNDEFINED 0 /* unheard of */
+#define T_BOOLEAN 1 /* true/false or LOGICAL */
+#define T_CHAR 2 /* ASCII, signed if used as int */
+#define T_INT 3 /* signed integer */
+#define T_UNS_INT 4 /* unsigned integer */
+#define T_REAL 5 /* binary or decimal real */
+#define T_COMPLEX 6 /* pair of reals */
+#define T_STRING200 7 /* Series 300 string type */
+#define T_LONGSTRING200 8 /* Series 300 long string type */
+#define T_TEXT 9 /* for Pascal TEXT file */
+#define T_FLABEL 10 /* for any program labels */
+#define T_FTN_STRING_SPEC 11 /* PA-RISC FORTRAN string type */
+#define T_MOD_STRING_SPEC 12 /* PA-RISC Modcal/Pascal string */
+#define T_PACKED_DECIMAL 13 /* packed decimal */
+#define T_REAL_3000 14 /* HP3000 format real */
+#define T_MOD_STRING_3000 15 /* HP3000 Modcal/Pascal string */
+#define T_ANYPTR 16 /* Pascal any-pointer */
+#define T_GLOBAL_ANYPTR 17 /* Pascal global any-pointer */
+#define T_LOCAL_ANYPTR 18 /* Pascal local any-pointer */
+#define T_COMPLEXS3000 19 /* HP3000 format complex */
+#define T_FTN_STRING_S300_COMPAT 20 /* 9000/s300 compatible fortran string */
+#define T_FTN_STRING_VAX_COMPAT 21 /* VAX compatible fortran string */
+#define T_BOOLEAN_S300_COMPAT 22 /* 9000/s300 compatible fortran logical */
+#define T_BOOLEAN_VAX_COMPAT 23 /* VAX compatible fortran logical */
+#define T_WIDE_CHAR 24 /* ANSI/C wchar_t pseudo-type */
+#define T_LONG 25 /* signed long */
+#define T_UNS_LONG 26 /* unsigned long */
+#define T_DOUBLE 27 /* binary or decimal double */
+#ifdef TEMPLATES
+#define T_TEMPLATE_ARG 28 /* template argument immediate type */
+#endif /* TEMPLATES */
+
+/* THE HIGHEST BASE_TYPE ALLOWABLE is 31 (see DNTTP_IMMEDIATE) */
+/*
+ * The string types are reserved for cases where the language has
+ * an explicit string type separate from "array of char".
+ *
+ * The ANSI/C wchar_t typedef defines a special base-type to
+ * the debugger. The interpretation of wide-characters during
+ * input or display (i.e. their mapping to/from "external"
+ * characters) is defined by the ANSI/C functions mbtowc() and
+ * wctomb(), the "multi-byte" translation functions.
+ *
+ * T_FLABEL is used for CONSTs which are actually FORTRAN labels.
+ * The T_FLABEL is needed for the following: in FORTRAN there is
+ * the ASSIGN statement (ASSIGN <label> TO <integer variable>),
+ * which places the address of the statement prefixed with the
+ * label <label> into the integer variable. This integer variable
+ * can then be used as a label (e.g. GOTO <integer variable>).
+ * The user may wish to display the contents of the integer variable
+ * as a label. The DNTT LABEL entry is not sufficient, as the label
+ * need not be on an executable statement (e.g. a FORMAT statement),
+ * and the DNTT LABEL can only be used with executable statements.
+ *
+ * The bitlength in a DNTT entry further qualifies the basetype.
+ * Here is a summary of the legal values for bitlength. See the
+ * appropriate sections below for details.
+ *
+ * T_UNDEFINED any probably treat as int
+ * T_BOOLEAN 1 one-bit value
+ * 16,32 FORTRAN LOGICAL
+ * T_CHAR 1..8 size of char (really can be < 8 bits in C)
+ * T_INT 2..n probably n <= 64; incl. sign bit
+ * T_UNS_INT 1..n probably n <= 64
+ * T_REAL 32 short binary
+ * 64 long binary
+ * 128 extended real
+ * T_COMPLEX 64 two short binaries
+ * 128 two long binaries
+ * 192 two decimals
+ * T_STRING200 n * 8 maximum allocated memory, including
+ * length byte and/or terminator byte
+ * T_FTN_STRING_SPEC (to be determined)
+ * T_MOD_STRING_SPEC (to be determined)
+ * T_TEXT n size of the element buffer only
+ * T_FLABEL n * 8 size of the format label
+ * T_PACKED_DECIMAL (to be determined)
+ * T_WIDE_CHAR 32 determined by HP's NLS/Ansi-C committees
+ */
+
+typedef unsigned int BITS;
+
+/*
+ * DNTT pointer:
+ */
+
+struct DNTTP_IMMEDIATE {
+ BITS extension: 1; /* always set to 1 */
+ BITS immediate: 1; /* always set to 1 */
+ BITS global: 1; /* always set to 0 */
+ BASETYPE type: 5; /* immediate basetype */
+ BITS bitlength: 24; /* immediate bitlength */
+};
+
+/*
+ * Note that for type T_TEMPLATE_ARG bitlength is an positioning
+ * index into the chain of DNTT_TEMPLATE_ARG hanging out of
+ * the DNTT_TEMPLATE arglist field.
+ */
+
+struct DNTTP_NONIMMED {
+ BITS extension: 1; /* always set to 1 */
+ BITS immediate: 1; /* always set to 0 */
+ BITS global: 1; /* 1 => GNTT, 0 => LNTT */
+ BITS index: 29; /* DNTT table index */
+};
+
+typedef union {
+ struct DNTTP_IMMEDIATE dntti;
+ struct DNTTP_NONIMMED dnttp;
+ long word; /* for generic access */
+} DNTTPOINTER; /* one word */
+
+#define DNTTNIL (-1)
+
+/*
+ * A DNTTPOINTER of DNTTNIL means a nil pointer. In the DNTT
+ * immediate case there is always at least one zero bit (the global
+ * bit) to distinguish that case from nil pointer (-1). In the
+ * non-immediate, non-nil case DNTTPOINTER is the block index, base
+ * zero, of another DNTT entry; the global bit indicates which table
+ * it is an index into, the GNTT or LNTT. Each block is 12 bytes.
+ *
+ * Extension bits really have nothing to do with DNTT pointers, but
+ * are needed for constructing the DNTT. See the next section.
+ *
+ * Bitlength is the MINIMUM (packed) size of the object. In lieu
+ * of other information (i.e., outside of a structure or array),
+ * the object is assumed to be right-justified in the minimum
+ * number of whole bytes required to hold the bitlength. An
+ * immediate DNTTPOINTER is only allowed if the type is a simple
+ * BASETYPE. Otherwise, a separate DNTT entry must be used.
+ */
+
+
+/*
+ * SLT pointer:
+ *
+ * Signed entry index, base zero, into the source line table.
+ * Each entry is eight bytes.
+ */
+
+typedef long SLTPOINTER;
+
+#define SLTNIL (-1)
+
+
+/*
+ * VT pointer:
+ *
+ * Unsigned byte offset into the value table. Note that VTNIL
+ * is not actually a nil pointer, but rather a pointer to a nil
+ * string (see section 6).
+ */
+
+typedef long VTPOINTER;
+
+#define VTNIL 0
+
+
+/*
+ * XREF pointer:
+ *
+ * Signed entry index, base zero, into the cross reference table.
+ * Each entry is four bytes.
+ */
+
+typedef long XREFPOINTER;
+
+#define XREFNIL (-1)
+
+
+/*
+ * Values for "declaration" fields describing packing method
+ */
+
+#define DECLNORMAL 0
+#define DECLPACKED 1
+#define DECLCRUNCHED 2
+
+
+/*
+ * ---- 4. DEBUG HEADER
+ */
+
+/*
+ * The header table is composed of five word header records. For
+ * each compilation unit, the compiler must generate a header
+ * record, indicating the length (in bytes) of the five tables
+ * (GNTT, LNTT, SLT, VT and XT) produced for that compilation unit.
+ */
+
+ struct XDB_header {
+ long gntt_length;
+ long lntt_length;
+ long slt_length;
+ long vt_length;
+ long xt_length;
+ };
+
+#define extension_header 0x80000000
+
+/*
+ * The purpose of the header record is as follows: the five tables
+ * are each contained in a separate subspace on PA-RISC or in a
+ * separate section of the a.out file on the series 300. Therefore
+ * at link time, the tables from different compilation units will
+ * be con- catenated separately, GNTTs to GNTTS, SLTs to SLTs, etc.
+ * However, the preprocessor requires the number of compilation
+ * units, and the size of each of the five tables produced by each
+ * compilation unit. The header records supply this size
+ * information, and the number of header records equals the number
+ * of compilation units.
+ *
+ * For PA-RISC, the header_extension flag (MSB) is set in the
+ * gntt_length word in each header-record by the HP-UX 3.1+ s800 C
+ * compiler to indicate the header contains an xt_length and is 5
+ * words long. This bit is used to distinguish SOM's that were
+ * created with the pre-SA compiler (HP-UX 3.0, /bin/cc vers.
+ * A.00.15 or earlier) from SOM's that contain an $XT$ subspace.
+ *
+ * For PA-RISC, pxdb and xdb version A.02.xx can be used on
+ * >>all<< SOM's (4 or 5 word XDB headers) that have not already
+ * been pxdb'd. Earlier versions of either are completely
+ * incompatible with SOM's containing an $XT$ (HP-UXS 3.1 or later)
+ * because of the header-length.
+ *
+ * For the series 300, the header_extension flag is not used (i.e.
+ * the gntt_length occupies a full 32 bits).
+ */
+
+/*
+ * ---- 5. DEBUG SYMBOL TABLE (DNTT) ENTRY FORMAT
+ */
+
+/*
+ * The DNTT consists of a series of three-word blocks. Each block
+ * starts with an "extension bit". Each structure in the union
+ * "dnttentry" begins in an "initial block" with a bit which is
+ * always zero. If a structure is more than three words (one
+ * block) long, it occupies one or more additional "extension
+ * blocks", each of which starts with a bit set to one to
+ * distinguish it from an initial block.
+ *
+ * Note well that every DNTTPOINTER has a high bit of one and that
+ * every DNTT structure bigger than one block is carefully arranged
+ * so that a DNTTPOINTER resides in the fourth and seventh words.
+ * (The extension bit is in the DNTTPOINTER to avoid wasting space
+ * due to structure packing rules.)
+ */
+
+#define DNTTBLOCKSIZE 12
+
+/* The second field in each structure is "kind", which acts like a
+ * Pascal variant tag to denote the type of the structure. The
+ * "unused" fields are just included for clarity. The whole union
+ * "dnttentry" is declared after the definition of KINDTYPE and all
+ * the various structures (below).
+ */
+
+typedef int KINDTYPE;
+
+#define K_NIL (-1) /* guaranteed illegal value */
+
+#define K_SRCFILE 0
+
+#define K_MODULE 1
+#define K_FUNCTION 2
+#define K_ENTRY 3
+#define K_BEGIN 4
+#define K_END 5
+#define K_IMPORT 6
+#define K_LABEL 7
+#define K_WITH 27
+#define K_COMMON 28
+
+#define K_FPARAM 8
+#define K_SVAR 9
+#define K_DVAR 10
+#define K_CONST 12
+
+#define K_TYPEDEF 13
+#define K_TAGDEF 14
+#define K_POINTER 15
+#define K_ENUM 16
+#define K_MEMENUM 17
+#define K_SET 18
+#define K_SUBRANGE 19
+#define K_ARRAY 20
+#define K_STRUCT 21
+#define K_UNION 22
+#define K_FIELD 23
+#define K_VARIANT 24
+#define K_FILE 25
+#define K_FUNCTYPE 26
+#define K_COBSTRUCT 29
+
+#define K_XREF 30
+#define K_SA 31
+#define K_MACRO 32
+#define K_BLOCKDATA 33
+
+#define K_MODIFIER 45 /* used for C too so we can qualify type */
+
+#ifdef CPLUSPLUS
+#define K_CLASS_SCOPE 34
+#define K_REFERENCE 35
+#define K_PTRMEM 36
+#define K_PTRMEMFUNC 37
+#define K_CLASS 38
+#define K_GENFIELD 39
+#define K_VFUNC 40
+#define K_MEMACCESS 41
+#define K_INHERITANCE 42
+#define K_FRIEND_CLASS 43
+#define K_FRIEND_FUNC 44
+#define K_OBJECT_ID 46
+#define K_MEMFUNC 47
+#ifdef TEMPLATES
+#define K_TEMPLATE 48
+#define K_TEMPL_ARG 49
+#define K_FUNC_TEMPLATE 50
+#define K_LINK 51
+#endif /* TEMPLATES */
+#endif
+
+#ifdef CPLUSPLUS
+#ifdef TEMPLATES
+#define K_MAX K_LINK
+#else /* TEMPLATES */
+#define K_MAX K_MEMFUNC
+#endif /* TEMPLATES */
+#else
+#define K_MAX K_BLOCKDATA
+#endif
+
+/*
+ * ---- 5.1. FILE-CLASS ("FILE") DNTT ENTRIES
+ */
+
+
+struct DNTT_SRCFILE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_SRCFILE */
+ LANGTYPE language: 4; /* type of language */
+ BITS unused: 17;
+/*1*/ VTPOINTER name; /* name of source/listing file */
+/*2*/ SLTPOINTER address; /* code and text locations */
+}; /* three words */
+
+/*
+ * One SRCFILE is emitted for the start of each source file, the
+ * start of each included file, and the return from each included
+ * file. Additional SRCFILE entries must also be output before each
+ * DNTT_FUNC entry. This guarantees the debuggers know which file a
+ * function came from. Specifically, the rules are as follows:
+ *
+ * Definitions:
+ * Source block: contiguous block of one or more lines of text in a
+ * source-file, bounded by beginning or end-of-file or include
+ * directives (conceptually identical to the "basic block" in
+ * optimizer jargon). No distinction is made between blocks
+ * that contain compilable code and those that don't.
+ *
+ * Code segment: contiguous LINEAR block of DNTT (and associated
+ * SLT) entries that are generated from the same "source block".
+ * "SLT_SRC" is used here to actually refer to an SLT_SPEC entry
+ * of type SLT_SRCFILE. Same goes for SLT_FUNC.
+ *
+ * 1. One DNTT_SRCFILE and SLT_SRC must be emitted at the head of each
+ * code segment to facilitate reading backwards through the DNTT or
+ * SLT tables from any point in the segment to determine the
+ * enclosing source file. If the source-file changes within the
+ * body of a function/subprogram, a DNTT_SRCFILE/SLT_SRC pair must
+ * be emitted prior to any additional DNTT or SLT entries generated
+ * by the remainder of that function/subprogram.
+ *
+ * 2. One DNTT_SRCFILE/SLT_SRC pair is always emitted *immediately*
+ * before any DNTT_FUNC/SLT_FUNC. Exception: a DNTT_SA and
+ * associated DNTT_XREF may appear between a DNTT_FUNC and it's
+ * preceding DNTT_SRCFILE. There can be nothing between the
+ * SLT_SRC and the SLT_FUNC. The DNTT_SRCFILE (preceding the
+ * DNTT_FUNC) must name the file containing the functions
+ * declaration. The SLT_FUNC must contain the line number of the
+ * line in the function's declaration where the function's name
+ * appears. This line number must match the line number that
+ * appears in the XT record denoting the function's declaration.
+ * The SLT_END associated with the SLT_FUNC must contain the line
+ * number of the source line containing the scope-closing token
+ * (i.e. "}" or "end").
+ *
+ * 3. One DNTT_SRCFILE/SLT_SRC pair must be emitted for a source file
+ * that otherwise would not be mentioned in the DNTT i.e. source
+ * files that do not generate a code segment. This is required for
+ * Static analysis only.
+ *
+ *
+ * "address" points to a special SLT entry (for the line number
+ * only), but the code location is known from context in the SLT. *
+ *
+ * NOTE: Listing files and listing file line numbers may be used in
+ * place of source files and source file line numbers. A
+ * special compiler option will designate which is generated
+ * by the compiler.
+ *
+ * SRCFILE names are exactly as seen by the compiler, i.e. they
+ * may be relative, absolute, or whatever. C include file names
+ * must be given as absolute paths if found "in the usual place",
+ * i.e., /usr/include/...
+ */
+
+/*
+ * ---- 5.2. CODE-CLASS ("SCOPING") DNTT ENTRIES
+ */
+
+
+struct DNTT_MODULE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_MODULE */
+ BITS unused: 21;
+/*1*/ VTPOINTER name; /* name of module */
+/*2*/ VTPOINTER alias; /* alternate name, if any */
+/*3*/ DNTTPOINTER dummy; /* 4th word must be DNTTPOINTER */
+/*4*/ SLTPOINTER address; /* code and text locations */
+}; /* five words */
+
+/*
+ * One MODULE is emitted for the start of each Pascal/Modcal module
+ * or C source file (C sources are considered a nameless module).
+ * "address" points to a special SLT entry, but the code location
+ * is known from context in the SLT.
+ *
+ * In the case of languages that do not support modules (such as
+ * FORTRAN) a DNTT_MODULE and DNTT_END pair are not used. Every
+ * MODULE must have a matching END (see below). If a Pascal/Modcal
+ * module has a module body (some code), the latter must be represented
+ * by a FUNCTION-END pair as well (see below).
+ *
+ * For items within a module, the public bit is true if that item
+ * is exported by the module. If the public bit of an item is set,
+ * that item is visible within any module or procedure that imports
+ * the module containing the item. If the public bit of an item
+ * is not set, then the item is only visible within the module.
+ *
+ * The "dummy" field exists only because the first word of each
+ * extension block must be a DNTTPOINTER; it is important only
+ * that the extension bit of the DNTTPOINTER be set.
+ *
+ * The MODULE DNTT should be used only in the LNTT.
+ */
+
+#ifdef TEMPLATES
+
+struct DNTT_LINK
+{
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_LINK */
+ BITS linkKind: 4; /* always LINK_UNKNOWN */
+ BITS unused: 17;
+/*1*/ long future1; /* expansion */
+/*2*/ DNTTPOINTER ptr1; /* link from template */
+/*3*/ DNTTPOINTER ptr2; /* to expansion */
+/*4*/ long future[2];
+};
+
+#if 1
+struct DNTT_TFUNC_LINK
+{
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_LINK */
+ BITS linkKind: 4; /* always LINK_FUNC_TEMPLATE */
+ BITS unused: 17;
+/*1*/ long args; /* expansion */
+/*2*/ DNTTPOINTER pTemplate; /* link from template */
+/*3*/ DNTTPOINTER pExpansion; /* to expansion */
+/*4*/ long future[2];
+};
+#endif /* 0 */
+/* temporary until we get a new cfront */
+#if 0
+struct DNTT_TFUNC_LINK
+{
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_LINK */
+ BITS linkKind: 4; /* always LINK_FUNC_TEMPLATE */
+ BITS unused: 17;
+/*2*/ DNTTPOINTER pTemplate; /* link from template */
+/*3*/ DNTTPOINTER pExpansion; /* to expansion */
+/*1*/ long args; /* expansion */
+/*4*/ long future[2];
+};
+#endif /* 0 */
+/*
+ * Note the linkKind bit. The idea is that we might have other
+ * LINKs in the future that share the same format but where we would
+ * call the fields another name. It's hard to debug a program
+ * where fields are called link_word1 and link_word2.
+ */
+
+#define LINK_UNKNOWN 0
+#define LINK_FUNC_TEMPLATE 1
+
+struct DNTT_FUNC_TEMPLATE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* K_FUNC_TEMPLATE */
+ BITS public: 1; /* 1 => globally visible */
+ LANGTYPE language: 4; /* type of language */
+ BITS level: 5; /* nesting level (top level = 0)*/
+ BITS optimize: 2; /* level of optimization */
+ BITS varargs: 1; /* ellipses. Pascal/800 later */
+ BITS info: 4; /* lang-specific stuff; F_xxxx */
+#ifdef CPLUSPLUS
+ BITS inlined: 1;
+ BITS localloc: 1; /* 0 at top, 1 at end of block */
+ BITS unused: 2;
+#else
+ BITS unused: 4;
+#endif
+/*1*/ VTPOINTER name; /* name of function */
+/*2*/ VTPOINTER alias; /* alternate name, if any */
+/*3*/ DNTTPOINTER firstparam; /* first FPARAM, if any */
+/*4*/ DNTTPOINTER retval; /* return type, if any */
+/*5*/ DNTTPOINTER arglist; /* ptr to argument list */
+}; /* nine words */
+
+/*
+ * DNTT_FUNC_TEMPLATEs only appear in the GNTT. Functions and
+ * classes templates cannot be local. (Their instantions may be).
+ */
+#endif /* TEMPLATES */
+
+struct DNTT_FUNC {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* K_FUNCTION, K_ENTRY, */
+ /* K_BLOCKDATA, or K_MEMFUNC */
+ BITS public: 1; /* 1 => globally visible */
+ LANGTYPE language: 4; /* type of language */
+ BITS level: 5; /* nesting level (top level = 0)*/
+ BITS optimize: 2; /* level of optimization */
+ BITS varargs: 1; /* ellipses. Pascal/800 later */
+ BITS info: 4; /* lang-specific stuff; F_xxxx */
+#ifdef CPLUSPLUS
+ BITS inlined: 1;
+ BITS localloc: 1; /* 0 at top, 1 at end of block */
+#ifdef TEMPLATES
+ BITS expansion: 1; /* 1 = function expansion */
+ BITS unused: 1;
+#else /* TEMPLATES */
+ BITS unused: 2;
+#endif /* TEMPLATES */
+#else
+ BITS unused: 4;
+#endif
+/*1*/ VTPOINTER name; /* name of function */
+/*2*/ VTPOINTER alias; /* alternate name, if any */
+/*3*/ DNTTPOINTER firstparam; /* first FPARAM, if any */
+/*4*/ SLTPOINTER address; /* code and text locations */
+/*5*/ ADDRESS entryaddr; /* address of entry point */
+/*6*/ DNTTPOINTER retval; /* return type, if any */
+/*7*/ ADDRESS lowaddr; /* lowest address of function */
+/*8*/ ADDRESS hiaddr; /* highest address of function */
+}; /* nine words */
+
+/*
+ * Additional function semantics: Values for DNTT_FUNC.info
+*/
+
+ /* In command-line C proc-call... */
+#define F_ARGMODE_COMPAT_C 0 /* all real params passed as double */
+#define F_ARGMODE_ANSI_C 1 /* floats-is-floats but PASS as dbl */
+#define F_ARGMODE_ANSI_C_PROTO 2 /* all real params passed as declared */
+
+ /* special DNTT_FUNC semantics */
+#define F_ARGMODE_BLKDATA 3 /* Fortran "block data" construct */
+ /* NOT A FUNCTION! */
+ /* F_ARGMODE_BLKDATA is retained for backward compatability only */
+
+#ifdef CPLUSPLUS
+#define CPP_OVERLOADED 0x1 /* overloaded function */
+#define CPP_MEMBERFUNC 0x2 /* member function */
+#define CPP_INLINE 0x4 /* inline function */
+#define CPP_OPERATOR 0x8 /* operator function */
+#endif
+
+/*
+ * Struct DNTT_FUNC is used for dfunc and dentry, and dblockdata types.
+ * One FUNCTION or ENTRY is emitted for each formal function
+ * declaration (with a body) or secondary entry point,
+ * respectively. They are not emitted for bodyless declarations
+ * (FORWARD, EXTERNAL, "int x ();" etc.). A dblockdata is emitted for
+ * Fortran BLOCK DATA constructs only.
+ *
+ * "address" always points to a special SLT entry.
+ *
+ * For FUNCTION types, the "entryaddr" field is the code address of
+ * the primary entry point of the function. The "lowaddr" field is
+ * the lowest code address of the function. The "hiaddr" field
+ * is the highest code address of the function. This both gives
+ * the size of the function and helps in mapping code locations
+ * to functions when there are anonymous (non-debuggable) functions
+ * present. These three fields should be filled in by the generation
+ * of fixups.
+ *
+ * For ENTRY types, the "entryaddr" field points to the proper code
+ * location for calling the function at the secondary entrypoint,
+ * and the "lowaddr" and "hiaddr" fields are nil (zero). For a
+ * FORTRAN subroutine with alternate entries, DNTT_DVARs are required
+ * to represent the parameters, see the DNTT_FPARAM definition for
+ * the details.
+ *
+ * For BLOCKDATA types, the "public" bit should be set to 1, the
+ * "level", "optimize", "varargs" and "info" fields should all be 0.
+ * The "firstparam" field should be DNTTNIL. The "entryaddr" and
+ * "lowaddr" fields should be 0, and the "highaddr" field should be
+ * FFFFFFFC (-4). The "retval" field should be set to T_UNDEFINED,
+ * with length 0. An SLT_FUNCTION/SNT_END pair should be emitted
+ * for each DNTT_FUNC (BLOCKDATA).
+ *
+ * Every FUNCTION or BLOCKDATA must have a matching END (see below).
+ *
+ * For languages in which a functions return value is set by assigning
+ * the value to the function name (such as FORTRAN & Pascal), a DVAR
+ * entry should also be emitted for the function. The address of this
+ * DVAR for the function should be the address of the answer spot for
+ * the function. This will allow the user to display the current
+ * return value while the function is executing.
+ *
+ * The "varargs" field indicates whether the function was declared as
+ * having a variable-length parameter list. This is currently possible
+ * only via ANSI/C function-prototype "ellipses" (...). The "info" field
+ * provides additional language-specific characteristics of the function
+ * and/or its parameter-list.
+ *
+ * The localloc (local variables location) is currently only used
+ * in the following context: If the function
+ * language is LANG_CPLUSPLUS, then 0 means that locals are
+ * at the beginning of the block, and 1 means that locals appears
+ * at the end of a block. For all other languages
+ * this bit is not used.
+ *
+ * The FUNCTION DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_BEGIN {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_BEGIN */
+#ifdef CPLUSPLUS
+ BITS classflag: 1; /* beginning of class def'n */
+ BITS unused: 20;
+#else
+ BITS unused: 21;
+#endif
+/*1*/ SLTPOINTER address; /* code and text locations */
+}; /* two words */
+
+/*
+ * BEGINs are emitted as required to open a new (nested) scope for
+ * any type of variable or label, at any level within MODULE-END
+ * and FUNCTION-END pairs. Every BEGIN must have a matching END
+ * (see below). "address" points to a special SLT entry, but the
+ * code location is known from context in the SLT. Because a DNTT
+ * BEGIN-END is used to indicate a new scope, the Pascal BEGIN-
+ * END pair does not produce a DNTT BEGIN-END, while the C { }
+ * construct does.
+ *
+ * The BEGIN DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_COMMON {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_COMMON */
+ BITS unused: 21;
+/*1*/ VTPOINTER name; /* name of common block */
+/*2*/ VTPOINTER alias; /* alternate name, if any */
+}; /* three words */
+
+/*
+ * COMMONs are used to indicate that a group of variables are members
+ * of a given FORTRAN common block. For each common block, a DNTT_
+ * COMMON is emitted, followed by a DNTT_SVAR for each member of the
+ * common block, and finally a DNTT_END. If type information is
+ * required for a member of the common block (such as an array), it
+ * may also be within the DNTT_COMMON, DNTT_END pair.
+ *
+ * The COMMON DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_WITH {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_WITH */
+ BITS addrtype: 2; /* 0 => STATTYPE */
+ /* 1 => DYNTYPE */
+ /* 2 => REGTYPE */
+ BITS indirect: 1; /* 1 => pointer to object */
+ BITS longaddr: 1; /* 1 => in long pointer space */
+ BITS nestlevel: 6; /* # of nesting levels back */
+ BITS unused: 11;
+/*1*/ long location; /* where stored (allocated) */
+/*2*/ SLTPOINTER address;
+/*3*/ DNTTPOINTER type; /* type of with expression */
+/*4*/ VTPOINTER name; /* name of with expression */
+/*5*/ unsigned long offset; /* byte offset from location */
+}; /* six words */
+
+/*
+ * WITHs are emitted to open a with scope. Like a BEGIN, a
+ * WITH requires a matching END to close the scope. A single WITH
+ * statement possessing more than one record expression, should
+ * be handled as multiple nested withs with only one expression
+ * each. The "addrtype" field indicates the addressing mode used
+ * for the record expression, and along with the "indirect" field,
+ * tells how to interpret the "location" and "offset" fields. Thus,
+ * depending upon the value of "addrtype", "location" may contain
+ * a short pointer, an offset from the local frame pointer, or a
+ * register number. If "nestlevel" is non-zero and "addrtype" is
+ * DYNTYPE, the address for the record expression is computed by
+ * tracing back "nestlevel" static links and using "location" as
+ * an offset from the frame pointer at that level. (This situation
+ * occurs only on the FOCUS architecture.) The use of the
+ * "offset" field is the same as for the DNTT_SVAR entry (see below).
+ * The "type" field is the type of the record expression. The "name"
+ * field is the symbolic representation of the record expression
+ * (ex. "p[i]^"). "address" points to a special SLT, but the code
+ * location is known from context in the SLT.
+ *
+ * The WITH DNTT should be used only in the LNTT.
+ */
+
+struct DNTT_END {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_END */
+ KINDTYPE endkind: 10; /* DNTT kind closing scope for */
+#ifdef CPLUSPLUS
+ BITS classflag: 1; /* end of class def'n */
+ BITS unused: 10;
+#else
+ BITS unused: 11;
+#endif
+/*1*/ SLTPOINTER address; /* code and text locations */
+/*2*/ DNTTPOINTER beginscope; /* start of scope */
+}; /* three words */
+
+/*
+ * ENDs are emitted as required to close a scope started by a
+ * MODULE, FUNCTION, WITH, COMMON, or BEGIN (but not an ENTRY).
+ * Each points back to the DNTT entry that opened the scope.
+ * "endkind" indicates which kind of DNTT entry is associated with
+ * the END and is filled in by the preprocessor. "address" points
+ * to a special SLT entry, but the code location is known from context
+ * in the SLT.
+ *
+ * The END DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_IMPORT {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_IMPORT */
+ BITS explicit: 1; /* module directly imported */
+ BITS unused: 20;
+/*1*/ VTPOINTER module; /* module imported from */
+/*2*/ VTPOINTER item; /* name of item imported */
+}; /* three words */
+
+/*
+ * Within a module, there is one IMPORT entry for each imported
+ * module, function, or variable. The item field is nil when an
+ * entire module is imported. Used only by Pascal/Modcal. Note
+ * that exported functions and variables have their public bits set.
+ *
+ * The "explicit" flag indicates the module was directly imported.
+ * When not set, the module was imported by an imported module.
+ *
+ * The IMPORT DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_LABEL {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_LABEL */
+ BITS unused: 21;
+/*1*/ VTPOINTER name; /* name of label */
+/*2*/ SLTPOINTER address; /* code and text locations */
+}; /* three words */
+
+/*
+ * One LABEL is emitted for each source program statement label,
+ * referencing the matching physical line (SLT entry). An SLT
+ * pointer is used, instead of just a linenumber, so a code
+ * location is known for setting a breakpoint. This is the only
+ * case of SLTPOINTER that points to a normal (not special) SLT
+ * entry.
+ *
+ * If a label appears at the very end of a function (after all
+ * executable code), a normal SLT entry must be emitted for it
+ * anyway. In this case the SLT entry points to an exit (return)
+ * instruction.
+ *
+ * Numeric labels are named as the equivalent character string with
+ * no leading zeroes, except in those languages where the leading
+ * zeroes are significant (i.e. COBOL).
+ *
+ * The LABEL DNTT should be used only in the LNTT.
+ */
+
+
+/*
+ * ---- 5.3. STORAGE-CLASS ("NAME") DNTT ENTRIES
+ */
+
+struct DNTT_FPARAM {
+ /*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FPARAM */
+ BITS regparam: 1; /* 1 => REGTYPE, not DYNTYPE */
+ BITS indirect: 1; /* 1 => pass by reference */
+ BITS longaddr: 1; /* 1 => in long pointer space */
+ BITS copyparam: 1; /* 1 => Copied to a local */
+ /* only for fortran strings */
+#ifdef CPLUSPLUS
+ BITS dflt: 1; /* default parameter value? */
+ BITS unused: 16;
+#else
+ BITS unused: 17;
+#endif
+ /*1*/ VTPOINTER name; /* name of parameter */
+ /*2*/ DYNTYPE location; /* where stored */
+ /*3*/ DNTTPOINTER type; /* type information */
+ /*4*/ DNTTPOINTER nextparam; /* next FPARAM, if any */
+ /*5*/ int misc; /* assorted uses */
+ }; /* six words */
+
+ /*
+ * FPARAMs are chained together in parameter list order (left to
+ * right) from every FUNCTION, ENTRY, or FUNCTYPE (see below), one
+ * for each parameter, whether or not the type is explicitly
+ * declared. For unnamed parameters, the FPARAM name is "*".
+ *
+ * "regparam" implies that the storage location given is to be
+ * interpreted as a REGTYPE, not a DYNTYPE, that is, the parameter
+ * was passed in a register.
+ *
+ * "indirect" implies that the storage location given contains a
+ * data pointer to the parameter described, not the parameter
+ * itself, due to a call by reference (Pascal VAR, for instance).
+ * In the case where a call-by-value parameter is too big to be
+ * passed in the parameter list (e.g., a copied-value parameter in
+ * Pascal), the "location" must be given as the actual (post-copy)
+ * location of the parameter.
+ *
+ * "longaddr" is meaningful only for varparams, and indicates that
+ * the storage location given contains a 64 bit PA-RISC long
+ * pointer. The long pointer could be in 2 consecutive words, or
+ * in the case of a regparam, two consecutive registers.
+ *
+ * "copyparam" implies that the parameter has been copied to a local,
+ * and thus the location is relative to the sp of the current procedure,
+ * not the sp of the previous procdeure.
+ *
+ * "misc" is for assorted values. Current uses are:
+ * (1) if the parameter is of type T_FTN_STRING_S300
+ * then the "misc" field contains the SP relative
+ * offset of the word containing the length of
+ * the string
+ *
+ * In the case of a FORTRAN routine with alternate entries, DNTT
+ * DVARs also must be emited for each parameter. The reason is
+ * that with FORTRAN alternate entries, the same parameter can
+ * be in two different entry's parameter lists, in a different
+ * location (ex. the parameter "x" in "subroutine a(x,y,z)" and
+ * "entry b(v,w,x)") and yet they both represent the same parameter.
+ * Thus in order to insure a consistant address for such parameters,
+ * the compiler allocates a local temporary, and the prologue code
+ * for each entry copies the parameters into the local temps. So, to
+ * insure that the debugger can find the parameters, a DNTT DVAR
+ * must be generated for each temporary, with the name of the DVAR
+ * being the name of the FPARAM for which the temp. was allocated.
+ *
+ * The FPARAM DNTT should be used only in the LNTT.
+ */
+
+
+struct DNTT_SVAR {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_SVAR */
+ BITS public: 1; /* 1 => globally visible */
+ BITS indirect: 1; /* 1 => pointer to object */
+ BITS longaddr: 1; /* 1 => in long pointer space */
+#ifdef CPLUSPLUS
+ BITS staticmem: 1; /* 1 => member of a class */
+ BITS a_union: 1; /* 1 => anonymous union member */
+ BITS unused: 16;
+#else
+ BITS unused: 18;
+#endif
+/*1*/ VTPOINTER name; /* name of object (variable) */
+/*2*/ STATTYPE location; /* where stored (allocated) */
+/*3*/ DNTTPOINTER type; /* type information */
+/*4*/ unsigned long offset; /* post indirection byte offset */
+/*5*/ unsigned long displacement; /* pre indirection byte offset */
+}; /* six words */
+
+struct DNTT_DVAR {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_DVAR */
+ BITS public: 1; /* 1 => globally visible */
+ BITS indirect: 1; /* 1 => pointer to object */
+ BITS regvar: 1; /* 1 => REGTYPE, not DYNTYPE */
+#ifdef CPLUSPLUS
+ BITS a_union: 1; /* 1 => anonymous union member */
+ BITS unused: 17;
+#else
+ BITS unused: 18;
+#endif
+/*1*/ VTPOINTER name; /* name of object (variable) */
+/*2*/ DYNTYPE location; /* where stored (allocated) */
+/*3*/ DNTTPOINTER type; /* type information */
+/*4*/ unsigned long offset; /* post indirection byte offset */
+ /* for use in cobol structures */
+}; /* five words */
+
+/*
+ * SVARs describe static variables (with respect to storage, not
+ * visibility) and DVARs describe dynamic variables, and also
+ * describe register variables. Note that SVARs have an extra
+ * word, "offset", not needed for the other types. This provides
+ * for direct data which is indexed from a base, and indirect data
+ * which is accessed through a pointer, then indexed.
+
+ * The "location" field of an SVAR will require a fixup. An
+ * example of when the offset field can be useful, is a FORTRAN
+ * common block. In a common block declaration such as "common
+ * /marx/ groucho, harpo, chico", the symbol "marx" is the only
+ * global symbol. If "marx" is accessed indirectly, then the
+ * address of "harpo" would contain the address of "marx" in the
+ * location field (with the indirect bit on), and the offset of
+ * "harpo" from "marx" in the offset field. If "marx" is not
+ * indirect, then location field can be filled in by a fixup of the
+ * form address(marx) + offset of harpo, and the offset field is
+ * not needed.
+ *
+ * The compilers must emit SVARs even for data objects the linker
+ * does not know about by name, such as variables in common blocks.
+ *
+ * As in the FPARAM entry, the longaddr field indicates the use
+ * of a PA-RISC long pointer, and is valid only if the indirect
+ * flag is true. The "regvar" field also has the same meaning as in
+ * the FPARAM case.
+ *
+ * For languages in which a functions return value is set by assigning
+ * the value to the function name (such as FORTRAN & Pascal), a DVAR
+ * entry should also be emitted for the function. The address of this
+ * DVAR for the function should be the address of the answer spot for
+ * the function. This will allow the user to display the current
+ * return value while the function is executing.
+ *
+ * For a FORTRAN subroutine with alternate entries, DNTT_DVARs are
+ * required to represent the parameters, see the DNTT_FPARAM
+ * definition for the details.
+ *
+ * The SVAR can be used in both the GNTT and LNTT, while the DVAR
+ * is only applicable to the LNTT.
+ */
+
+
+struct DNTT_CONST {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_CONST */
+ BITS public: 1; /* 1 => globally visible */
+ BITS indirect: 1; /* 1 => pointer to object */
+ LOCDESCTYPE locdesc: 3; /* meaning of location field */
+#ifdef CPLUSPLUS
+ BITS classmem: 1; /* 1 => member of a class */
+ BITS unused: 15;
+#else
+ BITS unused: 16;
+#endif
+/*1*/ VTPOINTER name; /* name of object */
+/*2*/ STATTYPE location; /* where stored */
+/*3*/ DNTTPOINTER type; /* type information */
+/*4*/ unsigned long offset; /* post indirection byte offset */
+/*5*/ unsigned long displacement; /* pre indirection byte offset */
+}; /* six words */
+
+/*
+ * The value of locdesc determines the meaning of location.
+ * Compilers are free to use any of the three types (LOC_IMMED,
+ * LOC_PTR, LOC_VT) as feasible and appropriate. They might, for
+ * example, merely dump all CONST values into the VT, with some
+ * redundancy, if they could do no better. Ideally, each compiler
+ * would use all three types according to whether the constant is
+ * stored in an immediate instruction (so a copy is needed here),
+ * in code or data space, or nowhere else, respectively.
+ *
+ * If locdesc == LOC_PTR, CONST is very much like an SVAR, and the
+ * indirect and offset values are relevant.
+ *
+ * The CONST DNTT can be used in both the GNTT and LNTT.
+ */
+
+
+/*
+ * ---- 5.4. TYPE-CLASS ("TYPE") DNTT ENTRIES
+ */
+
+
+struct DNTT_TYPE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* either K_TYPEDEF or K_TAGDEF */
+ BITS public: 1; /* 1 => globally visible */
+ BITS typeinfo: 1; /* 1 => type info available */
+ BITS unused: 19;
+/*1*/ VTPOINTER name; /* name of type or tag */
+/*2*/ DNTTPOINTER type; /* type information */
+}; /* three words */
+
+/*
+ * The DNTT_TYPE type is used for dtype and dtag entries. TYPEDEFs
+ * are just a way of remembering names associated with types
+ * declared in Pascal, via "type" sections, or in C, via "typedef"s.
+ * TAGDEFs are used for C "struct", "union", and "enum" tags, which
+ * may be named identically to "typedef"s in the same scope.
+ * TAGDEFs always point at STRUCTs, UNIONs, or ENUMs (see below),
+ * and provide a way to "hang" a name onto a subtree.
+ *
+ * Note that named types point directly to the underlying
+ * structures, not to intervening TYPEDEFs or TAGDEFs. Type
+ * information in TYPEDEFs and TAGDEFs point to the same structures
+ * independent of named instantiations of the types.
+ *
+ * For example:
+ * +
+ * typedef struct S { + typedef enum E { ... } EEE;
+ * ... +
+ * } *pS; +
+ *
+ * would generate something like this (shown graphically)
+ *
+ * TYPEDEF "pS" + TYPEDEF "EEE"
+ * | + |
+ * POINTER + TAG "E"
+ * | + |
+ * TAG "S" + ENUM
+ * | + |
+ * STRUCT + :
+ * | + :
+ * : +
+ * : +
+ *
+ * Note also that variables (of a named non-base type) must point to
+ * TYPEDEF or TAGDEF dntt, and not the underlying structures. If
+ * this is not done, the removal of duplicate global information is
+ * impossible.
+ *
+ * The "typeinfo" flag only applies to TAGDEFs. When not set, it is
+ * used to indicate that an underlying struct, union, or enum is
+ * named, but the actual type is not declared. In general,
+ * "typeinfo" will be set to 1. It will be set to a 0 if the type
+ * subtree is not available. Consider the C file:
+ *
+ * typedef struct s *Sptr;
+ * main(){}
+ *
+ * which is a valid compilation unit with "struct s" defined in
+ * another file. For this case, the "typeinfo" for TAGDEF "s" will
+ * be set to 0, and "type" points to a "nil" DNTT_STRUCT (i.e. a
+ * DNTT_STRUCT entry with its "firstfield", "vartagfield", and
+ * "varlist" fields set to DNTTNIL and its "declaration" and
+ * "bitlength" fields set to 0). Graphically:
+ *
+ * TYPEDEF "Sptr"
+ * |
+ * POINTER
+ * |
+ * TAG "s"
+ * |
+ * STRUCT
+ * \---<firstfield>---> DNTTNIL
+ * \--<vartagfield>--> DNTTNIL
+ * \-<varlist>------> DNTTNIL
+ * \- other fields > all set to 0
+ *
+ *
+ * Thus, whenever "typeinfo" is 0, "type" must point to an
+ * appropriate DNTT entry which has all its fields correctly NIL'ed.
+ * This applies to *named* DNTT_STRUCT's, DNTT_UNION's, and
+ * DNTT_ENUM's.
+ *
+ * The TYPEDEF and TAGDEF DNTTs may be used in both the GNTT and
+ * LNTT.
+ *
+ */
+
+
+struct DNTT_POINTER {
+/*0*/ BITS extension: 1; /* always zero */
+#ifdef CPLUSPLUS
+ KINDTYPE kind: 10; /* K_POINTER or K_REFERENCE */
+#else
+ KINDTYPE kind: 10; /* always K_POINTER */
+#endif
+ BITS unused: 21;
+/*1*/ DNTTPOINTER pointsto; /* type of object */
+/*2*/ unsigned long bitlength; /* size of pointer, not object */
+}; /* three words */
+
+
+struct DNTT_ENUM {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_ENUM */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER firstmem; /* first MEMENUM (member) */
+/*2*/ unsigned long bitlength; /* packed size */
+}; /* three words */
+
+struct DNTT_MEMENUM {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_MEMENUM */
+#ifdef CPLUSPLUS
+ BITS classmem: 1; /* 1 => member of a class */
+ BITS unused: 20;
+#else
+ BITS unused: 21;
+#endif
+/*1*/ VTPOINTER name; /* name of member */
+/*2*/ unsigned long value; /* equivalent number */
+/*3*/ DNTTPOINTER nextmem; /* next MEMENUM, else ENUM type */
+}; /* four words */
+
+/*
+ * Each ENUM begins a chain of (name, value) pairs. The nextmem
+ * field of the last memenum, should be DNTT NIL. The POINTER,
+ * ENUM, and MEMENUM DNTTs can all be used in both the GNTT and
+ * LNTT.
+ */
+
+
+struct DNTT_SET {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_SET */
+ BITS declaration: 2; /* normal, packed, or crunched */
+ BITS unused: 19;
+/*1*/ DNTTPOINTER subtype; /* type implies bounds of set */
+/*2*/ unsigned long bitlength; /* packed size */
+}; /* three words */
+
+
+struct DNTT_SUBRANGE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_SUBRANGE */
+ BITS dyn_low: 2; /* >0 => nonconstant low bound */
+ BITS dyn_high: 2; /* >0 => nonconstant high bound */
+ BITS unused: 17;
+/*1*/ long lowbound; /* meaning depends on subtype */
+/*2*/ long highbound; /* meaning depends on subtype */
+/*3*/ DNTTPOINTER subtype; /* immediate type or ENUM */
+/*4*/ unsigned long bitlength; /* packed size */
+}; /* five words */
+
+
+struct DNTT_ARRAY {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_ARRAY */
+ BITS declaration: 2; /* normal, packed, or crunched */
+ BITS dyn_low: 2; /* >0 => nonconstant low bound */
+ BITS dyn_high: 2; /* >0 => nonconstant high bound */
+ BITS arrayisbytes: 1; /* 1 => array size is in bytes */
+ BITS elemisbytes: 1; /* 1 => elem. size is in bytes */
+ BITS elemorder: 1; /* 0 => in increasing order */
+ BITS justified: 1; /* 0 => left justified */
+ BITS unused: 11;
+/*1*/ unsigned long arraylength; /* size of whole array */
+/*2*/ DNTTPOINTER indextype; /* how to index the array */
+/*3*/ DNTTPOINTER elemtype; /* type of each array element */
+/*4*/ unsigned long elemlength; /* size of one element */
+}; /* five words */
+
+/*
+ * The dyn_low and dyn_high fields are non-zero only if the
+ * DNTT_SUBRANGE is defining the range of an array index, otherwise
+ * they are always zero. The dyn_low and dyn_high bits are
+ * duplicated in the DNTT_SUBRANGE defining the range of the array
+ * index (so sllic can fix the pointers). "dyn_low" indicates
+ * whether the lower bound for the subscript of the array is
+ * dynamic. If the dyn_low field is zero, then the lowbound field
+ * of the DNTT_SUBRANGE entry, pointed to by the indextype field in
+ * the DNTT_ARRAY entry, is interpreted as a constant lower bound.
+ * If the dyn_low field is 1, then the lowbound field of the DNTT
+ * SUBRANGE is interpreted as a DYNTYPE giving a local address where
+ * the lower bound can be found. If the dyn_low field is 2, then
+ * the lowbound field of the DNTT_SUBRANGE is interpreted as a
+ * DNTTPOINTER to a variable whose value is the lower bound (needed
+ * if the lower bound is a static variable). The dyn_low value of 3
+ * is not used. The "dyn_high" bit has a similar meaning relating
+ * to the upper bound. If an upper bound for an array parameter is
+ * not given (like assumed size arrays in FORTRAN, or "char foo[]"
+ * in C) then the upper bound in the DNTT_SUBRANGE should be the
+ * largest integer that fits in a long integer, so that any value
+ * the user can give is legal.
+ *
+ * "arrayisbytes" indicates that the field "arraylength" contains
+ * the length in bytes rather then bits. This is needed on PA-RISC
+ * where an array could be up to 2**32 bytes. A value of zero for
+ * bitsize will be used to represent 2**32.
+ *
+ * "elemisbytes" indicates that the field "elemlength" contains the
+ * elem. length in bytes rather then bits. The "elemlength" field
+ * contains the not the "true" size of an array element, but the
+ * size allocated to each element within the array (the "true" size
+ * plus any wasted bits on the left or right). As an example for a
+ * Pascal array of a 13 bit structure, the array element size might
+ * equal 16, with the justified field equal to 0 to indicate the
+ * structure is left justified within the 16 bits. The "true" size
+ * of the structure would be found in the size field of the
+ * DNTT_STRUCT pointed to by the "elemtype" field of the DNTT_ARRAY.
+ *
+ * "indextype" typically points to a SUBRANGE for bounds.
+ * "elemtype" may point to another ARRAY for multi-dimensional
+ * arrays. Row or column precedence in the language is reflected in
+ * the order of the ARRAY entries on the chain. For example, in
+ * Pascal, which is row-precedent, an array declared [1..2, 3..4,
+ * 5..6] would result in "array 1..2 of array 3..4 of array 5..6 of
+ * ...". The same declaration in FORTRAN, which is
+ * column-precedent, would result in "array 5..6 of array 3..4 of
+ * array 1..2 of ...". This makes index-to-address conversion much
+ * easier. Either way an expression handler must know the
+ * precedence for the language.
+ *
+ * The SET, SUBRANGE, and ARRAY DNTTs can be used in both the GNTT
+ * and LNTT.
+ */
+
+
+struct DNTT_STRUCT {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_STRUCT */
+ BITS declaration: 2; /* normal, packed, or crunched */
+ BITS unused: 19;
+/*1*/ DNTTPOINTER firstfield; /* first FIELD, if any */
+/*2*/ DNTTPOINTER vartagfield; /* variant tag FIELD, or type */
+/*3*/ DNTTPOINTER varlist; /* first VARIANT, if any */
+/*4*/ unsigned long bitlength; /* total at this level */
+}; /* five words */
+
+/*
+ * The "declaration", "vartagfield", and "varlist" fields apply to
+ * Pascal/Modcal records only and are nil for record structures in
+ * other languages. If there is a tag, then the "vartagfield" points
+ * to the FIELD DNTT describing the tag. Otherwise, the "vartagfield"
+ * points to the tag type.
+ *
+ * The STRUCT DNTT may be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_UNION {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_UNION */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER firstfield; /* first FIELD entry */
+/*2*/ unsigned long bitlength; /* total at this level */
+}; /* three words */
+
+/*
+ * This type supports C unions only and is not used otherwise.
+ *
+ * Since STRUCTUREs and UNIONs are not packable inside of outer
+ * STRUCTUREs and UNIONs, their bitlengths tell their actual (not
+ * necessarily packed) size, according only as to how they are
+ * internally packed.
+ *
+ * The STRUCT DNTT may be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_FIELD {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FIELD */
+#ifdef CPLUSPLUS
+ BITS visibility:2; /* pub = 0, prot = 1, priv = 2 */
+ BITS a_union: 1; /* 1 => anonymous union member */
+#ifdef TEMPLATES
+ BITS staticMem: 1; /* 1 -> static member of a template */
+ BITS unused: 17;
+#else /* TEMPLATES */
+ BITS unused: 18;
+#endif /* TEMPLATES */
+#else
+ BITS unused: 21;
+#endif
+/*1*/ VTPOINTER name; /* name of field, if any */
+/*2*/ unsigned long bitoffset; /* of object itself in STRUCT */
+/*3*/ DNTTPOINTER type; /* type information */
+/*4*/ unsigned long bitlength; /* size at this level */
+/*5*/ DNTTPOINTER nextfield; /* next FIELD in STRUCT, if any */
+}; /* six words */
+
+/*
+ * This type describes the fields in Pascal records and C
+ * structures and unions. The bitoffset is from the start of the
+ * STRUCT or UNION that started the chain, to the start of the
+ * object itself, ignoring any padding. Note that bitoffset
+ * does not have to be on a byte boundary. For unions, each
+ * bitoffset should be zero since all fields overlap.
+ *
+ * The bitlength field is the same as that of the type except for C
+ * bit fields, which may be a different size than the base type.
+ *
+ * The FIELD DNTT can be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_VARIANT {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_VARIANT */
+ BITS unused: 21;
+/*1*/ long lowvarvalue; /* meaning depends on vartype */
+/*2*/ long hivarvalue; /* meaning depends on vartype */
+/*3*/ DNTTPOINTER varstruct; /* this variant STRUCT, if any */
+/*4*/ unsigned long bitoffset; /* of variant, in outer STRUCT */
+/*5*/ DNTTPOINTER nextvar; /* next VARIANT, if any */
+}; /* six words */
+
+/*
+ * "varstruct" points to the STRUCT which in turn describes the
+ * contents of the variant. The latter might in turn point to
+ * VARIANTs of its own, and to FIELDs which point to other STRUCTs.
+ * "lowvarvalue" and "hivarvalue" are the range of values for which
+ * this variant applys; more than one dntt VARIANT may be necessary
+ * to describe the range (e.g., 'a'..'n','q':). A type field is un-
+ * necessary, as the type can be obtained from the "vartagfield"
+ * field of the STRUCT DNTT.
+ *
+ * The VARIANT DNTT can be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_FILE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FILE */
+ BITS ispacked: 1; /* 1 => file is packed */
+ BITS unused: 20;
+/*1*/ unsigned long bitlength; /* of whole element buffer */
+/*2*/ unsigned long bitoffset; /* of current element in buffer */
+/*3*/ DNTTPOINTER elemtype; /* type and size of of element */
+}; /* four words */
+
+/*
+ * Pascal/Modcal is the only language of interest with built-in file
+ * buffering. For Pascal/Modcal files, the symbol table tells the file
+ * element type, the sizes of the current element (via "elemtype")
+ * and the whole buffer (via "bitlength"), and the locations of the
+ * element buffer (from the parent "NAME" entry) and the element
+ * itself within the buffer, following header information (from
+ * "bitoffset").
+ *
+ * The FILE DNTT can be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_FUNCTYPE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FUNCTYPE */
+ BITS varargs: 1; /* func-proto ellipses. */
+ BITS info: 4; /* lang-specific stuff; F_xxxx */
+ BITS unused: 16;
+/*1*/ unsigned long bitlength; /* size of function pointer */
+/*2*/ DNTTPOINTER firstparam; /* first FPARAM, if any */
+/*3*/ DNTTPOINTER retval; /* return type, if any */
+}; /* four words */
+
+/*
+ * This type supports function variables in a limited way,
+ * including the parameter types (if any) and the return value type
+ * (if any).
+ *
+ * See DNTT_FUNC for discussion of various fields.
+ *
+ * The FUNCTYPE DNTT can be used in both the GNTT and LNTT.
+ */
+
+
+struct DNTT_COBSTRUCT {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_COBSTRUCT */
+ BITS hasoccurs: 1; /* descendant has OCCURS clause */
+ BITS istable: 1; /* is a table item? */
+ BITS unused: 19;
+/*1*/ DNTTPOINTER parent; /* next higher data item */
+/*2*/ DNTTPOINTER child; /* 1st descendant data item */
+/*3*/ DNTTPOINTER sibling; /* next data item at this level */
+/*4*/ DNTTPOINTER synonym; /* next data item w/ same name */
+/*5*/ BITS catusage: 6; /* category or usage of item */
+ BITS pointloc: 8; /* location of decimal point */
+ BITS numdigits:10; /* number of digits */
+ BITS unused2: 8;
+/*6*/ DNTTPOINTER table; /* array entry describing table */
+/*7*/ VTPOINTER editpgm; /* name of edit subprogram */
+/*8*/ unsigned long bitlength; /* size of item in bits */
+}; /* nine words */
+
+/*
+ * This entry is used to describe COBOL data items and table items.
+ * A Cobol variable will begin with a DNTT_SVAR, DNTT_DVAR, or DNTT_
+ * FPARAM whose "type" field is a DNTTPOINTER to a DNTT_COBSTRUCT.
+ *
+ * "parent", "child", "sibling", and "synonym" are DNTTPOINTER to
+ * other DNTT_SVAR, DNTT_DVAR, or DNTT_FPARAMs having these particular
+ * relationships with the current DNTT_COBSTRUCT (or are set to DNTTNIL
+ * if no such relationship exists).
+ *
+ * "hasoccurs" is set to 1 if the descendent of this COBOL element
+ * (pointed to by "child") has an OCCURS ... DEPENDING ON clause.
+ *
+ * "istable" is set to 1 if this COBOL data item is a table. In this
+ * case, "table" will point to a DNTT_ARRAY entry describing the table.
+ *
+ * The COBSTRUCT DNTT can be used in both the GNTT and LNTT.
+ */
+
+/*
+ * Used for C too so pulled out of ifdef CPLUSPLUS.
+ */
+
+struct DNTT_MODIFIER {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_MODIFIER */
+ BITS m_const: 1; /* const */
+ BITS m_static: 1; /* static */
+ BITS m_void: 1; /* void */
+ BITS m_volatile: 1; /* volatile */
+ BITS m_duplicate: 1; /* duplicate */
+ BITS unused: 16;
+/*1*/ DNTTPOINTER type; /* subtype */
+}; /* two words */
+
+#ifdef CPLUSPLUS
+struct DNTT_GENFIELD {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_GENFIELD */
+ BITS visibility: 2; /* pub = 0, prot = 1, priv = 2 */
+ BITS a_union: 1; /* 1 => anonymous union member */
+ BITS unused: 18;
+/*1*/ DNTTPOINTER field; /* pointer to field or qualifier */
+/*2*/ DNTTPOINTER nextfield; /* pointer to next field */
+}; /* three words */
+
+struct DNTT_MEMACCESS {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_MEMACCESS */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER classptr; /* pointer to base class */
+/*2*/ DNTTPOINTER field; /* pointer field */
+}; /* three words */
+
+struct DNTT_VFUNC {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_VFUNCTION */
+ BITS pure: 1; /* pure virtual function ? */
+ BITS unused: 20;
+/*1*/ DNTTPOINTER funcptr; /* function name */
+/*2*/ unsigned long vtbl_offset; /* offset into vtbl for virtual */
+}; /* three words */
+
+struct DNTT_CLASS_SCOPE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_CLASS_SCOPE */
+ BITS unused: 21;
+/*1*/ SLTPOINTER address; /* pointer to SLT entry */
+/*2*/ DNTTPOINTER type; /* pointer to class type DNTT */
+}; /* three words */
+
+struct DNTT_FRIEND_CLASS {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FRIEND_CLASS */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER classptr; /* pointer to class DNTT */
+/*2*/ DNTTPOINTER next; /* next DNTT_FRIEND */
+}; /* three words */
+
+struct DNTT_FRIEND_FUNC {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_FRIEND_FUNC */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER funcptr; /* pointer to function */
+/*2*/ DNTTPOINTER classptr; /* pointer to class DNTT */
+/*3*/ DNTTPOINTER next; /* next DNTT_FRIEND */
+}; /* four words */
+
+struct DNTT_CLASS {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_CLASS */
+ BITS abstract: 1; /* is this an abstract class? */
+ BITS class_decl: 2; /* 0=class,1=union,2=struct */
+#ifdef TEMPLATES
+ BITS expansion: 1; /* 1=template expansion */
+ BITS unused: 17;
+#else /* TEMPLATES */
+ BITS unused: 18;
+#endif /* TEMPLATES */
+/*1*/ DNTTPOINTER memberlist; /* ptr to chain of K_[GEN]FIELDs */
+/*2*/ unsigned long vtbl_loc; /* offset in obj of ptr to vtbl */
+/*3*/ DNTTPOINTER parentlist; /* ptr to K_INHERITANCE list */
+/*4*/ unsigned long bitlength; /* total at this level */
+/*5*/ DNTTPOINTER identlist; /* ptr to chain of class ident's */
+/*6*/ DNTTPOINTER friendlist; /* ptr to K_FRIEND list */
+#ifdef TEMPLATES
+/*7*/ DNTTPOINTER templateptr; /* ptr to template */
+/*8*/ DNTTPOINTER nextexp; /* ptr to next expansion */
+#else /* TEMPLATES */
+/*7*/ unsigned long future2;
+/*8*/ unsigned long future3;
+#endif /* TEMPLATES */
+};
+ /* nine words */
+#ifdef TEMPLATES
+struct DNTT_TEMPLATE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_TEMPLATE */
+ BITS abstract: 1; /* is this an abstract class? */
+ BITS class_decl: 2; /* 0=class,1=union,2=struct */
+ BITS unused: 18;
+/*1*/ DNTTPOINTER memberlist; /* ptr to chain of K_[GEN]FIELDs */
+/*2*/ long unused2; /* offset in obj of ptr to vtbl */
+/*3*/ DNTTPOINTER parentlist; /* ptr to K_INHERITANCE list */
+/*4*/ unsigned long bitlength; /* total at this level */
+/*5*/ DNTTPOINTER identlist; /* ptr to chain of class ident's */
+/*6*/ DNTTPOINTER friendlist; /* ptr to K_FRIEND list */
+/*7*/ DNTTPOINTER arglist; /* ptr to argument list */
+/*8*/ DNTTPOINTER expansions; /* ptr to expansion list */
+};
+
+/*
+ * DNTT_TEMPLATEs only appear in the GNTT. Functions and
+ * classes templates cannot be local. (Their instantions may be).
+ */
+
+struct DNTT_TEMPL_ARG {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_TEMPL_ARG */
+ BITS usagetype:1; /* 0 type-name 1 expression */
+ BITS unused: 20;
+/*1*/ VTPOINTER name; /* name of argument */
+/*2*/ DNTTPOINTER type; /* for non type arguments */
+/*3*/ DNTTPOINTER nextarg; /* Next argument if any */
+/*4*/ long unused2[2];
+}; /* 6 words */
+
+/*
+ * Pxdb fills in the prevexp, and nextexp in the
+ * DNTT_CLASS. Pxdb also fills in the expansions field in the
+ * DNTT_TEMPLATE.
+ */
+#endif /* TEMPLATES */
+
+struct DNTT_PTRMEM {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* K_PTRMEM or K_PTRMEMFUNC */
+ BITS unused: 21;
+/*1*/ DNTTPOINTER pointsto; /* pointer to class DNTT */
+/*2*/ DNTTPOINTER memtype; /* type of member */
+}; /* three words */
+
+struct DNTT_INHERITANCE {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* K_INHERITANCE */
+ BITS Virtual: 1; /* virtual base class ? */
+ BITS visibility: 2; /* pub = 0, prot = 1, priv = 2 */
+ BITS unused: 18;
+/*1*/ DNTTPOINTER classname; /* first parent class, if any */
+/*2*/ unsigned long offset; /* offset to start of base class */
+/*3*/ DNTTPOINTER next; /* pointer to next K_INHERITANCE */
+}; /* four words */
+
+struct DNTT_OBJECT_ID {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* K_OBJECT_ID */
+ BITS unused: 21;
+/*1*/ unsigned long object_ident; /* object identifier */
+/*2*/ unsigned long offset; /* offset to start of base class */
+/*3*/ DNTTPOINTER next; /* pointer to next K_OBJECT_ID */
+/*4*/ unsigned long segoffset; /* for linker fixup */
+}; /* five words */
+#endif
+
+/*
+ * DNTT_XREF ENTRY:
+ * This entry is used to retrieve cross-reference information from
+ * the XREF Table (XT). A DNTT_XREF entry immediately follows the
+ * DNTT_SVAR, DNTT_DVAR, DNTT_TYPE, etc. entry to which it pertains.
+ *
+ * The XREFPOINTER points into the XT table where the information
+ * about the previous DNTT entry is contained. If no entries are
+ * generated in the XT table, the xreflist field should contain
+ * XREFNIL. The language field contains the source language
+ * (LANG_xxx) value of the DNTT object.
+ *
+ * The XREF DNTT can be used in both the GNTT and LNTT.
+ */
+
+struct DNTT_XREF {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_XREF */
+ BITS language: 4; /* language of DNTT object */
+ BITS unused: 17;
+/*1*/ XREFPOINTER xreflist; /* index into XREF subspace */
+/*2*/ long extra; /* free */
+}; /* three words */
+
+
+/*
+ * DNTT_SA ENTRY:
+ * This entry is used with static analysis info. It supplies the
+ * name and kind for a few special cases not currently handled by a
+ * DNTT_SVAR, DNTT_DVAR, DNTT_TYPE, etc. It is used for a local
+ * entity that has a global scope.
+ *
+ * Example: a function, has a DNTT_FUNCTION entry in the LNTT;
+ * but it can be seen globally, thus a K_SA will be emitted in
+ * the GNTT, with the functions name and a base_kind of K_FUNCTION;
+ * the DNTT_XREF will follow the DNTT_SA, not the DNTT_FUNCTION.
+ *
+ * The DNTT_SA is also used for C macros.
+ *
+ * The XREF DNTT can be used in both the GNTT and LNTT.
+ */
+
+struct DNTT_SA {
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* always K_SA */
+ KINDTYPE base_kind:10; /* K_FUNCTION, K_LABEL, etc */
+ BITS unused: 11;
+/*1*/ VTPOINTER name;
+/*2*/ long extra; /* free */
+}; /* three words */
+
+
+/*
+ * ---- 5.5. OVERALL DNTT ENTRY FORMAT
+ */
+
+
+/*
+ * Generic entry for easy access:
+ */
+
+struct DNTT_GENERIC { /* rounded up to whole number of blocks */
+ unsigned long word [9];
+};
+
+struct DNTT_BLOCK { /* easy way to deal with one block */
+/*0*/ BITS extension: 1; /* always zero */
+ KINDTYPE kind: 10; /* kind of dnttentry */
+ BITS unused: 21;
+/*1*/ unsigned long word [2];
+};
+
+
+/*
+ * Overall format:
+ */
+
+union dnttentry {
+ struct DNTT_SRCFILE dsfile;
+
+ struct DNTT_MODULE dmodule;
+ struct DNTT_FUNC dfunc;
+ struct DNTT_FUNC dentry;
+ struct DNTT_FUNC dblockdata;
+ struct DNTT_BEGIN dbegin;
+ struct DNTT_END dend;
+ struct DNTT_IMPORT dimport;
+ struct DNTT_LABEL dlabel;
+ struct DNTT_WITH dwith;
+ struct DNTT_COMMON dcommon;
+
+ struct DNTT_FPARAM dfparam;
+ struct DNTT_SVAR dsvar;
+ struct DNTT_DVAR ddvar;
+ struct DNTT_CONST dconst;
+
+ struct DNTT_TYPE dtype;
+ struct DNTT_TYPE dtag;
+ struct DNTT_POINTER dptr;
+ struct DNTT_ENUM denum;
+ struct DNTT_MEMENUM dmember;
+ struct DNTT_SET dset;
+ struct DNTT_SUBRANGE dsubr;
+ struct DNTT_ARRAY darray;
+ struct DNTT_STRUCT dstruct;
+ struct DNTT_UNION dunion;
+ struct DNTT_FIELD dfield;
+ struct DNTT_VARIANT dvariant;
+ struct DNTT_FILE dfile;
+ struct DNTT_FUNCTYPE dfunctype;
+ struct DNTT_COBSTRUCT dcobstruct;
+
+#ifdef CPLUSPLUS
+ struct DNTT_CLASS_SCOPE dclass_scope;
+ struct DNTT_POINTER dreference;
+ struct DNTT_PTRMEM dptrmem;
+ struct DNTT_PTRMEM dptrmemfunc;
+ struct DNTT_CLASS dclass;
+ struct DNTT_GENFIELD dgenfield;
+ struct DNTT_VFUNC dvfunc;
+ struct DNTT_MEMACCESS dmemaccess;
+ struct DNTT_INHERITANCE dinheritance;
+ struct DNTT_FRIEND_CLASS dfriend_class;
+ struct DNTT_FRIEND_FUNC dfriend_func;
+ struct DNTT_MODIFIER dmodifier;
+ struct DNTT_OBJECT_ID dobject_id;
+ struct DNTT_FUNC dmemfunc;
+#ifdef TEMPLATES
+ struct DNTT_TEMPLATE dtemplate;
+ struct DNTT_TEMPL_ARG dtempl_arg;
+ struct DNTT_FUNC_TEMPLATE dfunctempl;
+ struct DNTT_LINK dlink; /* generic */
+ struct DNTT_TFUNC_LINK dtflink;
+#endif /* TEMPLATES */
+#endif
+
+ struct DNTT_XREF dxref;
+ struct DNTT_SA dsa;
+
+ struct DNTT_GENERIC dgeneric;
+ struct DNTT_BLOCK dblock;
+};
+
+
+/*
+ * ---- 6. SOURCE LINE TABLE (SLT) ENTRY FORMAT
+ */
+
+/*
+ * Type of SLT special entry:
+ *
+ * Sizeof (SLTTYPE) = 4 bits, for a maximum of 16 possible special
+ * slttypes. Note that SLT_NIL is the same as SLTNIL.
+ */
+
+typedef unsigned int SLTTYPE;
+
+#define SLT_NIL SLTNIL
+
+#define SLT_NORMAL 0 /* note that the field is unsigned */
+#define SLT_SRCFILE 1
+#define SLT_MODULE 2
+#define SLT_FUNCTION 3
+#define SLT_ENTRY 4
+#define SLT_BEGIN 5
+#define SLT_END 6
+#define SLT_WITH 7
+#define SLT_EXIT 8
+#define SLT_ASSIST 9
+#define SLT_MARKER 10
+#ifdef CPLUSPLUS
+#define SLT_CLASS_SCOPE 11
+#endif
+
+struct SLT_NORM {
+ SLTTYPE sltdesc: 4; /* always zero */
+ BITS line: 28; /* where in source text */
+ ADDRESS address; /* where in function */
+}; /* two words */
+
+struct SLT_SPEC {
+ SLTTYPE sltdesc: 4; /* special entry type */
+ BITS line: 28; /* where in source text */
+ DNTTPOINTER backptr; /* where in DNTT */
+}; /* two words */
+
+struct SLT_ASST {
+ SLTTYPE sltdesc: 4; /* always nine */
+ BITS unused: 28;
+ SLTPOINTER address; /* first SLT normal */
+}; /* two words */
+
+struct SLT_GENERIC {
+ unsigned long word[2];
+}; /* two words */
+
+
+union sltentry {
+ struct SLT_NORM snorm;
+ struct SLT_SPEC sspec;
+ struct SLT_ASST sasst;
+ struct SLT_GENERIC sgeneric;
+}; /* two words */
+
+#define SLTBLOCKSIZE 8
+#define SLT_LN_PROLOGUE 0x0fffffff
+
+/*
+ * This table consists of a series of entries, each of which is
+ * either normal, special, or assist according to the sltdesc field
+ * of the first word. Normal entries contain an address (actually
+ * a code offset relative to the beginning of the current function)
+ * and a source/listing line (by line number). Listing line numbers
+ * may be used in place of source line numbers based upon a compiler
+ * option. This will also be reflected in the DNTT_SRCFLE entries.
+ * Special entries also provide a line number (where something was
+ * declared) and point back to the DNTT which references them. This
+ * is used for quick determination of scope, including source/listing
+ * file, after an interrupt. Even if there are multiple source/listing
+ * files, all source/listing line information is accumulated in this
+ * one table.
+ *
+ * The SLT was originally designed to be unnested, even for those
+ * languages whose LNTT must reflect their nesting. The debuggers
+ * depend upon this. For those languages that are nested the SLT
+ * must now be nested and an SLT_ASST must immediately follow each
+ * SLT_SPEC of type FUNC. The "address" field will be filled in by
+ * the compiler back-ends to point forward to the first SLT_NORM in
+ * the FUNC's scope. The "firstnorm" is set to one if this SLT_NORM
+ * is the first SLT_NORM looking sequentially forward in the SLT.
+ *
+ * The one exception to the normal/special/assist rule is the EXIT SLT.
+ * The EXIT SLT is used to identify exit points for a routine. The
+ * EXIT SLT is a special only in the sense that the sltdesc field
+ * is not equal to SLT_NORMAL. However, it contains a line number
+ * and address like a normal SLT. The EXIT SLT is used in place of
+ * a NORMAL SLT for all exit statements (such as "return" in C and
+ * FORTRAN, or the "end" of a procedure body in Pascal).
+ *
+ * The SLT_MARKER is for use in "Chunk-Per-Som". The address field
+ * contains a new base address (replacing the current procedure's
+ * low-address field. This new base address will be added to succeding
+ * SLT_NORMALs and SLT_EXITs to produce an absolute address.
+ *
+ * To distinguish prologue (function setup) code emitted at the END
+ * of a function from the last line (normal SLT) of the function, a
+ * normal SLT entry with a line number of SLT_LN_PRLOGUE is used.
+ * Such SLT entries are only emitted if there is trailing prologue
+ * code, and they are always the last SLT emitted for the function
+ * except for the special SLT entry for the function END. For com-
+ * pilers that emit the prologue code before the main body, no
+ * special prologue SLT entry is required.
+ *
+ * One SLT entry is emitted for (the FIRST physical line of) each
+ * executable statement, for each construct that generates a DNTT
+ * entry which points to an SLT entry, and for the prologue code,
+ * if any. The user cannot set a breakpoint without a corresponding
+ * SLT entry. Compilers must emit multiple SLT entries for parts
+ * of a composite statement (such as FOR) and for multiple statements
+ * appearing on one source line.
+ *
+ * For compatibility, the high bits of DNTTPOINTERs in SLT entries
+ * are also set to 1, even though they are not needed here.
+ *
+ * The global bit on DNTTPOINTERs in SLT entries should always be 0,
+ * as the LNTT contains all the scoping information.
+ */
+
+/*
+ * ---- 7. VALUE TABLE (VT) ENTRY FORMAT
+ *
+ *
+ * This table contains symbol names plus values for DNTT_CONST
+ * entries of type LOC_VT. All strings are null-terminated, as in C.
+ * There are no restrictions on the lengths of values nor the order
+ * in which they may appear. All symbol names are exactly as given
+ * by the user, e.g. there are no prepended underscores.
+ *
+ * CONST values are not (and need not be) terminated in any way.
+ * They may be forced to word boundaries if necessary, with
+ * resulting wasted bytes.
+ *
+ * The first byte of the table must be zero (a null string
+ * terminator), so that the null VTPOINTER results in a null name.
+ */
+
+/*
+ * ---- 8. XREF TABLE (XT) ENTRY FORMAT
+ *
+ * This table contains static information about each named object in
+ * a compilation unit. It consists of a collection of of lists,
+ * each list associated with a DNTT object via the DNTT_XREF that
+ * follows the object. The DNTT_XREF contains an XREFPOINTER which
+ * is an offset into the XT table, and denotes the beginning of the
+ * reference list.
+ *
+ * Each list is actually one or more of linear sub-list that are
+ * linked together. Each sublist begins with an XREFNAME entry,
+ * which names a (current) source file. Following the XREFNAME is
+ * one or more XREFINFO entries, one for each appearance of the
+ * object's name in the current file. These entries list what type
+ * of reference and the line no. within the file. Column numbers
+ * are currently unsupported. The XREFINFO1 structure is normally
+ * used. The XREFINFO2A/B structure pair is only used for compilers
+ * which support line numbers greater than 16 bits long. An
+ * XREFLINK marks the end of a sublist, so a typical sequence looks
+ * like:
+ *
+ * XREFNAME, XREFINFO1, XREFINFO1, ... , XREFLINK
+ *
+ * Note that all elements of a sublist must appear in sequence
+ * (linearly). If the list must be continued, the XREFLINK serves
+ * as a continuation pointer from one sublist to the next, and
+ * contains another offset into the XT where the next sublist is
+ * found for the same named object. If there is no additional
+ * sublist, the XREFLINK contains a 0 index, denoting the end of the
+ * current list.
+ *
+ * Lists for the same named object may appear in different
+ * compilation units. It is the responsibility of PXDB to link
+ * these together.
+ *
+ */
+
+#define XTBLOCKSIZE 4
+
+#define XINFO1 0
+#define XINFO2 1
+#define XLINK 2
+#define XNAME 3
+
+struct XREFINFO1 {
+ BITS tag: 3; /* always XINFO1 */
+ BITS definition: 1; /* True => definition */
+ BITS declaration: 1; /* True => declaration */
+ BITS modification: 1; /* True => modification */
+ BITS use: 1; /* True => use */
+ BITS call: 1; /* True => call */
+ BITS column: 8; /* Unsigned Byte for Column within line */
+ BITS line: 16; /* Unsigned 16-bits for line # relative */
+ /* to beginning of current inlude file. */
+};
+
+struct XREFINFO2A {
+ /* first word */
+ BITS tag: 3; /* always XINFO2A */
+ BITS definition: 1; /* True => definition */
+ BITS declaration: 1; /* True => declaration */
+ BITS modification: 1; /* True => modification */
+ BITS use: 1; /* True => use */
+ BITS call: 1; /* True => call */
+ BITS extra: 16; /* ? */
+ BITS column: 8; /* ? */
+};
+
+struct XREFINFO2B {
+ /* second word */
+ BITS line: 32; /* Unsigned 32-bits for line # relative */
+ /* to beginning of current file. */
+};
+
+struct XREFLINK {
+ BITS tag: 3; /* always XLINK for XREFLINK */
+ BITS next: 29; /* index of next list. If */
+ /* zero then this is the end of line. */
+ /* a.k.a. continuation pointer */
+};
+struct XREFNAME {
+ BITS tag: 3; /* always XNAME for XREFNAME */
+ BITS filename: 29; /* VTPOINTER to file name */
+};
+
+union xrefentry {
+ struct XREFINFO1 xrefshort;
+ struct XREFINFO2A xreflong;
+ struct XREFINFO2B xrefline;
+ struct XREFLINK xlink;
+ struct XREFNAME xfname;
+};
+
+
+/*
+ * ---- 9. ORDERING OF TABLE ENTRIES
+ *
+ *
+ * LNTT and SLT entries must be emitted and kept in source file
+ * order wherever possible. As a minimum, named LNTT entries must
+ * be emitted and kept within the proper scope, though some
+ * compilers may emit them at the end of a scope instead of the
+ * beginning. In general, the debugger must know the emission
+ * rules for the language it is dealing with, and search the LNTT
+ * accordingly, or else always search in both directions.
+ *
+ * Items in the GNTT are all global, so the public bit must always
+ * be set. Within the LNTT, the public bit indicates that the item
+ * is exported by the module in which it resides, and is visible
+ * within a module or procedure that imports the containing module.
+ *
+ * Compilers and linkers are encouraged to make multiple references
+ * to DNTT, SLT, and VT entries (even chains of DNTT entries) where
+ * possible to reduce redundancy with no loss of data. They are
+ * also encouraged to emit entries grouped so that related entries
+ * are physically close, as long as no scope rules are violated.
+ *
+ * SLT entries must be emitted in sorted line number order within
+ * each file, except for special SLT entries for ENTRYs and
+ * FUNCTIONs only. They may be out of line number order (due to
+ * nested functions, etc.) so long as the next normal SLT entry is
+ * the proper place to breakpoint the entity. For example, there
+ * can be numerous ENTRY types after a FUNCTION, all referring to
+ * the same code location. (If there are no normal SLT entries
+ * before the next FUNCTION or MODULE entry and a SLT_ASST does not
+ * immediately follow the SLT_SPEC for a FUNC, the entity has no
+ * breakpointable locations.)
+ *
+ * SLT entries must be sorted in ascending code address order
+ * WITHIN EACH MODULE or FUNCTION body. It is impossible to
+ * require that they be sorted both by file line number and code
+ * address because function object code may be emitted or linked
+ * out of source order in a segment.
+ *
+ * It is reasonable to expect sequential SLT entries may have the
+ * same line numbers or code locations (but not both, as that would
+ * be redundant). This might be due to multiple statements on one
+ * source line or several scope levels starting at one place in the
+ * code.
+ *
+ * Thus, for nested languages like Pascal and Modcal, the LNTT
+ * entries must be nested to reflect the program's scope. The SLT
+ * entries should also be nested with an SLT_ASST entry following
+ * each SLT_SPEC of type FUNC.
+ */
+
+
+/*
+ * ---- 10. LINKER CONSIDERATIONS
+ *
+ * As stated earlier, all fixups to the debug information are
+ * done through the generation of a list of fixups for the GNTT
+ * and LNTT subspaces within the debug space. Other than these
+ * fixups, the only other task for the linker is the concatenation
+ * of the debug spaces from separate compilation units.
+ */
+
+
+/*
+ * --- 11. PREPROCESSOR
+ */
+
+/*
+ * The preprocessor (PXDB) which must be run on the debug info in
+ * the executable program file massages this debug info so that the
+ * debugger may start up and run more efficiently. Some of the
+ * tasks performed by PXDB are: remove duplicate global type and
+ * variable information from the GNTT, append the GNTT onto the end
+ * of the LNTT and place both back in the LNTT section, build quick
+ * look-up tables for files, procedures, modules, and paragraphs
+ * (for Cobol), placing these in the GNTT section, and reconstruct
+ * the header appearing in the header section to access this
+ * information.
+ *
+ * This post-PXDB header is as follows:
+ */
+
+struct PXDB_header {
+ int pd_entries; /* # of entries in function look-up table */
+ int fd_entries; /* # of entries in file look-up table */
+ int md_entries; /* # of entries in module look-up table */
+ BITS pxdbed : 1; /* 1 => file has been preprocessed */
+ BITS bighdr : 1; /* 1 => this header contains 'time' word */
+ BITS sa_header : 1;/* 1 => created by SA version of pxdb */
+ /* used for version check in xdb */
+#ifdef CPLUSPLUS
+ BITS inlined: 1; /* one or more functions have been inlined */
+ BITS spare:12;
+ short version; /* pxdb header version */
+#else /* CPLUSPLUS */
+ BITS spare:29;
+#endif /* CPLUSPLUS */
+ int globals; /* index into the DNTT where GNTT begins */
+ BITS time; /* modify time of file before being pxdbed */
+ int pg_entries; /* # of entries in label look-up table */
+ int functions; /* actual number of functions */
+ int files; /* actual number of files */
+#ifdef CPLUSPLUS
+ int cd_entries; /* # of entries in class look-up table */
+ int aa_entries; /* # of entries in addr alias look-up table */
+ int oi_entries; /* # of entries in object id look-up table */
+#endif
+};
+
+#define PXDB_VERSION_CPLUSPLUS 1
+#define PXDB_VERSION_7_4 2
+#define PXDB_VERSION_CPP_30 3
+
+#define PXDB_VERSION_2_1 1
+
+/*
+ * The structures for the quick look-up tables in the
+ * post-PXDB GNTT section are:
+ */
+
+/*
+ * Source File Descriptor:
+ *
+ * An element of the source file quick look-up table
+ */
+
+typedef struct FDS {
+ long isym; /* first symbol for file */
+ ADRT adrStart; /* mem adr of start of file's code */
+ ADRT adrEnd; /* mem adr of end of file's code */
+ char *sbFile; /* name of source file */
+ BITS fHasDecl: 1; /* do we have a .d file? */
+ BITS fWarned: 1; /* have warned about age problems? */
+ unsigned short ilnMac; /* lines in file (0 if don't know) */
+ int ipd; /* first proc for file, in PD [] */
+ BITS *rgLn; /* line pointer array, if any */
+} FDR, *pFDR;
+
+/*
+ * Procedure Descriptor:
+ *
+ * An element of the procedure quick look-up table
+ */
+
+typedef struct PDS {
+ long isym; /* first symbol for proc */
+ ADRT adrStart; /* memory adr of start of proc */
+ ADRT adrEnd; /* memory adr of end of proc */
+ char *sbAlias; /* alias name of procedure */
+ char *sbProc; /* real name of procedure */
+ ADRT adrBp; /* address of entry breakpoint */
+ ADRT adrExitBp; /* address of exit breakpoint */
+#ifdef CPLUSPLUS
+ int icd; /* member of this class */
+#else /* CPLUSPLUS */
+ BITS inst; /* instruction at entry */
+#endif /* CPLUSPLUS */
+#ifdef TEMPLATES
+ BITS ipd; /* index of template for this function */
+#else /* TEMPLATES */
+ BITS instExit; /* instruction at exit */
+#endif /* TEMPLATES */
+#ifdef CPLUSPLUS
+#ifdef TEMPLATES
+ BITS unused: 6;
+ BITS fTemplate: 1; /* function template */
+ BITS fExpansion: 1; /* function expansion */
+ BITS linked : 1; /* linked with other expansions */
+#else /* TEMPLATES */
+ BITS unused: 9;
+#endif /* TEMPLATES */
+ BITS duplicate: 1; /* clone of another procedure */
+ BITS overloaded:1; /* overloaded function */
+ BITS member: 1; /* class member function */
+ BITS constructor:1; /* constructor function */
+ BITS destructor:1; /* destructor function */
+ BITS Static: 1; /* static function */
+ BITS Virtual: 1; /* virtual function */
+ BITS constant: 1; /* constant function */
+ BITS pure: 1; /* pure (virtual) function */
+ BITS language: 4; /* procedure's language */
+ BITS inlined: 1; /* function has been inlined */
+ BITS Operator: 1; /* operator function */
+ BITS stub: 1; /* bodyless function */
+#else
+ BITS unused1: 18;
+ BITS language: 4; /* procedure's language */
+ BITS unused2: 3;
+#endif
+ BITS optimize: 2; /* optimization level */
+ BITS level: 5; /* nesting level (top=0) */
+} PDR, *pPDR;
+
+/*
+ * Module Descriptor:
+ *
+ * An element of the module quick reference table
+ */
+
+typedef struct MDS {
+ long isym; /* first symbol for module */
+ ADRT adrStart; /* adr of start of mod. */
+ ADRT adrEnd; /* adr of end of mod. */
+ char *sbAlias; /* alias name of module */
+ char *sbMod; /* real name of module */
+ BITS imports: 1; /* module have any imports? */
+ BITS vars_in_front: 1; /* module globals in front? */
+ BITS vars_in_gaps: 1; /* module globals in gaps? */
+ BITS unused : 29;
+ BITS unused2; /* space for future stuff */
+} MDR, *pMDR;
+
+
+/*
+ * Paragraph Descriptor:
+ *
+ * An element of the paragraph quick look-up table
+ */
+
+typedef struct PGS {
+ long isym; /* first symbol for label */
+ ADRT adrStart; /* memory adr of start of label */
+ ADRT adrEnd; /* memory adr of end of label */
+ char *sbLab; /* name of label */
+ BITS inst; /* Used in xdb to store inst @ bp */
+ BITS sect: 1; /* true = section, false = parag. */
+ BITS unused: 31; /* future use */
+} PGR, *pPGR;
+
+#ifdef CPLUSPLUS
+/*
+ * Class Descriptor:
+ *
+ * An element of the class quick look-up table
+ */
+
+typedef struct CDS {
+ char *sbClass; /* name of class */
+ long isym; /* class symbol (tag) */
+ BITS type : 2; /* 0=class, 1=union, 2=struct */
+#ifdef TEMPLATES
+ BITS fTemplate : 1;/* class template */
+ BITS expansion : 1;/* template expansion */
+ BITS unused :28;
+#else /* TEMPLATES */
+ BITS unused : 30;
+#endif /* TEMPLATES */
+ SLTPOINTER lowscope; /* beginning of defined scope */
+ SLTPOINTER hiscope; /* end of defined scope */
+} CDR, *pCDR;
+
+/*
+ * Address Alias Entry
+ *
+ * An element of the address alias quick look-up table
+ */
+
+typedef struct AAS {
+ ADRT low;
+ ADRT high;
+ int index;
+ BITS unused : 31;
+ BITS alternate : 1; /* alternate unnamed aliases? */
+} AAR, *pAAR;
+
+/*
+ * Object Identification Entry
+ *
+ * An element of the object identification quick look-up table
+ */
+
+typedef struct OIS {
+ ADRT obj_ident; /* class identifier */
+ long isym; /* class symbol */
+ long offset; /* offset to object start */
+} OIR, *pOIR;
+
+#endif /*CPLUSPLUS*/
+
+#if __cplusplus
+#undef public
+#endif
+
+#endif /* _SYMTAB_INCLUDED */
projects / platform / upstream / binutils.git / commitdiff