diff options
| -rw-r--r-- | include/.Sanitize | 7 | ||||
| -rw-r--r-- | include/ChangeLog | 15 | ||||
| -rw-r--r-- | include/ChangeLog.hpread | 6 | ||||
| -rw-r--r-- | include/hp-symtab.h | 983 | ||||
| -rwxr-xr-x | include/hpux-symtab.h | 2559 |
5 files changed, 999 insertions, 2571 deletions
diff --git a/include/.Sanitize b/include/.Sanitize index aab0e01..4ad7726 100644 --- a/include/.Sanitize +++ b/include/.Sanitize @@ -21,12 +21,6 @@ else lose_these_too="${lose_these_too} mpw" fi -if ( echo $* | grep keep\-hpread > /dev/null ) ; then - keep_these_too="${keep_these_too} hpux-symtab.h ChangeLog.hpread" -else - lose_these_too="${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 @@ -50,6 +44,7 @@ fopen-bin.h fopen-same.h gdbm.h getopt.h +hp-symtab.h ieee.h libiberty.h nlm diff --git a/include/ChangeLog b/include/ChangeLog index b11a398..b91ed0a 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,18 @@ +Fri Nov 25 00:14:05 1994 Jeff Law (law@snake.cs.utah.edu) + + * hp-symtab.h: New file describing the debug symbols emitted + by the HP C compilers. + +Fri Nov 11 15:48:37 1994 Ian Lance Taylor <ian@sanguine.cygnus.com> + + * bfdlink.h (struct bfd_link_hash_entry): Change u.c.size from 24 + to 26 bits, and change u.c.alignment_power from 8 to 6 bits. 6 + bit in the alignment power is enough for a 64 bit address space. + +Mon Oct 31 13:02:51 1994 Stan Shebs (shebs@andros.cygnus.com) + + * demangle.h (cplus_mangle_opname): Declare. + Tue Oct 25 11:38:02 1994 Ian Lance Taylor <ian@sanguine.cygnus.com> * bfdlink.h (struct bfd_link_callbacks): Fix comments for diff --git a/include/ChangeLog.hpread b/include/ChangeLog.hpread deleted file mode 100644 index 08bfaa2..0000000 --- a/include/ChangeLog.hpread +++ /dev/null @@ -1,6 +0,0 @@ -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/hp-symtab.h b/include/hp-symtab.h new file mode 100644 index 0000000..84f6a51 --- /dev/null +++ b/include/hp-symtab.h @@ -0,0 +1,983 @@ +/* Definitions and structures for reading debug symbols from the + native HP C compiler. + + Written by the Center for Software Science at the University of Utah + and by Cygnus Support. + + Copyright 1994 Free Software Foundation, Inc. + + 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; either version 2 of the License, or + (at your option) any later version. + + 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 program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifndef HP_SYMTAB_INCLUDED +#define HP_SYMTAB_INCLUDED + +/* General information: + + This header file defines and describes only the basic data structures + necessary to read debug symbols produced by the HP C compiler using the + SOM object file format. Definitions and structures used by other compilers + for other languages or object file formats may be missing. + (For a full description of the debug format, ftp hpux-symtab.h from + jaguar.cs.utah.edu:/dist). + + + Debug symbols are contained entirely within an unloadable space called + $DEBUG$. $DEBUG$ contains several subspaces which group related + debug symbols. + + $GNTT$ contains information for global variables, types and contants. + + $LNTT$ contains information for procedures (including nesting), scoping + information, local variables, types, and constants. + + $SLT$ contains source line information so that code addresses may be + mapped to source lines. + + $VT$ contains various strings and constants for named objects (variables, + typedefs, functions, etc). Strings are stored as null-terminated character + lists. Constants always begin on word boundaries. The first byte of + the VT must be zero (a null string). + + $XT$ is not currently used by GDB. + + Many structures within the subspaces point to other structures within + the same subspace, or to structures within a different subspace. These + pointers are represented as a structure index from the beginning of + the appropriate subspace. */ + +/* Used to describe where a constant is stored. */ +enum location_type +{ + LOCATION_IMMEDIATE, + LOCATION_PTR, + LOCATION_VT, +}; + +/* Languages supported by this debug format. Within the data structures + this type is limited to 4 bits for a maximum of 16 languages. */ +enum hp_language +{ + HP_LANGUAGE_UNKNOWN, + HP_LANGUAGE_C, + HP_LANGUAGE_F77, + HP_LANGUAGE_PASCAL, + HP_LANGUAGE_COBOL, + HP_LANGUAGE_BASIC, + HP_LANGUAGE_ADA, + HP_LANGUAGE_CPLUSPLUS, +}; + + +/* Basic data types available in this debug format. Within the data + structures this type is limited to 5 bits for a maximum of 32 basic + data types. */ +enum hp_type +{ + HP_TYPE_UNDEFINED, + HP_TYPE_BOOLEAN, + HP_TYPE_CHAR, + HP_TYPE_INT, + HP_TYPE_UNSIGNED_INT, + HP_TYPE_REAL, + HP_TYPE_COMPLEX, + HP_TYPE_STRING200, + HP_TYPE_LONGSTRING200, + HP_TYPE_TEXT, + HP_TYPE_FLABEL, + HP_TYPE_FTN_STRING_SPEC, + HP_TYPE_MOD_STRING_SPEC, + HP_TYPE_PACKED_DECIMAL, + HP_TYPE_REAL_3000, + HP_TYPE_MOD_STRING_3000, + HP_TYPE_ANYPOINTER, + HP_TYPE_GLOBAL_ANYPOINTER, + HP_TYPE_LOCAL_ANYPOINTER, + HP_TYPE_COMPLEXS3000, + HP_TYPE_FTN_STRING_S300_COMPAT, + HP_TYPE_FTN_STRING_VAX_COMPAT, + HP_TYPE_BOOLEAN_S300_COMPAT, + HP_TYPE_BOOLEAN_VAX_COMPAT, + HP_TYPE_WIDE_CHAR, + HP_TYPE_LONG, + HP_TYPE_UNSIGNED_LONG, + HP_TYPE_DOUBLE, + HP_TYPE_TEMPLATE_ARG, +}; + +/* An immediate name and type table entry. + + extension and immediate will always be one. + global will always be zero. + hp_type is the basic type this entry describes. + bitlength is the length in bits for the basic type. */ +struct dnttp_immediate +{ + unsigned int extension: 1; + unsigned int immediate: 1; + unsigned int global: 1; + enum hp_type type: 5; + unsigned int bitlength: 24; +}; + +/* A nonimmediate name and type table entry. + + extension will always be one. + immediate will always be zero. + if global is zero, this entry points into the LNTT + if global is one, this entry points into the GNTT + index is the index within the GNTT or LNTT for this entry. */ +struct dnttp_nonimmediate +{ + unsigned int extension: 1; + unsigned int immediate: 1; + unsigned int global: 1; + unsigned int index: 29; +}; + +/* A pointer to an entry in the GNTT and LNTT tables. It has two + forms depending on the type being described. + + The immediate form is used for simple entries and is one + word. + + The nonimmediate form is used for complex entries and contains + an index into the LNTT or GNTT which describes the entire type. + + If a dnttpointer is -1, then it is a NIL entry. */ + +#define DNTTNIL (-1) +typedef union dnttpointer +{ + struct dnttp_immediate dntti; + struct dnttp_nonimmediate dnttp; + int word; +} dnttpointer; + +/* An index into the source line table. As with dnttpointers, a sltpointer + of -1 indicates a NIL entry. */ +#define SLTNIL (-1) +typedef int sltpointer; + +/* Unsigned byte offset into the VT. */ +typedef unsigned int vtpointer; + +/* A DNTT entry (used within the GNTT and LNTT). + + DNTT entries are variable sized objects, but are always a multiple + of 3 words (we call each group of 3 words a "block"). + + The first bit in each block is an extension bit. This bit is zero + for the first block of a DNTT entry. If the entry requires more + than one block, then this bit is set to one in all blocks after + the first one. */ + +/* Each DNTT entry describes a particular debug symbol (beginning of + a source file, a function, variables, structures, etc. + + The type of the DNTT entry is stored in the "kind" field within the + DNTT entry itself. */ + +enum dntt_entry_type +{ + DNTT_TYPE_NIL = -1, + DNTT_TYPE_SRCFILE, + DNTT_TYPE_MODULE, + DNTT_TYPE_FUNCTION, + DNTT_TYPE_ENTRY, + DNTT_TYPE_BEGIN, + DNTT_TYPE_END, + DNTT_TYPE_IMPORT, + DNTT_TYPE_LABEL, + DNTT_TYPE_FPARAM, + DNTT_TYPE_SVAR, + DNTT_TYPE_DVAR, + DNTT_TYPE_HOLE1, + DNTT_TYPE_CONST, + DNTT_TYPE_TYPEDEF, + DNTT_TYPE_TAGDEF, + DNTT_TYPE_POINTER, + DNTT_TYPE_ENUM, + DNTT_TYPE_MEMENUM, + DNTT_TYPE_SET, + DNTT_TYPE_SUBRANGE, + DNTT_TYPE_ARRAY, + DNTT_TYPE_STRUCT, + DNTT_TYPE_UNION, + DNTT_TYPE_FIELD, + DNTT_TYPE_VARIANT, + DNTT_TYPE_FILE, + DNTT_TYPE_FUNCTYPE, + DNTT_TYPE_WITH, + DNTT_TYPE_COMMON, + DNTT_TYPE_COBSTRUCT, + DNTT_TYPE_XREF, + DNTT_TYPE_SA, + DNTT_TYPE_MACRO, + DNTT_TYPE_BLOCKDATA, + DNTT_TYPE_CLASS_SCOPE, + DNTT_TYPE_REFERENCE, + DNTT_TYPE_PTRMEM, + DNTT_TYPE_PTRMEMFUNC, + DNTT_TYPE_CLASS, + DNTT_TYPE_GENFIELD, + DNTT_TYPE_VFUNC, + DNTT_TYPE_MEMACCESS, + DNTT_TYPE_INHERITANCE, + DNTT_TYPE_FRIEND_CLASS, + DNTT_TYPE_FRIEND_FUNC, + DNTT_TYPE_MODIFIER, + DNTT_TYPE_OBJECT_ID, + DNTT_TYPE_MEMFUNC, + DNTT_TYPE_TEMPLATE, + DNTT_TYPE_TEMPLATE_ARG, + DNTT_TYPE_FUNC_TEMPLATE, + DNTT_TYPE_LINK, + DNTT_TYPE_MAX, +}; + +/* DNTT_TYPE_SRCFILE: + + One DNTT_TYPE_SRCFILE symbol is output for the start of each source + file and at the begin and end of an included file. A DNTT_TYPE_SRCFILE + entry is also output before each DNTT_TYPE_FUNC symbol so that debuggers + can determine what file a function was defined in. + + LANGUAGE describes the source file's language. + + NAME points to an VT entry providing the source file's name. + + Note the name used for DNTT_TYPE_SRCFILE entries are exactly as seen + by the compiler (ie they may be relative or absolute). C include files + via <> inclusion must use absolute paths. + + ADDRESS points to an SLT entry from which line number and code locations + may be determined. */ + +struct dntt_type_srcfile +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + enum hp_language language: 4; + unsigned int unused: 17; + vtpointer name; + sltpointer address; +}; + +/* DNTT_TYPE_MODULE: + + A DNTT_TYPE_MODULE symbol is emitted for the start of a pascal + module or C source file. + + Each DNTT_TYPE_MODULE must have an associated DNTT_TYPE_END symbol. + + NAME points to a VT entry providing the module's name. Note C + source files are considered nameless modules. + + ALIAS point to a VT entry providing a secondary name. + + ADDRESS points to an SLT entry from which line number and code locations + may be determined. */ + +struct dntt_type_module +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int unused: 21; + vtpointer name; + vtpointer alias; + dnttpointer unused2; + sltpointer address; +}; + +/* DNTT_TYPE_FUNCTION: + + A DNTT_TYPE_FUNCTION symbol is emitted for each function definition; + a DNTT_TYPE_ENTRY symbols is used for secondary entry points. Both + symbols used the dntt_type_function structure. + + Each DNTT_TYPE_FUNCTION must have a matching DNTT_TYPE_END. + + GLOBAL is nonzero if the function has global scope. + + LANGUAGE describes the function's source language. + + OPT_LEVEL describes the optimization level the function was compiled + with. + + VARARGS is nonzero if the function uses varargs. + + NAME points to a VT entry providing the function's name. + + ALIAS points to a VT entry providing a secondary name for the function. + + FIRSTPARAM points to a LNTT entry which describes the parameter list. + + ADDRESS points to an SLT entry from which line number and code locations + may be determined. + + ENTRYADDR is the memory address corresponding the the function's entry point + + RETVAL points to a LNTT entry describing the function's return value. + + LOWADDR is the lowest memory address associated with this function. + + HIADDR is the highest memory address associated with this function. */ + +struct dntt_type_function +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int global: 1; + enum hp_language language: 4; + unsigned int nest_level: 5; + unsigned int opt_level: 2; + unsigned int varargs: 1; + unsigned int lang_info: 4; + unsigned int inlined: 1; + unsigned int localalloc: 1; + unsigned int expansion: 1; + unsigned int unused: 1; + vtpointer name; + vtpointer alias; + dnttpointer firstparam; + sltpointer address; + CORE_ADDR entryaddr; + dnttpointer retval; + CORE_ADDR lowaddr; + CORE_ADDR hiaddr; +}; + +/* DNTT_TYPE_BEGIN: + + A DNTT_TYPE_BEGIN symbol is emitted to begin a new nested scope. + Every DNTT_TYPE_BEGIN symbol must have a matching DNTT_TYPE_END symbol. + + CLASSFLAG is nonzero if this is the beginning of a c++ class definition. + + ADDRESS points to an SLT entry from which line number and code locations + may be determined. */ + +struct dntt_type_begin +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int classflag: 1; + unsigned int unused: 20; + sltpointer address; +}; + +/* DNTT_TYPE_END: + + A DNTT_TYPE_END symbol is emitted when closing a scope started by + a DNTT_TYPE_MODULE, DNTT_TYPE_FUNCTION, and DNTT_TYPE_BEGIN symbols. + + ENDKIND describes what type of scope the DNTT_TYPE_END is closing + (DNTT_TYPE_MODULE, DNTT_TYPE_BEGIN, etc). + + CLASSFLAG is nonzero if this is the end of a c++ class definition. + + ADDRESS points to an SLT entry from which line number and code locations + may be determined. + + BEGINSCOPE points to the LNTT entry which opened the scope. */ + +struct dntt_type_end +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + enum dntt_entry_type endkind: 10; + unsigned int classflag: 1; + unsigned int unused: 10; + sltpointer address; + dnttpointer beginscope; +}; + +/* DNTT_TYPE_IMPORT is unused by GDB. */ +/* DNTT_TYPE_LABEL is unused by GDB. */ + +/* DNTT_TYPE_FPARAM: + + A DNTT_TYPE_FPARAM symbol is emitted for a function argument. When + chained together the symbols represent an argument list for a function. + + REGPARAM is nonzero if this parameter was passed in a register. + + INDIRECT is nonzero if this parameter is a pointer to the parameter + (pass by reference or pass by value for large items). + + LONGADDR is nonzero if the parameter is a 64bit pointer. + + NAME is a pointer into the VT for the parameter's name. + + LOCATION describes where the parameter is stored. Depending on the + parameter type LOCATION could be a register number, or an offset + from the stack pointer. + + TYPE points to a NTT entry describing the type of this parameter. + + NEXTPARAM points to the LNTT entry describing the next parameter. */ + +struct dntt_type_fparam +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int regparam: 1; + unsigned int indirect: 1; + unsigned int longaddr: 1; + unsigned int copyparam: 1; + unsigned int dflt: 1; + unsigned int unused: 16; + vtpointer name; + int location; + dnttpointer type; + dnttpointer nextparam; + int misc; +}; + +/* DNTT_TYPE_SVAR: + + A DNTT_TYPE_SVAR is emitted to describe a variable in static storage. + + GLOBAL is nonzero if the variable has global scope. + + INDIRECT is nonzero if the variable is a pointer to an object. + + LONGADDR is nonzero if the variable is in long pointer space. + + STATICMEM is nonzero if the variable is a member of a class. + + A_UNION is nonzero if the variable is an anonymous union member. + + NAME is a pointer into the VT for the variable's name. + + LOCATION provides the memory address for the variable. + + TYPE is a pointer into either the GNTT or LNTT which describes + the type of this variable. */ + +struct dntt_type_svar +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int global: 1; + unsigned int indirect: 1; + unsigned int longaddr: 1; + unsigned int staticmem: 1; + unsigned int a_union: 1; + unsigned int unused: 16; + vtpointer name; + CORE_ADDR location; + dnttpointer type; + unsigned int offset; + unsigned int displacement; +}; + +/* DNTT_TYPE_DVAR: + + A DNTT_TYPE_DVAR is emitted to describe automatic variables and variables + held in registers. + + GLOBAL is nonzero if the variable has global scope. + + INDIRECT is nonzero if the variable is a pointer to an object. + + REGVAR is nonzero if the variable is in a register. + + A_UNION is nonzero if the variable is an anonymous union member. + + NAME is a pointer into the VT for the variable's name. + + LOCATION provides the memory address or register number for the variable. + + TYPE is a pointer into either the GNTT or LNTT which describes + the type of this variable. */ + +struct dntt_type_dvar +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int global: 1; + unsigned int indirect: 1; + unsigned int regvar: 1; + unsigned int a_union: 1; + unsigned int unused: 17; + vtpointer name; + int location; + dnttpointer type; + unsigned int offset; +}; + +/* DNTT_TYPE_CONST: + + A DNTT_TYPE_CONST symbol is emitted for program constants. + + GLOBAL is nonzero if the constant has global scope. + + INDIRECT is nonzero if the constant is a pointer to an object. + + LOCATION_TYPE describes where to find the constant's value + (in the VT, memory, or embedded in an instruction). + + CLASSMEM is nonzero if the constant is a member of a class. + + NAME is a pointer into the VT for the constant's name. + + LOCATION provides the memory address, register number or pointer + into the VT for the constant's value. + + TYPE is a pointer into either the GNTT or LNTT which describes + the type of this variable. */ + +struct dntt_type_const +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int global: 1; + unsigned int indirect: 1; + enum location_type: 3; + unsigned int classmem: 1; + unsigned int unused: 15; + vtpointer name; + CORE_ADDR location; + dnttpointer type; + unsigned int offset; + unsigned int displacement; +}; + +/* DNTT_TYPE_TYPEDEF and DNTT_TYPE_TAGDEF: + + The same structure is used to describe typedefs and tagdefs. + + DNTT_TYPE_TYPEDEFS are associated with C "typedefs". + + DNTT_TYPE_TAGDEFs are associated with C "struct", "union", and "enum" + tags, which may have the same name as a typedef in the same scope. + + GLOBAL is nonzero if the typedef/tagdef has global scope. + + TYPEINFO is used to determine if full type information is available + for a tag. (usually 1, but can be zero for opaque types in C). + + NAME is a pointer into the VT for the constant's name. + + TYPE points to the underlying type for the typedef/tagdef in the + GNTT or LNTT. */ + +struct dntt_type_type +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int global: 1; + unsigned int typeinfo: 1; + unsigned int unused: 19; + vtpointer name; + dnttpointer type; +}; + +/* DNTT_TYPE_POINTER: + + Used to describe a pointer to an underlying type. + + POINTSTO is a pointer into the GNTT or LNTT for the type which this + pointer points to. + + BITLENGTH is the length of the pointer (not the underlying type). */ + +struct dntt_type_pointer +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int unused: 21; + dnttpointer pointsto; + unsigned int bitlength; +}; + + +/* DNTT_TYPE_ENUM: + + Used to describe enumerated types. + + FIRSTMEM is a pointer to a DNTT_TYPE_MEMENUM in the GNTT/LNTT which + describes the first member (and contains a pointer to the chain of + members). + + BITLENGTH is the number of bits used to hold the values of the enum's + members. */ + +struct dntt_type_enum +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int unused: 21; + dnttpointer firstmem; + unsigned int bitlength; +}; + +/* DNTT_TYPE_MEMENUM + + Used to describe members of an enumerated type. + + CLASSMEM is nonzero if this member is part of a class. + + NAME points into the VT for the name of this member. + + VALUE is the value of this enumeration member. + + NEXTMEM points to the next DNTT_TYPE_MEMENUM in the chain. */ + +struct dntt_type_memenum +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int classmem: 1; + unsigned int unused: 20; + vtpointer name; + unsigned int value; + dnttpointer nextmem; +}; + +/* DNTT_TYPE_SET + + DECLARATION describes the bitpacking of the set. + + SUBTYPE points to a DNTT entry describing the type of the members. + + BITLENGTH is the size of the set. */ + +struct dntt_type_set +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int declaration: 2; + unsigned int unused: 19; + dnttpointer subtype; + unsigned int bitlength; +}; + +/* DNTT_TYPE_SUBRANGE + + DYN_LOW describes the lower bound of the subrange: + + 00 for a constant lower bound (found in LOWBOUND). + + 01 for a dynamic lower bound with the lower bound found in the the + memory address pointed to by LOWBOUND. + + 10 for a dynamic lower bound described by an variable found in the + DNTT/LNTT (LOWBOUND would be a pointer into the DNTT/LNTT). + + DYN_HIGH is similar to DYN_LOW, except it describes the upper bound. + + SUBTYPE points to the type of the subrange. + + BITLENGTH is the length in bits needed to describe the subrange's + values. */ + +struct dntt_type_subrange +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int dyn_low: 2; + unsigned int dyn_high: 2; + unsigned int unused: 17; + int lowbound; + int highbound; + dnttpointer subtype; + unsigned int bitlength; +}; + +/* DNTT_TYPE_ARRAY + + DECLARATION describes the bit packing used in the array. + + ARRAYISBYTES is nonzero if the field in arraylength describes the + length in bytes rather than in bits. A value of zero is used to + describe an array with size 2**32. + + ELEMISBYTES is nonzero if the length if each element in the array + is describes in bytes rather than bits. A value of zero is used + to an element with size 2**32. + + ELEMORDER is nonzero if the elements are indexed in increasing order. + + JUSTIFIED if the elements are left justified to index zero. + + ARRAYLENGTH is the length of the array. + + INDEXTYPE is a DNTT pointer to the type used to index the array. + + ELEMTYPE is a DNTT pointer to the type for the array elements. + + ELEMLENGTH is the length of each element in the array (including + any padding). + + Multi-dimensional arrays are represented by ELEMTYPE pointing to + another DNTT_TYPE_ARRAY. */ + +struct dntt_type_array +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int declaration: 2; + unsigned int dyn_low: 2; + unsigned int dyn_high: 2; + unsigned int arrayisbytes: 1; + unsigned int elemisbytes: 1; + unsigned int elemorder: 1; + unsigned int justified: 1; + unsigned int unused: 11; + unsigned int arraylength; + dnttpointer indextype; + dnttpointer elemtype; + unsigned int elemlength; +}; + +/* DNTT_TYPE_STRUCT + + DNTT_TYPE_STRUCT is used to describe a C structure. + + DECLARATION describes the bitpacking used. + + FIRSTFIELD is a DNTT pointer to the first field of the structure + (each field contains a pointer to the next field, walk the list + to access all fields of the structure). + + VARTAGFIELD and VARLIST are used for Pascal variant records. + + BITLENGTH is the size of the structure in bits. */ + +struct dntt_type_struct +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int declaration: 2; + unsigned int unused: 19; + dnttpointer firstfield; + dnttpointer vartagfield; + dnttpointer varlist; + unsigned int bitlength; +}; + +/* DNTT_TYPE_UNION + + DNTT_TYPE_UNION is used to describe a C union. + + FIRSTFIELD is a DNTT pointer to the beginning of the field chain. + + BITLENGTH is the size of the union in bits. */ + +struct dntt_type_union +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int unused: 21; + dnttpointer firstfield; + unsigned int bitlength; +}; + +/* DNTT_TYPE_FIELD + + DNTT_TYPE_FIELD describes one field in a structure or union. + + VISIBILITY is used to describe the visibility of the field + (for c++. public = 0, protected = 1, private = 2). + + A_UNION is nonzero if this field is a member of an anonymous union. + + STATICMEM is nonzero if this field is a static member of a template. + + NAME is a pointer into the VT for the name of the field. + + BITOFFSET gives the offset of this field in bits from the beginning + of the structure or union this field is a member of. + + TYPE is a DNTT pointer to the type describing this field. + + BITLENGTH is the size of the entry in bits. + + NEXTFIELD is a DNTT pointer to the next field in the chain. */ + +struct dntt_type_field +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int visibility: 2; + unsigned int a_union: 1; + unsigned int staticmem: 1; + unsigned int unused: 17; + vtpointer name; + unsigned int bitoffset; + dnttpointer type; + unsigned int bitlength; + dnttpointer nextfield; +}; + +/* DNTT_TYPE_VARIANT is unused by GDB. */ +/* DNTT_TYPE_FILE is unused by GDB. */ + +/* DNTT_TYPE_COMMON is unused by GDB. */ +/* DNTT_TYPE_LINK is unused by GDB. */ +/* DNTT_TYPE_FFUNC_LINK is unused by GDB. */ +/* DNTT_TYPE_TEMPLATE is unused by GDB. */ + +/* DNTT_TYPE_FUNCTYPE + + VARARGS is nonzero if this function uses varargs. + + FIRSTPARAM is a DNTT pointer to the first entry in the parameter + chain. + + RETVAL is a DNTT pointer to the type of the return value. */ + +struct dntt_type_functype +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int varargs: 1; + unsigned int info: 4; + unsigned int unused: 16; + unsigned int bitlength; + dnttpointer firstparam; + dnttpointer retval; +}; + +/* DNTT_TYPE_WITH is unued by GDB. */ +/* DNTT_TYPE_COBSTRUCT is unused by GDB. */ +/* DNTT_TYPE_MODIFIER is unused by GDB. */ +/* DNTT_TYPE_GENFIELD is unused by GDB. */ +/* DNTT_TYPE_MEMACCESS is unused by GDB. */ +/* DNTT_TYPE_VFUNC is unused by GDB. */ +/* DNTT_TYPE_CLASS_SCOPE is unused by GDB. */ +/* DNTT_TYPE_FRIEND_CLASS is unused by GDB. */ +/* DNTT_TYPE_FRIEND_FUNC is unused by GDB. */ +/* DNTT_TYPE_CLASS unused by GDB. */ +/* DNTT_TYPE_TEMPLATE unused by GDB. */ +/* DNTT_TYPE_TEMPL_ARG is unused by GDB. */ +/* DNTT_TYPE_PTRMEM not used by GDB */ +/* DNTT_TYPE_INHERITANCE is unused by GDB. */ +/* DNTT_TYPE_OBJECT_ID is unused by GDB. */ +/* DNTT_TYPE_XREF is unused by GDB. */ +/* DNTT_TYPE_SA is unused by GDB. */ + +/* DNTT_TYPE_GENERIC and DNTT_TYPE_BLOCK are convience structures + so we can examine a DNTT entry in a generic fashion. */ +struct dntt_type_generic +{ + unsigned int word[9]; +}; + +struct dntt_type_block +{ + unsigned int extension: 1; + enum dntt_entry_type kind: 10; + unsigned int unused: 21; + unsigned int word[2]; +}; + +/* One entry in a DNTT (either the LNTT or GNTT). */ +union dnttentry +{ + struct dntt_type_srcfile dsfile; + struct dntt_type_module dmodule; + struct dntt_type_function dfunc; + struct dntt_type_function dentry; + struct dntt_type_begin dbegin; + struct dntt_type_end dend; + struct dntt_type_fparam dfparam; + struct dntt_type_svar dsvar; + struct dntt_type_dvar ddvar; + struct dntt_type_const dconst; + struct dntt_type_type dtype; + struct dntt_type_type dtag; + struct dntt_type_pointer dptr; + struct dntt_type_enum denum; + struct dntt_type_memenum dmember; + struct dntt_type_set dset; + struct dntt_type_subrange dsubr; + struct dntt_type_array darray; + struct dntt_type_struct dstruct; + struct dntt_type_union dunion; + struct dntt_type_field dfield; + struct dntt_type_functype dfunctype; + struct dntt_type_generic dgeneric; + struct dntt_type_block dblock; +}; + +/* Source line entry types. */ +enum slttype +{ + SLT_NORMAL, + SLT_SRCFILE, + SLT_MODULE, + SLT_FUNCTION, + SLT_ENTRY, + SLT_BEGIN, + SLT_END, + SLT_WITH, + SLT_EXIT, + SLT_ASSIST, + SLT_MARKER, +}; + +/* A normal source line entry. Simply provides a mapping of a source + line number to a code address. + + SLTDESC will always be SLT_NORMAL or SLT_EXIT. */ + +struct slt_normal +{ + enum slttype sltdesc: 4; + unsigned int line: 28; + CORE_ADDR address; +}; + +/* A special source line entry. Provides a mapping of a declaration + to a line number. These entries point back into the DNTT which + references them. */ + +struct slt_special +{ + enum slttype sltdesc: 4; + unsigned int line: 28; + dnttpointer backptr; +}; + +/* Used to describe nesting. + + For nested languages, an slt_assist entry must follow each SLT_FUNC + entry in the SLT. The address field will point forward to the + first slt_normal entry within the function's scope. */ + +struct slt_assist +{ + enum slttype sltdesc: 4; + unsigned int unused: 28; + sltpointer address; +}; + +struct slt_generic +{ + unsigned int word[2]; +}; + +union sltentry +{ + struct slt_normal snorm; + struct slt_special sspec; + struct slt_assist sasst; + struct slt_generic sgeneric; +}; + +#endif /* HP_SYMTAB_INCLUDED */ diff --git a/include/hpux-symtab.h b/include/hpux-symtab.h deleted file mode 100755 index 1e1813a..0000000 --- a/include/hpux-symtab.h +++ /dev/null @@ -1,2559 +0,0 @@ -/*************************************************************************** - * (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 */ |