From 36d4f4d8516c9293d633ad65dadf8e2f52c7a7b1 Mon Sep 17 00:00:00 2001
From: Jeff Law <law@redhat.com>
Date: Fri, 19 Aug 1994 16:04:42 +0000
Subject: [PATCH]         * hpux-symtab.h: New file describing the debug
 symbols emitted by         the HP C compilers.

---
 include/.Sanitize        |    6 +
 include/ChangeLog.hpread |    6 +
 include/hpux-symtab.h    | 2559 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 2571 insertions(+)
 create mode 100644 include/ChangeLog.hpread
 create mode 100755 include/hpux-symtab.h

diff --git a/include/.Sanitize b/include/.Sanitize
index 34711051b53..ff7023be384 100644
--- a/include/.Sanitize
+++ b/include/.Sanitize
@@ -21,6 +21,12 @@ else
 	lose_these_too="mpw"
 fi
 
+if ( echo $* | grep keep\-hpread > /dev/null ) ; then
+	keep_these_too="hpux-symtab.h ChangeLog.hpread"
+else
+	lose_these_too="hpux-symtab.h ChangeLog.hpread"
+fi
+
 # All files listed between the "Things-to-keep:" line and the
 # "Files-to-sed:" line will be kept.  All other files will be removed.
 # Directories listed in this section will have their own Sanitize
diff --git a/include/ChangeLog.hpread b/include/ChangeLog.hpread
new file mode 100644
index 00000000000..08bfaa29f22
--- /dev/null
+++ b/include/ChangeLog.hpread
@@ -0,0 +1,6 @@
+Fri Aug 19 09:56:31 1994  Jeff Law  (law@snake.cs.utah.edu)
+
+	* hpux-symtab.h: New file describing the debug symbols emitted by
+	the HP C compilers.
+
+
diff --git a/include/hpux-symtab.h b/include/hpux-symtab.h
new file mode 100755
index 00000000000..1e1813a1bfd
--- /dev/null
+++ b/include/hpux-symtab.h
@@ -0,0 +1,2559 @@
+/***************************************************************************
+ * (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 */
-- 
2.30.2