diff options
| author | Jeff Law <law@redhat.com> | 1994-08-19 16:04:42 +0000 |
|---|---|---|
| committer | Jeff Law <law@redhat.com> | 1994-08-19 16:04:42 +0000 |
| commit | 36d4f4d8516c9293d633ad65dadf8e2f52c7a7b1 (patch) | |
| tree | 9845c40f782813923b43748dcc0108f58f1ac1ed | |
| parent | 64b7bf9f67f7b173537cbe7e7b90c46b49d648c3 (diff) | |
| download | gdb-36d4f4d8516c9293d633ad65dadf8e2f52c7a7b1.zip gdb-36d4f4d8516c9293d633ad65dadf8e2f52c7a7b1.tar.gz gdb-36d4f4d8516c9293d633ad65dadf8e2f52c7a7b1.tar.bz2 | |
* hpux-symtab.h: New file describing the debug symbols emitted by
the HP C compilers.
| -rw-r--r-- | include/.Sanitize | 6 | ||||
| -rw-r--r-- | include/ChangeLog.hpread | 6 | ||||
| -rwxr-xr-x | include/hpux-symtab.h | 2559 |
3 files changed, 2571 insertions, 0 deletions
diff --git a/include/.Sanitize b/include/.Sanitize index 3471105..ff7023b 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 0000000..08bfaa2 --- /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 0000000..1e1813a --- /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 */ |