1867 lines
63 KiB
C++
1867 lines
63 KiB
C++
/* 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, 1995, 1998, 1999, 2003 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
|
|
|
|
#ifndef HP_SYMTAB_INCLUDED
|
|
#define HP_SYMTAB_INCLUDED
|
|
|
|
/* General information:
|
|
|
|
This header file defines and describes only the data structures
|
|
necessary to read debug symbols produced by the HP C compiler,
|
|
HP ANSI C++ compiler, and HP FORTRAN 90 compiler using the
|
|
SOM object file format.
|
|
(For a full description of the debug format, ftp hpux-symtab.h from
|
|
jaguar.cs.utah.edu:/dist).
|
|
|
|
Additional notes (Rich Title)
|
|
This file is a reverse-engineered version of a file called
|
|
"symtab.h" which exists internal to HP's Computer Languages Organization
|
|
in /CLO/Components/DDE/obj/som/symtab.h. Because HP's version of
|
|
the file is copyrighted and not distributed, it is necessary for
|
|
GDB to use the reverse-engineered version that follows.
|
|
Work was done by Cygnus to reverse-engineer the C subset of symtab.h.
|
|
The WDB project has extended this to also contain the C++
|
|
symbol definitions, the F90 symbol definitions,
|
|
and the DOC (debugging-optimized-code) symbol definitions.
|
|
In some cases (the C++ symbol definitions)
|
|
I have added internal documentation here that
|
|
goes beyond what is supplied in HP's symtab.h. If we someday
|
|
unify these files again, the extra comments should be merged back
|
|
into HP's symtab.h.
|
|
|
|
-------------------------------------------------------------------
|
|
|
|
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_FORTRAN,
|
|
HP_LANGUAGE_F77 = HP_LANGUAGE_FORTRAN,
|
|
HP_LANGUAGE_PASCAL,
|
|
HP_LANGUAGE_MODCAL,
|
|
HP_LANGUAGE_COBOL,
|
|
HP_LANGUAGE_BASIC,
|
|
HP_LANGUAGE_ADA,
|
|
HP_LANGUAGE_CPLUSPLUS,
|
|
HP_LANGUAGE_DMPASCAL
|
|
};
|
|
|
|
|
|
/* 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, /* 0 */
|
|
HP_TYPE_BOOLEAN, /* 1 */
|
|
HP_TYPE_CHAR, /* 2 */
|
|
HP_TYPE_INT, /* 3 */
|
|
HP_TYPE_UNSIGNED_INT, /* 4 */
|
|
HP_TYPE_REAL, /* 5 */
|
|
HP_TYPE_COMPLEX, /* 6 */
|
|
HP_TYPE_STRING200, /* 7 */
|
|
HP_TYPE_LONGSTRING200, /* 8 */
|
|
HP_TYPE_TEXT, /* 9 */
|
|
HP_TYPE_FLABEL, /* 10 */
|
|
HP_TYPE_FTN_STRING_SPEC, /* 11 */
|
|
HP_TYPE_MOD_STRING_SPEC, /* 12 */
|
|
HP_TYPE_PACKED_DECIMAL, /* 13 */
|
|
HP_TYPE_REAL_3000, /* 14 */
|
|
HP_TYPE_MOD_STRING_3000, /* 15 */
|
|
HP_TYPE_ANYPOINTER, /* 16 */
|
|
HP_TYPE_GLOBAL_ANYPOINTER, /* 17 */
|
|
HP_TYPE_LOCAL_ANYPOINTER, /* 18 */
|
|
HP_TYPE_COMPLEXS3000, /* 19 */
|
|
HP_TYPE_FTN_STRING_S300_COMPAT, /* 20 */
|
|
HP_TYPE_FTN_STRING_VAX_COMPAT, /* 21 */
|
|
HP_TYPE_BOOLEAN_S300_COMPAT, /* 22 */
|
|
HP_TYPE_BOOLEAN_VAX_COMPAT, /* 23 */
|
|
HP_TYPE_WIDE_CHAR, /* 24 */
|
|
HP_TYPE_LONG, /* 25 */
|
|
HP_TYPE_UNSIGNED_LONG, /* 26 */
|
|
HP_TYPE_DOUBLE, /* 27 */
|
|
HP_TYPE_TEMPLATE_ARG, /* 28 */
|
|
HP_TYPE_VOID /* 29 */
|
|
};
|
|
|
|
/* 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;
|
|
unsigned int 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;
|
|
|
|
/* Index into DOC (= "Debugging Optimized Code") line table. */
|
|
#define LTNIL (-1)
|
|
typedef int ltpointer;
|
|
|
|
/* Index into context table. */
|
|
#define CTXTNIL (-1)
|
|
typedef int ctxtpointer;
|
|
|
|
/* 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_DYN_ARRAY_DESC,
|
|
DNTT_TYPE_DESC_SUBRANGE,
|
|
DNTT_TYPE_BEGIN_EXT,
|
|
DNTT_TYPE_INLN,
|
|
DNTT_TYPE_INLN_LIST,
|
|
DNTT_TYPE_ALIAS,
|
|
DNTT_TYPE_DOC_FUNCTION,
|
|
DNTT_TYPE_DOC_MEMFUNC,
|
|
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;
|
|
unsigned int kind: 10; /* DNTT_TYPE_SRCFILE */
|
|
unsigned int 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. A module indicates a compilation unit
|
|
for name-scoping purposes; in that regard there should be
|
|
a 1-1 correspondence between GDB "symtab"'s and MODULE symbol records.
|
|
|
|
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;
|
|
unsigned int kind: 10; /* DNTT_TYPE_MODULE */
|
|
unsigned int unused: 21;
|
|
vtpointer name;
|
|
vtpointer alias;
|
|
dnttpointer unused2;
|
|
sltpointer address;
|
|
};
|
|
|
|
/* DNTT_TYPE_FUNCTION,
|
|
DNTT_TYPE_ENTRY,
|
|
DNTT_TYPE_BLOCKDATA,
|
|
DNTT_TYPE_MEMFUNC:
|
|
|
|
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.
|
|
A DNTT_TYPE_BLOCKDATA symbol is emitted ...?
|
|
A DNTT_TYPE_MEMFUNC symbol is emitted for inlined member functions (C++).
|
|
|
|
Each of 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 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;
|
|
unsigned int kind: 10; /* DNTT_TYPE_FUNCTION,
|
|
DNTT_TYPE_ENTRY,
|
|
DNTT_TYPE_BLOCKDATA
|
|
or DNTT_TYPE_MEMFUNC */
|
|
unsigned int global: 1;
|
|
unsigned int 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;
|
|
unsigned int 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, DNTT_TYPE_WITH,
|
|
DNTT_TYPE_COMMON, DNTT_TYPE_BEGIN, and DNTT_TYPE_CLASS_SCOPE symbols.
|
|
|
|
ENDKIND describes what type of scope the DNTT_TYPE_END is closing
|
|
(one of the above 6 kinds).
|
|
|
|
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;
|
|
unsigned int kind: 10;
|
|
unsigned int 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;
|
|
unsigned int kind: 10;
|
|
unsigned int regparam: 1;
|
|
unsigned int indirect: 1;
|
|
unsigned int longaddr: 1;
|
|
unsigned int copyparam: 1;
|
|
unsigned int dflt: 1;
|
|
unsigned int doc_ranges: 1;
|
|
unsigned int misc_kind: 1;
|
|
unsigned int unused: 14;
|
|
vtpointer name;
|
|
CORE_ADDR 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;
|
|
unsigned int 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 unused1: 1;
|
|
unsigned int thread_specific: 1;
|
|
unsigned int unused2: 14;
|
|
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;
|
|
unsigned int 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;
|
|
unsigned int kind: 10;
|
|
unsigned int global: 1;
|
|
unsigned int indirect: 1;
|
|
unsigned int 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.
|
|
Also they are associated with C++ "class" tags, which implicitly have
|
|
the same name as the class type.
|
|
|
|
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;
|
|
unsigned int kind: 10; /* DNTT_TYPE_TYPEDEF or
|
|
DNTT_TYPE_TAGDEF. */
|
|
unsigned int global: 1;
|
|
unsigned int typeinfo: 1;
|
|
unsigned int unused: 19;
|
|
vtpointer name;
|
|
dnttpointer type; /* Underlying type, which for TAGDEF's may be
|
|
DNTT_TYPE_STRUCT, DNTT_TYPE_UNION,
|
|
DNTT_TYPE_ENUM, or DNTT_TYPE_CLASS.
|
|
For TYPEDEF's other underlying types
|
|
are also possible. */
|
|
};
|
|
|
|
/* 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;
|
|
unsigned int 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;
|
|
unsigned int 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;
|
|
unsigned int kind: 10;
|
|
unsigned int classmem: 1;
|
|
unsigned int unused: 20;
|
|
vtpointer name;
|
|
unsigned int value;
|
|
dnttpointer nextmem;
|
|
};
|
|
|
|
/* DNTT_TYPE_SET
|
|
|
|
Used to describe PASCAL "set" type.
|
|
|
|
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;
|
|
unsigned int kind: 10;
|
|
unsigned int declaration: 2;
|
|
unsigned int unused: 19;
|
|
dnttpointer subtype;
|
|
unsigned int bitlength;
|
|
};
|
|
|
|
/* DNTT_TYPE_SUBRANGE
|
|
|
|
Used to describe subrange type.
|
|
|
|
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
|
|
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;
|
|
unsigned int 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
|
|
|
|
Used to describe an array type.
|
|
|
|
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;
|
|
unsigned int 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;
|
|
unsigned int 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;
|
|
unsigned int 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
|
|
or C++ class.
|
|
|
|
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;
|
|
unsigned int 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_FUNCTYPE
|
|
|
|
I think this is used to describe a function type (e.g., would
|
|
be emitted as part of a function-pointer description).
|
|
|
|
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;
|
|
unsigned int 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 emitted by C++ to indicate "with" scoping semantics.
|
|
(Probably also emitted by PASCAL to support "with"...).
|
|
|
|
C++ example: Say "memfunc" is a method of class "c", and say
|
|
"m" is a data member of class "c". Then from within "memfunc",
|
|
it is legal to reference "m" directly (e.g. you don't have to
|
|
say "this->m". The symbol table indicates
|
|
this by emitting a DNTT_TYPE_WITH symbol within the function "memfunc",
|
|
pointing to the type symbol for class "c".
|
|
|
|
In GDB, this symbol record is unnecessary,
|
|
because GDB's symbol lookup algorithm
|
|
infers the "with" semantics when it sees a "this" argument to the member
|
|
function. So GDB can safely ignore the DNTT_TYPE_WITH record.
|
|
|
|
A DNTT_TYPE_WITH has a matching DNTT_TYPE_END symbol. */
|
|
|
|
struct dntt_type_with
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_WITH */
|
|
unsigned int addrtype: 2; /* 0 => STATTYPE */
|
|
/* 1 => DYNTYPE */
|
|
/* 2 => REGTYPE */
|
|
unsigned int indirect: 1; /* 1 => pointer to object */
|
|
unsigned int longaddr: 1; /* 1 => in long pointer space */
|
|
unsigned int nestlevel: 6; /* # of nesting levels back */
|
|
unsigned int doc_ranges: 1; /* 1 => location is range list */
|
|
unsigned int unused: 10;
|
|
long location; /* where stored (allocated) */
|
|
sltpointer address;
|
|
dnttpointer type; /* type of with expression */
|
|
vtpointer name; /* name of with expression */
|
|
unsigned long offset; /* byte offset from location */
|
|
};
|
|
|
|
/* DNTT_TYPE_COMMON is unsupported by GDB. */
|
|
/* A DNTT_TYPE_COMMON symbol must have a matching DNTT_TYPE_END symbol */
|
|
|
|
/* DNTT_TYPE_COBSTRUCT is unsupported by GDB. */
|
|
/* DNTT_TYPE_XREF is unsupported by GDB. */
|
|
/* DNTT_TYPE_SA is unsupported by GDB. */
|
|
/* DNTT_TYPE_MACRO is unsupported by GDB */
|
|
|
|
/* DNTT_TYPE_BLOCKDATA has the same structure as DNTT_TYPE_FUNCTION */
|
|
|
|
/* The following are the C++ specific SOM records */
|
|
|
|
/* The purpose of the DNTT_TYPE_CLASS_SCOPE is to bracket C++ methods
|
|
and indicate the method name belongs in the "class scope" rather
|
|
than in the module they are being defined in. For example:
|
|
|
|
class c {
|
|
...
|
|
void memfunc(); // member function
|
|
};
|
|
|
|
void c::memfunc() // definition of class c's "memfunc"
|
|
{
|
|
...
|
|
}
|
|
|
|
main()
|
|
{
|
|
...
|
|
}
|
|
|
|
In the above, the name "memfunc" is not directly visible from "main".
|
|
I.e., you have to say "break c::memfunc".
|
|
If it were a normal function (not a method), it would be visible
|
|
via the simple "break memfunc". Since "memfunc" otherwise looks
|
|
like a normal FUNCTION in the symbol table, the bracketing
|
|
CLASS_SCOPE is what is used to indicate it is really a method.
|
|
|
|
|
|
A DNTT_TYPE_CLASS_SCOPE symbol must have a matching DNTT_TYPE_END symbol. */
|
|
|
|
struct dntt_type_class_scope
|
|
{
|
|
unsigned int extension: 1; /* Always zero. */
|
|
unsigned int kind: 10; /* Always DNTT_TYPE_CLASS_SCOPE. */
|
|
unsigned int unused: 21;
|
|
sltpointer address ; /* Pointer to SLT entry. */
|
|
dnttpointer type ; /* Pointer to class type DNTT. */
|
|
};
|
|
|
|
/* C++ reference parameter.
|
|
The structure of this record is the same as DNTT_TYPE_POINTER -
|
|
refer to struct dntt_type_pointer. */
|
|
|
|
/* The next two describe C++ pointer-to-data-member type, and
|
|
pointer-to-member-function type, respectively.
|
|
DNTT_TYPE_PTRMEM and DNTT_TYPE_PTRMEMFUNC have the same structure. */
|
|
|
|
struct dntt_type_ptrmem
|
|
{
|
|
unsigned int extension: 1; /* Always zero. */
|
|
unsigned int kind: 10; /* Always DNTT_TYPE_PTRMEM. */
|
|
unsigned int unused: 21;
|
|
dnttpointer pointsto ; /* Pointer to class DNTT. */
|
|
dnttpointer memtype ; /* Type of member. */
|
|
};
|
|
|
|
struct dntt_type_ptrmemfunc
|
|
{
|
|
unsigned int extension: 1; /* Always zero. */
|
|
unsigned int kind: 10; /* Always DNTT_TYPE_PTRMEMFUNC. */
|
|
unsigned int unused: 21;
|
|
dnttpointer pointsto ; /* Pointer to class DNTT. */
|
|
dnttpointer memtype ; /* Type of member. */
|
|
};
|
|
|
|
/* The DNTT_TYPE_CLASS symbol is emitted to describe a class type.
|
|
"memberlist" points to a chained list of FIELD or GENFIELD records
|
|
indicating the class members. "parentlist" points to a chained list
|
|
of INHERITANCE records indicating classes from which we inherit
|
|
fields. */
|
|
|
|
struct dntt_type_class
|
|
{
|
|
unsigned int extension: 1; /* Always zero. */
|
|
unsigned int kind: 10; /* Always DNTT_TYPE_CLASS. */
|
|
unsigned int abstract: 1; /* Is this an abstract class? */
|
|
unsigned int class_decl: 2; /* 0=class,1=union,2=struct. */
|
|
unsigned int expansion: 1; /* 1=template expansion. */
|
|
unsigned int unused: 17;
|
|
dnttpointer memberlist ; /* Ptr to chain of [GEN]FIELDs. */
|
|
unsigned long vtbl_loc ; /* Offset in obj of ptr to vtbl. */
|
|
dnttpointer parentlist ; /* Ptr to K_INHERITANCE list. */
|
|
unsigned long bitlength ; /* Total at this level. */
|
|
dnttpointer identlist ; /* Ptr to chain of class ident's. */
|
|
dnttpointer friendlist ; /* Ptr to K_FRIEND list. */
|
|
dnttpointer templateptr ; /* Ptr to template. */
|
|
dnttpointer nextexp ; /* Ptr to next expansion. */
|
|
};
|
|
|
|
/* Class members are indicated via either the FIELD record (for
|
|
data members, same as for C struct fields), or by the GENFIELD record
|
|
(for member functions). */
|
|
|
|
struct dntt_type_genfield
|
|
{
|
|
unsigned int extension: 1; /* Always zero. */
|
|
unsigned int kind: 10; /* Always DNTT_TYPE_GENFIELD. */
|
|
unsigned int visibility: 2; /* Pub = 0, prot = 1, priv = 2. */
|
|
unsigned int a_union: 1; /* 1 => anonymous union member. */
|
|
unsigned int unused: 18;
|
|
dnttpointer field ; /* Pointer to field or qualifier. */
|
|
dnttpointer nextfield ; /* Pointer to next field. */
|
|
};
|
|
|
|
/* C++ virtual functions. */
|
|
|
|
struct dntt_type_vfunc
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_VFUNC */
|
|
unsigned int pure: 1; /* pure virtual function ? */
|
|
unsigned int unused: 20;
|
|
dnttpointer funcptr ; /* points to FUNCTION symbol */
|
|
unsigned long vtbl_offset ; /* offset into vtbl for virtual */
|
|
};
|
|
|
|
/* Not precisely sure what this is intended for - DDE ignores it. */
|
|
|
|
struct dntt_type_memaccess
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_MEMACCESS */
|
|
unsigned int unused: 21;
|
|
dnttpointer classptr ; /* pointer to base class */
|
|
dnttpointer field ; /* pointer field */
|
|
};
|
|
|
|
/* The DNTT_TYPE_INHERITANCE record describes derived classes.
|
|
In particular, the "parentlist" field of the CLASS record points
|
|
to a list of INHERITANCE records for classes from which we
|
|
inherit members. */
|
|
|
|
struct dntt_type_inheritance
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_INHERITANCE */
|
|
unsigned int Virtual: 1; /* virtual base class ? */
|
|
unsigned int visibility: 2; /* pub = 0, prot = 1, priv = 2 */
|
|
unsigned int unused: 18;
|
|
dnttpointer classname ; /* first parent class, if any */
|
|
unsigned long offset ; /* offset to start of base class */
|
|
dnttpointer next ; /* pointer to next K_INHERITANCE */
|
|
unsigned long future[2] ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* C++ "friend" classes ... */
|
|
|
|
struct dntt_type_friend_class
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_FRIEND_CLASS */
|
|
unsigned int unused: 21;
|
|
dnttpointer classptr ; /* pointer to class DNTT */
|
|
dnttpointer next ; /* next DNTT_FRIEND */
|
|
};
|
|
|
|
struct dntt_type_friend_func
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_FRIEND_FUNC */
|
|
unsigned int unused: 21;
|
|
dnttpointer funcptr ; /* pointer to function */
|
|
dnttpointer classptr ; /* pointer to class DNTT */
|
|
dnttpointer next ; /* next DNTT_FRIEND */
|
|
unsigned long future[2] ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* DDE appears to ignore the DNTT_TYPE_MODIFIER record.
|
|
It could perhaps be used to give better "ptype" output in GDB;
|
|
otherwise it is probably safe for GDB to ignore it also. */
|
|
|
|
struct dntt_type_modifier
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_MODIFIER */
|
|
unsigned int m_const: 1; /* const */
|
|
unsigned int m_static: 1; /* static */
|
|
unsigned int m_void: 1; /* void */
|
|
unsigned int m_volatile: 1; /* volatile */
|
|
unsigned int m_duplicate: 1; /* duplicate */
|
|
unsigned int unused: 16;
|
|
dnttpointer type ; /* subtype */
|
|
unsigned long future ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* I'm not sure what this was intended for - DDE ignores it. */
|
|
|
|
struct dntt_type_object_id
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_OBJECT_ID */
|
|
unsigned int indirect: 1; /* Is object_ident addr of addr? */
|
|
unsigned int unused: 20;
|
|
unsigned long object_ident ; /* object identifier */
|
|
unsigned long offset ; /* offset to start of base class */
|
|
dnttpointer next ; /* pointer to next K_OBJECT_ID */
|
|
unsigned long segoffset ; /* for linker fixup */
|
|
unsigned long future ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* No separate dntt_type_memfunc; same as dntt_type_func */
|
|
|
|
/* Symbol records to support templates. These only get used
|
|
in DDE's "describe" output (like GDB's "ptype"). */
|
|
|
|
/* The TEMPLATE record is the header for a template-class.
|
|
Like the CLASS record, a TEMPLATE record has a memberlist that
|
|
points to a list of template members. It also has an arglist
|
|
pointing to a list of TEMPLATE_ARG records. */
|
|
|
|
struct dntt_type_template
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_TEMPLATE */
|
|
unsigned int abstract: 1; /* is this an abstract class? */
|
|
unsigned int class_decl: 2; /* 0=class,1=union,2=struct */
|
|
unsigned int unused: 18;
|
|
dnttpointer memberlist ; /* ptr to chain of K_[GEN]FIELDs */
|
|
long unused2 ; /* offset in obj of ptr to vtbl */
|
|
dnttpointer parentlist ; /* ptr to K_INHERITANCE list */
|
|
unsigned long bitlength ; /* total at this level */
|
|
dnttpointer identlist ; /* ptr to chain of class ident's */
|
|
dnttpointer friendlist ; /* ptr to K_FRIEND list */
|
|
dnttpointer arglist ; /* ptr to argument list */
|
|
dnttpointer expansions ; /* ptr to expansion list */
|
|
};
|
|
|
|
/* Template-class arguments are a list of TEMPL_ARG records
|
|
chained together. The "name" field is the name of the formal.
|
|
E.g.:
|
|
|
|
template <class T> class q { ... };
|
|
|
|
Then "T" is the name of the formal argument. */
|
|
|
|
struct dntt_type_templ_arg
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_TEMPL_ARG */
|
|
unsigned int usagetype: 1; /* 0 type-name 1 expression */
|
|
unsigned int unused: 20;
|
|
vtpointer name ; /* name of argument */
|
|
dnttpointer type ; /* for non type arguments */
|
|
dnttpointer nextarg ; /* Next argument if any */
|
|
long future[2] ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* FUNC_TEMPLATE records are sort of like FUNCTION, but are emitted
|
|
for template member functions. E.g.,
|
|
|
|
template <class T> class q
|
|
{
|
|
...
|
|
void f();
|
|
...
|
|
};
|
|
|
|
Within the list of FIELDs/GENFIELDs defining the member list
|
|
of the template "q", "f" would appear as a FUNC_TEMPLATE.
|
|
We'll also see instances of FUNCTION "f" records for each
|
|
instantiation of the template. */
|
|
|
|
struct dntt_type_func_template
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_FUNC_TEMPLATE */
|
|
unsigned int public: 1; /* 1 => globally visible */
|
|
unsigned int language: 4; /* type of language */
|
|
unsigned int level: 5; /* nesting level (top level = 0)*/
|
|
unsigned int optimize: 2; /* level of optimization */
|
|
unsigned int varargs: 1; /* ellipses. Pascal/800 later */
|
|
unsigned int info: 4; /* lang-specific stuff; F_xxxx */
|
|
unsigned int inlined: 1;
|
|
unsigned int localloc: 1; /* 0 at top, 1 at end of block */
|
|
unsigned int unused: 2;
|
|
vtpointer name ; /* name of function */
|
|
vtpointer alias ; /* alternate name, if any */
|
|
dnttpointer firstparam ; /* first FPARAM, if any */
|
|
dnttpointer retval ; /* return type, if any */
|
|
dnttpointer arglist ; /* ptr to argument list */
|
|
};
|
|
|
|
/* LINK is apparently intended to link together function template
|
|
definitions with their instantiations. However, it is not clear
|
|
why this would be needed, except to provide the information on
|
|
a "ptype" command. And as far as I can tell, aCC does not
|
|
generate this record. */
|
|
|
|
struct dntt_type_link
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* always DNTT_TYPE_LINK */
|
|
unsigned int linkKind: 4; /* always LINK_UNKNOWN */
|
|
unsigned int unused: 17;
|
|
long future1 ; /* expansion */
|
|
dnttpointer ptr1 ; /* link from template */
|
|
dnttpointer ptr2 ; /* to expansion */
|
|
long future[2] ; /* padding to 3-word block end */
|
|
};
|
|
|
|
/* end of C++ specific SOM's. */
|
|
|
|
/* DNTT_TYPE_DYN_ARRAY_DESC is unused by GDB */
|
|
/* DNTT_TYPE_DESC_SUBRANGE is unused by GDB */
|
|
/* DNTT_TYPE_BEGIN_EXT is unused by GDB */
|
|
/* DNTT_TYPE_INLN is unused by GDB */
|
|
/* DNTT_TYPE_INLN_LIST is unused by GDB */
|
|
/* DNTT_TYPE_ALIAS is unused by GDB */
|
|
|
|
struct dntt_type_doc_function
|
|
{
|
|
unsigned int extension: 1; /* always zero */
|
|
unsigned int kind: 10; /* K_DOC_FUNCTION or */
|
|
/* K_DOC_MEMFUNC */
|
|
unsigned int global: 1; /* 1 => globally visible */
|
|
unsigned int language: 4; /* type of language */
|
|
unsigned int level: 5; /* nesting level (top level = 0)*/
|
|
unsigned int optimize: 2; /* level of optimization */
|
|
unsigned int varargs: 1; /* ellipses. Pascal/800 later */
|
|
unsigned int info: 4; /* lang-specific stuff; F_xxxx */
|
|
unsigned int inlined: 1;
|
|
unsigned int localloc: 1; /* 0 at top, 1 at end of block */
|
|
unsigned int expansion: 1; /* 1 = function expansion */
|
|
unsigned int doc_clone: 1;
|
|
vtpointer name; /* name of function */
|
|
vtpointer alias; /* alternate name, if any */
|
|
dnttpointer firstparam; /* first FPARAM, if any */
|
|
sltpointer address; /* code and text locations */
|
|
CORE_ADDR entryaddr; /* address of entry point */
|
|
dnttpointer retval; /* return type, if any */
|
|
CORE_ADDR lowaddr; /* lowest address of function */
|
|
CORE_ADDR hiaddr; /* highest address of function */
|
|
dnttpointer inline_list; /* pointer to first inline */
|
|
ltpointer lt_offset; /* start of frag/cp line table */
|
|
ctxtpointer ctxt_offset; /* start of context table for this routine */
|
|
};
|
|
|
|
/* DNTT_TYPE_DOC_MEMFUNC 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;
|
|
unsigned int kind: 10;
|
|
unsigned int unused: 21;
|
|
unsigned int word[2];
|
|
};
|
|
|
|
/* One entry in a DNTT (either the LNTT or GNTT).
|
|
This is a union of the above 60 or so structure definitions. */
|
|
|
|
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_with dwith;
|
|
struct dntt_type_function dblockdata;
|
|
struct dntt_type_class_scope dclass_scope;
|
|
struct dntt_type_pointer dreference;
|
|
struct dntt_type_ptrmem dptrmem;
|
|
struct dntt_type_ptrmemfunc dptrmemfunc;
|
|
struct dntt_type_class dclass;
|
|
struct dntt_type_genfield dgenfield;
|
|
struct dntt_type_vfunc dvfunc;
|
|
struct dntt_type_memaccess dmemaccess;
|
|
struct dntt_type_inheritance dinheritance;
|
|
struct dntt_type_friend_class dfriend_class;
|
|
struct dntt_type_friend_func dfriend_func;
|
|
struct dntt_type_modifier dmodifier;
|
|
struct dntt_type_object_id dobject_id;
|
|
struct dntt_type_template dtemplate;
|
|
struct dntt_type_templ_arg dtempl_arg;
|
|
struct dntt_type_func_template dfunc_template;
|
|
struct dntt_type_link dlink;
|
|
struct dntt_type_doc_function ddocfunc;
|
|
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,
|
|
SLT_CLASS_SCOPE,
|
|
SLT_INLN,
|
|
SLT_NORMAL_OFFSET,
|
|
};
|
|
|
|
/* 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
|
|
{
|
|
unsigned int sltdesc: 4;
|
|
unsigned int line: 28;
|
|
CORE_ADDR address;
|
|
};
|
|
|
|
struct slt_normal_off
|
|
{
|
|
unsigned int sltdesc: 4;
|
|
unsigned int offset: 6;
|
|
unsigned int line: 22;
|
|
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
|
|
{
|
|
unsigned int 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
|
|
{
|
|
unsigned int sltdesc: 4;
|
|
unsigned int unused: 28;
|
|
sltpointer address;
|
|
};
|
|
|
|
struct slt_generic
|
|
{
|
|
unsigned int word[2];
|
|
};
|
|
|
|
union sltentry
|
|
{
|
|
struct slt_normal snorm;
|
|
struct slt_normal_off snormoff;
|
|
struct slt_special sspec;
|
|
struct slt_assist sasst;
|
|
struct slt_generic sgeneric;
|
|
};
|
|
|
|
/* $LINES$ declarations
|
|
This is the line table used for optimized code, which is only present
|
|
in the new $PROGRAM_INFO$ debug space. */
|
|
|
|
#define DST_LN_ESCAPE_FLAG1 15
|
|
#define DST_LN_ESCAPE_FLAG2 14
|
|
#define DST_LN_CTX_SPEC1 13
|
|
#define DST_LN_CTX_SPEC2 12
|
|
|
|
/* Escape function codes: */
|
|
|
|
typedef enum
|
|
{
|
|
dst_ln_pad, /* pad byte */
|
|
dst_ln_escape_1, /* reserved */
|
|
dst_ln_dpc1_dln1, /* 1 byte line delta, 1 byte pc delta */
|
|
dst_ln_dpc2_dln2, /* 2 bytes line delta, 2 bytes pc delta */
|
|
dst_ln_pc4_ln4, /* 4 bytes ABSOLUTE line number, 4 bytes ABSOLUTE pc */
|
|
dst_ln_dpc0_dln1, /* 1 byte line delta, pc delta = 0 */
|
|
dst_ln_ln_off_1, /* statement escape, stmt # = 1 (2nd stmt on line) */
|
|
dst_ln_ln_off, /* statement escape, stmt # = next byte */
|
|
dst_ln_entry, /* entry escape, next byte is entry number */
|
|
dst_ln_exit, /* exit escape */
|
|
dst_ln_stmt_end, /* gap escape, 4 bytes pc delta */
|
|
dst_ln_stmt_cp, /* current stmt is a critical point */
|
|
dst_ln_escape_12, /* reserved */
|
|
dst_ln_escape_13, /* this is an exception site record */
|
|
dst_ln_nxt_byte, /* next byte contains the real escape code */
|
|
dst_ln_end, /* end escape, final entry follows */
|
|
dst_ln_escape1_END_OF_ENUM
|
|
}
|
|
dst_ln_escape1_t;
|
|
|
|
typedef enum
|
|
{
|
|
dst_ln_ctx_1, /* next byte describes context switch with 5-bit */
|
|
/* index into the image table and 3-bit run length. */
|
|
/* If run length is 0, end with another cxt specifier or ctx_end */
|
|
dst_ln_ctx_2, /* next 2 bytes switch context: 13 bit index, 3 bit run length */
|
|
dst_ln_ctx_4, /* next 4 bytes switch context: 29 bit index, 3 bit run length */
|
|
dst_ln_ctx_end, /* end current context */
|
|
dst_ln_col_run_1, /* next byte is column position of start of next statement, */
|
|
/* following byte is length of statement */
|
|
dst_ln_col_run_2, /* next 2 bytes is column position of start of next statement, */
|
|
/* following 2 bytes is length of statement */
|
|
dst_ln_init_base1, /* next 4 bytes are absolute PC, followed by 1 byte of line number */
|
|
dst_ln_init_base2, /* next 4 bytes are absolute PC, followed by 2 bytes of line number */
|
|
dst_ln_init_base3, /* next 4 bytes are absolute PC, followed by 3 bytes of line number */
|
|
dst_ln_escape2_END_OF_ENUM
|
|
}
|
|
dst_ln_escape2_t;
|
|
|
|
typedef union
|
|
{
|
|
struct
|
|
{
|
|
unsigned int pc_delta : 4; /* 4 bit pc delta */
|
|
int ln_delta : 4; /* 4 bit line number delta */
|
|
}
|
|
delta;
|
|
|
|
struct
|
|
{
|
|
unsigned int esc_flag : 4; /* alias for pc_delta */
|
|
unsigned int esc_code : 4; /* escape function code (dst_ln_escape1_t, or ...2_t */
|
|
}
|
|
esc;
|
|
|
|
struct
|
|
{
|
|
unsigned int esc_flag : 4; /* dst_ln_ctx_spec1, or dst_ln_ctx_spec2 */
|
|
unsigned int run_length : 2;
|
|
unsigned int ctx_index : 2; /* ...spec2 contains index; ...spec1, index - 4 */
|
|
}
|
|
ctx_spec;
|
|
|
|
char sdata; /* signed data byte */
|
|
unsigned char udata; /* unsigned data byte */
|
|
}
|
|
dst_ln_entry_t,
|
|
* dst_ln_entry_ptr_t;
|
|
|
|
/* Warning: although the above union occupies only 1 byte the compiler treats
|
|
it as having size 2 (the minimum size of a struct). Therefore a sequence of
|
|
dst_ln_entry_t's cannot be described as an array, and walking through such a
|
|
sequence requires convoluted code such as
|
|
ln_ptr = (dst_ln_entry_ptr_t) (char*) ln_ptr + 1
|
|
We regret the inconvenience. */
|
|
|
|
/* Structure for interpreting the byte following a dst_ln_ctx1 entry. */
|
|
typedef struct
|
|
{
|
|
unsigned int ctx1_index : 5; /* 5 bit index into context table */
|
|
unsigned int ctx1_run_length : 3; /* 3 bit run length */
|
|
} dst_ln_ctx1_t,
|
|
*dst_ln_ctx1_ptr_t;
|
|
|
|
/* Structure for interpreting the bytes following a dst_ln_ctx2 entry. */
|
|
typedef struct
|
|
{
|
|
unsigned int ctx2_index : 13; /* 13 bit index into context table */
|
|
unsigned int ctx2_run_length : 3; /* 3 bit run length */
|
|
} dst_ln_ctx2_t,
|
|
*dst_ln_ctx2_ptr_t;
|
|
|
|
/* Structure for interpreting the bytes following a dst_ln_ctx4 entry. */
|
|
typedef struct
|
|
{
|
|
unsigned int ctx4_index : 29; /* 29 bit index into context table */
|
|
unsigned int ctx4_run_length : 3; /* 3 bit run length */
|
|
} dst_ln_ctx4_t,
|
|
*dst_ln_ctx4_ptr_t;
|
|
|
|
|
|
/* PXDB definitions.
|
|
|
|
PXDB is a post-processor which takes the executable file
|
|
and massages the debug information so that the debugger may
|
|
start up and run more efficiently. Some of the tasks
|
|
performed by PXDB are:
|
|
|
|
o Remove duplicate global type and variable information
|
|
from the GNTT,
|
|
|
|
o Append the GNTT onto the end of the LNTT and place both
|
|
back in the LNTT section,
|
|
|
|
o Build quick look-up tables (description follows) for
|
|
files, procedures, modules, and paragraphs (for Cobol),
|
|
placing these in the GNTT section,
|
|
|
|
o Reconstruct the header appearing in the header section
|
|
to access this information.
|
|
|
|
The "quick look-up" tables are in the $GNTT$ sub-space, in
|
|
the following order:
|
|
|
|
Procedures -sorted by address
|
|
Source files -sorted by address (of the
|
|
generated code from routines)
|
|
Modules -sorted by address
|
|
Classes -<unsorted?>
|
|
Address Alias -sorted by index <?>
|
|
Object IDs -sorted by object identifier
|
|
|
|
Most quick entries have (0-based) indices into the LNTT tables to
|
|
the full entries for the item it describes.
|
|
|
|
The post-PXDB header is in the $HEADER$ sub-space. Alas, it
|
|
occurs in different forms, depending on the optimization level
|
|
in the compilation step and whether PXDB was run or not. The
|
|
worst part is the forms aren't self-describing, so we'll have
|
|
to grovel in the bits to figure out what kind we're looking at
|
|
(see hp_get_header in hp-psymtab-read.c). */
|
|
|
|
/* PXDB versions. */
|
|
|
|
#define PXDB_VERSION_CPLUSPLUS 1
|
|
#define PXDB_VERSION_7_4 2
|
|
#define PXDB_VERSION_CPP_30 3
|
|
#define PXDB_VERSION_DDE_3_2A 4
|
|
#define PXDB_VERSION_DDE_3_2 5
|
|
#define PXDB_VERSION_DDE_4_0 6
|
|
|
|
#define PXDB_VERSION_2_1 1
|
|
|
|
/* Header version for the case that there is no DOC info
|
|
but the executable has been processed by pxdb (the easy
|
|
case, from "cc -g"). */
|
|
|
|
typedef struct PXDB_struct
|
|
{
|
|
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 */
|
|
unsigned int pxdbed : 1; /* 1 => file has been preprocessed */
|
|
unsigned int bighdr : 1; /* 1 => this header contains 'time' word */
|
|
unsigned int sa_header : 1;/* 1 => created by SA version of pxdb */
|
|
/* used for version check in xdb */
|
|
unsigned int inlined: 1; /* one or more functions have been inlined */
|
|
unsigned int spare:12;
|
|
short version; /* pxdb header version */
|
|
int globals; /* index into the DNTT where GNTT begins */
|
|
unsigned int 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 */
|
|
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 */
|
|
} PXDB_header, *PXDB_header_ptr;
|
|
|
|
/* Header version for the case that there is no DOC info and the
|
|
executable has NOT been processed by pxdb. */
|
|
|
|
typedef struct XDB_header_struct
|
|
{
|
|
long gntt_length;
|
|
long lntt_length;
|
|
long slt_length;
|
|
long vt_length;
|
|
long xt_length;
|
|
} XDB_header;
|
|
|
|
/* Header version for the case that there is DOC info and the
|
|
executable has been processed by pxdb. */
|
|
|
|
typedef struct DOC_info_PXDB_header_struct
|
|
{
|
|
unsigned int xdb_header: 1; /* bit set if this is post-3.1 xdb */
|
|
unsigned int doc_header: 1; /* bit set if this is doc-style header */
|
|
unsigned int version: 8; /* version of pxdb see defines
|
|
PXDB_VERSION_* in this file. */
|
|
unsigned int reserved_for_flags: 16;/* for future use; -- must be
|
|
set to zero. */
|
|
unsigned int has_aux_pd_table: 1; /* $GNTT$ has aux PD table */
|
|
unsigned int has_expr_table: 1; /* space has $EXPR$ */
|
|
unsigned int has_range_table: 1; /* space has $RANGE$ */
|
|
unsigned int has_context_table: 1; /* space has $SRC_CTXT$ */
|
|
unsigned int has_lines_table: 1; /* space contains a $LINES$
|
|
subspace for line tables. */
|
|
unsigned int has_lt_offset_map: 1; /* space contains an lt_offset
|
|
subspace for line table mapping. */
|
|
/* The following fields are the same as those in the PXDB_header in $DEBUG$ */
|
|
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 */
|
|
unsigned int pxdbed : 1; /* 1 => file has been preprocessed */
|
|
unsigned int bighdr : 1; /* 1 => this header contains 'time' word */
|
|
unsigned int sa_header : 1;/* 1 => created by SA version of pxdb */
|
|
/* used for version check in xdb */
|
|
unsigned int inlined: 1; /* one or more functions have been inlined */
|
|
unsigned int spare : 28;
|
|
int globals; /* index into the DNTT where GNTT begins */
|
|
unsigned int 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 */
|
|
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 */
|
|
} DOC_info_PXDB_header;
|
|
|
|
/* Header version for the case that there is DOC info and the
|
|
executable has NOT been processed by pxdb. */
|
|
|
|
typedef struct DOC_info_header_struct
|
|
{
|
|
unsigned int xdb_header: 1; /* bit set if this is post-3.1 xdb */
|
|
unsigned int doc_header: 1; /* bit set if this is doc-style header*/
|
|
unsigned int version: 8; /* version of debug/header
|
|
format. For 10.0 the value
|
|
will be 1. For "Davis" the value is 2. */
|
|
unsigned int reserved_for_flags: 18; /* for future use; -- must be set to zero. */
|
|
unsigned int has_range_table: 1; /* space contains a $RANGE$ subspace for variable ranges. */
|
|
unsigned int has_context_table: 1; /* space contains a $CTXT$ subspace for context/inline table. */
|
|
unsigned int has_lines_table: 1; /* space contains a $LINES$ subspace for line tables. */
|
|
unsigned int has_lt_offset_map: 1; /* space contains an lt_offset subspace for line table mapping. */
|
|
|
|
long gntt_length; /* same as old header */
|
|
long lntt_length; /* same as old header */
|
|
long slt_length; /* same as old header */
|
|
long vt_length; /* same as old header */
|
|
long xt_length; /* same as old header */
|
|
long ctxt_length; /* present only if version >= 2 */
|
|
long range_length; /* present only if version >= 2 */
|
|
long expr_length; /* present only if version >= 2 */
|
|
|
|
} DOC_info_header;
|
|
|
|
typedef union GenericDebugHeader_union
|
|
{
|
|
PXDB_header no_doc;
|
|
DOC_info_PXDB_header doc;
|
|
XDB_header no_pxdb_no_doc;
|
|
DOC_info_header no_pxdb_doc;
|
|
} GenericDebugHeader;
|
|
|
|
|
|
/* Procedure Descriptor:
|
|
An element of the procedure quick look-up table. */
|
|
|
|
typedef struct quick_procedure
|
|
{
|
|
long isym; /* 0-based index of first symbol
|
|
for procedure in $LNTT$,
|
|
i.e. the procedure itself. */
|
|
CORE_ADDR adrStart; /* memory adr of start of proc */
|
|
CORE_ADDR adrEnd; /* memory adr of end of proc */
|
|
char *sbAlias; /* alias name of procedure */
|
|
char *sbProc; /* real name of procedure */
|
|
CORE_ADDR adrBp; /* address of entry breakpoint */
|
|
CORE_ADDR adrExitBp; /* address of exit breakpoint */
|
|
int icd; /* member of this class (index) */
|
|
unsigned int ipd; /* index of template for this */
|
|
/* function (index) */
|
|
unsigned int unused: 5;
|
|
unsigned int no_lt_offset: 1;/* no entry in lt_offset table */
|
|
unsigned int fTemplate: 1; /* function template */
|
|
unsigned int fExpansion: 1; /* function expansion */
|
|
unsigned int linked : 1; /* linked with other expansions */
|
|
unsigned int duplicate: 1; /* clone of another procedure */
|
|
unsigned int overloaded:1; /* overloaded function */
|
|
unsigned int member: 1; /* class member function */
|
|
unsigned int constructor:1; /* constructor function */
|
|
unsigned int destructor:1; /* destructor function */
|
|
unsigned int Static: 1; /* static function */
|
|
unsigned int Virtual: 1; /* virtual function */
|
|
unsigned int constant: 1; /* constant function */
|
|
unsigned int pure: 1; /* pure (virtual) function */
|
|
unsigned int language: 4; /* procedure's language */
|
|
unsigned int inlined: 1; /* function has been inlined */
|
|
unsigned int Operator: 1; /* operator function */
|
|
unsigned int stub: 1; /* bodyless function */
|
|
unsigned int optimize: 2; /* optimization level */
|
|
unsigned int level: 5; /* nesting level (top=0) */
|
|
} quick_procedure_entry, *quick_procedure_entry_ptr;
|
|
|
|
/* Source File Descriptor:
|
|
An element of the source file quick look-up table. */
|
|
|
|
typedef struct quick_source
|
|
{
|
|
long isym; /* 0-based index in $LNTT$ of
|
|
first symbol for this file. */
|
|
CORE_ADDR adrStart; /* mem adr of start of file's code */
|
|
CORE_ADDR adrEnd; /* mem adr of end of file's code */
|
|
char *sbFile; /* name of source file */
|
|
unsigned int fHasDecl: 1; /* do we have a .d file? */
|
|
unsigned int fWarned: 1; /* have warned about age problems? */
|
|
unsigned int fSrcfile: 1; /* 0 => include 1=> source */
|
|
unsigned short ilnMac; /* lines in file (0 if don't know) */
|
|
int ipd; /* 0-based index of first procedure
|
|
in this file, in the quick
|
|
look-up table of procedures. */
|
|
unsigned int *rgLn; /* line pointer array, if any */
|
|
} quick_file_entry, *quick_file_entry_ptr;
|
|
|
|
/* Module Descriptor:
|
|
An element of the module quick reference table. */
|
|
|
|
typedef struct quick_module
|
|
{
|
|
long isym; /* 0-based index of first
|
|
symbol for module. */
|
|
CORE_ADDR adrStart; /* adr of start of mod. */
|
|
CORE_ADDR adrEnd; /* adr of end of mod. */
|
|
char *sbAlias; /* alias name of module */
|
|
char *sbMod; /* real name of module */
|
|
unsigned int imports: 1; /* module have any imports? */
|
|
unsigned int vars_in_front: 1; /* module globals in front? */
|
|
unsigned int vars_in_gaps: 1; /* module globals in gaps? */
|
|
unsigned int language: 4; /* type of language */
|
|
unsigned int unused : 25;
|
|
unsigned int unused2; /* space for future stuff */
|
|
} quick_module_entry, *quick_module_entry_ptr;
|
|
|
|
/* Auxiliary Procedure Descriptor:
|
|
An element of the auxiliary procedure quick look-up table. */
|
|
|
|
typedef struct quick_aux_procedure
|
|
{
|
|
long isym_inln; /* start on inline list for proc */
|
|
long spare;
|
|
} quick_aux_procedure_entry, *quick_aux_procedure_entry_ptr;
|
|
|
|
/* Paragraph Descriptor:
|
|
An element of the paragraph quick look-up table. */
|
|
|
|
typedef struct quick_paragraph
|
|
{
|
|
long isym; /* first symbol for label (index) */
|
|
CORE_ADDR adrStart; /* memory adr of start of label */
|
|
CORE_ADDR adrEnd; /* memory adr of end of label */
|
|
char *sbLab; /* name of label */
|
|
unsigned int inst; /* Used in xdb to store inst @ bp */
|
|
unsigned int sect: 1; /* true = section, false = parag. */
|
|
unsigned int unused: 31; /* future use */
|
|
} quick_paragraph_entry, *quick_paragraph_entry_ptr;
|
|
|
|
/* Class Descriptor:
|
|
An element of the class quick look-up table. */
|
|
|
|
typedef struct quick_class
|
|
{
|
|
char *sbClass; /* name of class */
|
|
long isym; /* class symbol (tag) */
|
|
unsigned int type : 2; /* 0=class, 1=union, 2=struct */
|
|
unsigned int fTemplate : 1;/* class template */
|
|
unsigned int expansion : 1;/* template expansion */
|
|
unsigned int unused :28;
|
|
sltpointer lowscope; /* beginning of defined scope */
|
|
sltpointer hiscope; /* end of defined scope */
|
|
} quick_class_entry, *quick_class_entry_ptr;
|
|
|
|
/* Address Alias Entry
|
|
An element of the address alias quick look-up table. */
|
|
|
|
typedef struct quick_alias
|
|
{
|
|
CORE_ADDR low;
|
|
CORE_ADDR high;
|
|
int index;
|
|
unsigned int unused : 31;
|
|
unsigned int alternate : 1; /* alternate unnamed aliases? */
|
|
} quick_alias_entry, *quick_alias_entry_ptr;
|
|
|
|
/* Object Identification Entry
|
|
An element of the object identification quick look-up table. */
|
|
|
|
typedef struct quick_obj_ID
|
|
{
|
|
CORE_ADDR obj_ident; /* class identifier */
|
|
long isym; /* class symbol */
|
|
long offset; /* offset to object start */
|
|
} quick_obj_ID_entry, *quick_obj_ID_entry_ptr;
|
|
|
|
#endif /* HP_SYMTAB_INCLUDED */
|