include/hp-symtab.h

   1 /* Definitions and structures for reading debug symbols from the
   2    native HP C compiler.
   3
   4    Written by the Center for Software Science at the University of Utah
   5    and by Cygnus Support.
   6
   7    Copyright 1994, 1995, 1998, 1999 Free Software Foundation, Inc.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #ifndef HP_SYMTAB_INCLUDED
  24 #define HP_SYMTAB_INCLUDED
  25
  26 /* General information:
  27
  28    This header file defines and describes only the data structures
  29    necessary to read debug symbols produced by the HP C compiler,
  30    HP ANSI C++ compiler, and HP FORTRAN 90 compiler using the
  31    SOM object file format.
  32    (For a full description of the debug format, ftp hpux-symtab.h from
  33    jaguar.cs.utah.edu:/dist).
  34
  35    Additional notes (Rich Title)
  36    This file is a reverse-engineered version of a file called
  37    "symtab.h" which exists internal to HP's Computer Languages Organization
  38    in /CLO/Components/DDE/obj/som/symtab.h. Because HP's version of
  39    the file is copyrighted and not distributed, it is necessary for
  40    GDB to use the reverse-engineered version that follows.
  41    Work was done by Cygnus to reverse-engineer the C subset of symtab.h.
  42    The WDB project has extended this to also contain the C++
  43    symbol definitions, the F90 symbol definitions,
  44    and the DOC (debugging-optimized-code) symbol definitions.
  45    In some cases (the C++ symbol definitions)
  46    I have added internal documentation here that
  47    goes beyond what is supplied in HP's symtab.h. If we someday
  48    unify these files again, the extra comments should be merged back
  49    into HP's symtab.h.
  50
  51    -------------------------------------------------------------------
  52
  53    Debug symbols are contained entirely within an unloadable space called
  54    $DEBUG$.  $DEBUG$ contains several subspaces which group related
  55    debug symbols.
  56
  57    $GNTT$ contains information for global variables, types and contants.
  58
  59    $LNTT$ contains information for procedures (including nesting), scoping
  60    information, local variables, types, and constants.
  61
  62    $SLT$ contains source line information so that code addresses may be
  63    mapped to source lines.
  64
  65    $VT$ contains various strings and constants for named objects (variables,
  66    typedefs, functions, etc).  Strings are stored as null-terminated character
  67    lists.  Constants always begin on word boundaries.  The first byte of
  68    the VT must be zero (a null string).
  69
  70    $XT$ is not currently used by GDB.
  71
  72    Many structures within the subspaces point to other structures within
  73    the same subspace, or to structures within a different subspace.  These
  74    pointers are represented as a structure index from the beginning of
  75    the appropriate subspace.  */
  76
  77 /* Used to describe where a constant is stored.  */
  78 enum location_type
  79 {
  80   LOCATION_IMMEDIATE,
  81   LOCATION_PTR,
  82   LOCATION_VT,
  83 };
  84
  85 /* Languages supported by this debug format.  Within the data structures
  86    this type is limited to 4 bits for a maximum of 16 languages.  */
  87 enum hp_language
  88 {
  89   HP_LANGUAGE_UNKNOWN,
  90   HP_LANGUAGE_C,
  91   HP_LANGUAGE_FORTRAN,
  92   HP_LANGUAGE_F77 = HP_LANGUAGE_FORTRAN,
  93   HP_LANGUAGE_PASCAL,
  94   HP_LANGUAGE_MODCAL,
  95   HP_LANGUAGE_COBOL,
  96   HP_LANGUAGE_BASIC,
  97   HP_LANGUAGE_ADA,
  98   HP_LANGUAGE_CPLUSPLUS,
  99   HP_LANGUAGE_DMPASCAL
 100 };
 101
 102
 103 /* Basic data types available in this debug format.  Within the data
 104    structures this type is limited to 5 bits for a maximum of 32 basic
 105    data types.  */
 106 enum hp_type
 107 {
 108   HP_TYPE_UNDEFINED, /* 0 */
 109   HP_TYPE_BOOLEAN, /* 1 */
 110   HP_TYPE_CHAR, /* 2 */
 111   HP_TYPE_INT, /* 3 */
 112   HP_TYPE_UNSIGNED_INT, /* 4 */
 113   HP_TYPE_REAL, /* 5 */
 114   HP_TYPE_COMPLEX, /* 6 */
 115   HP_TYPE_STRING200, /* 7 */
 116   HP_TYPE_LONGSTRING200, /* 8 */
 117   HP_TYPE_TEXT, /* 9 */
 118   HP_TYPE_FLABEL, /* 10 */
 119   HP_TYPE_FTN_STRING_SPEC, /* 11 */
 120   HP_TYPE_MOD_STRING_SPEC, /* 12 */
 121   HP_TYPE_PACKED_DECIMAL, /* 13 */
 122   HP_TYPE_REAL_3000, /* 14 */
 123   HP_TYPE_MOD_STRING_3000, /* 15 */
 124   HP_TYPE_ANYPOINTER, /* 16 */
 125   HP_TYPE_GLOBAL_ANYPOINTER, /* 17 */
 126   HP_TYPE_LOCAL_ANYPOINTER, /* 18 */
 127   HP_TYPE_COMPLEXS3000, /* 19 */
 128   HP_TYPE_FTN_STRING_S300_COMPAT, /* 20 */
 129   HP_TYPE_FTN_STRING_VAX_COMPAT, /* 21 */
 130   HP_TYPE_BOOLEAN_S300_COMPAT, /* 22 */
 131   HP_TYPE_BOOLEAN_VAX_COMPAT, /* 23 */
 132   HP_TYPE_WIDE_CHAR, /* 24 */
 133   HP_TYPE_LONG, /* 25 */
 134   HP_TYPE_UNSIGNED_LONG, /* 26 */
 135   HP_TYPE_DOUBLE, /* 27 */
 136   HP_TYPE_TEMPLATE_ARG, /* 28 */
 137   HP_TYPE_VOID /* 29 */
 138 };
 139
 140 /* An immediate name and type table entry.
 141
 142    extension and immediate will always be one.
 143    global will always be zero.
 144    hp_type is the basic type this entry describes.
 145    bitlength is the length in bits for the basic type.  */
 146 struct dnttp_immediate
 147 {
 148   unsigned int extension:       1;
 149   unsigned int immediate:       1;
 150   unsigned int global:          1;
 151   unsigned int type:            5;
 152   unsigned int bitlength:       24;
 153 };
 154
 155 /* A nonimmediate name and type table entry.
 156
 157    extension will always be one.
 158    immediate will always be zero.
 159    if global is zero, this entry points into the LNTT
 160    if global is one, this entry points into the GNTT
 161    index is the index within the GNTT or LNTT for this entry.  */
 162 struct dnttp_nonimmediate
 163 {
 164   unsigned int extension:       1;
 165   unsigned int immediate:       1;
 166   unsigned int global:          1;
 167   unsigned int index:           29;
 168 };
 169
 170 /* A pointer to an entry in the GNTT and LNTT tables.  It has two
 171    forms depending on the type being described.
 172
 173    The immediate form is used for simple entries and is one
 174    word.
 175
 176    The nonimmediate form is used for complex entries and contains
 177    an index into the LNTT or GNTT which describes the entire type.
 178
 179    If a dnttpointer is -1, then it is a NIL entry.  */
 180
 181 #define DNTTNIL (-1)
 182 typedef union dnttpointer
 183 {
 184   struct dnttp_immediate    dntti;
 185   struct dnttp_nonimmediate dnttp;
 186   int word;
 187 } dnttpointer;
 188
 189 /* An index into the source line table.  As with dnttpointers, a sltpointer
 190    of -1 indicates a NIL entry.  */
 191 #define SLTNIL (-1)
 192 typedef int sltpointer;
 193
 194 /* Index into DOC (= "Debugging Optimized Code") line table */
 195 #define LTNIL (-1)
 196 typedef int ltpointer;
 197
 198 /* Index into context table */
 199 #define CTXTNIL (-1)
 200 typedef int ctxtpointer;
 201
 202 /* Unsigned byte offset into the VT.  */
 203 typedef unsigned int vtpointer;
 204
 205 /* A DNTT entry (used within the GNTT and LNTT).
 206
 207    DNTT entries are variable sized objects, but are always a multiple
 208    of 3 words (we call each group of 3 words a "block").
 209
 210    The first bit in each block is an extension bit.  This bit is zero
 211    for the first block of a DNTT entry.  If the entry requires more
 212    than one block, then this bit is set to one in all blocks after
 213    the first one.  */
 214
 215 /* Each DNTT entry describes a particular debug symbol (beginning of
 216    a source file, a function, variables, structures, etc.
 217
 218    The type of the DNTT entry is stored in the "kind" field within the
 219    DNTT entry itself.  */
 220
 221 enum dntt_entry_type
 222 {
 223   DNTT_TYPE_NIL = -1,
 224   DNTT_TYPE_SRCFILE,
 225   DNTT_TYPE_MODULE,
 226   DNTT_TYPE_FUNCTION,
 227   DNTT_TYPE_ENTRY,
 228   DNTT_TYPE_BEGIN,
 229   DNTT_TYPE_END,
 230   DNTT_TYPE_IMPORT,
 231   DNTT_TYPE_LABEL,
 232   DNTT_TYPE_FPARAM,
 233   DNTT_TYPE_SVAR,
 234   DNTT_TYPE_DVAR,
 235   DNTT_TYPE_HOLE1,
 236   DNTT_TYPE_CONST,
 237   DNTT_TYPE_TYPEDEF,
 238   DNTT_TYPE_TAGDEF,
 239   DNTT_TYPE_POINTER,
 240   DNTT_TYPE_ENUM,
 241   DNTT_TYPE_MEMENUM,
 242   DNTT_TYPE_SET,
 243   DNTT_TYPE_SUBRANGE,
 244   DNTT_TYPE_ARRAY,
 245   DNTT_TYPE_STRUCT,
 246   DNTT_TYPE_UNION,
 247   DNTT_TYPE_FIELD,
 248   DNTT_TYPE_VARIANT,
 249   DNTT_TYPE_FILE,
 250   DNTT_TYPE_FUNCTYPE,
 251   DNTT_TYPE_WITH,
 252   DNTT_TYPE_COMMON,
 253   DNTT_TYPE_COBSTRUCT,
 254   DNTT_TYPE_XREF,
 255   DNTT_TYPE_SA,
 256   DNTT_TYPE_MACRO,
 257   DNTT_TYPE_BLOCKDATA,
 258   DNTT_TYPE_CLASS_SCOPE,
 259   DNTT_TYPE_REFERENCE,
 260   DNTT_TYPE_PTRMEM,
 261   DNTT_TYPE_PTRMEMFUNC,
 262   DNTT_TYPE_CLASS,
 263   DNTT_TYPE_GENFIELD,
 264   DNTT_TYPE_VFUNC,
 265   DNTT_TYPE_MEMACCESS,
 266   DNTT_TYPE_INHERITANCE,
 267   DNTT_TYPE_FRIEND_CLASS,
 268   DNTT_TYPE_FRIEND_FUNC,
 269   DNTT_TYPE_MODIFIER,
 270   DNTT_TYPE_OBJECT_ID,
 271   DNTT_TYPE_MEMFUNC,
 272   DNTT_TYPE_TEMPLATE,
 273   DNTT_TYPE_TEMPLATE_ARG,
 274   DNTT_TYPE_FUNC_TEMPLATE,
 275   DNTT_TYPE_LINK,
 276   DNTT_TYPE_DYN_ARRAY_DESC,
 277   DNTT_TYPE_DESC_SUBRANGE,
 278   DNTT_TYPE_BEGIN_EXT,
 279   DNTT_TYPE_INLN,
 280   DNTT_TYPE_INLN_LIST,
 281   DNTT_TYPE_ALIAS,
 282   DNTT_TYPE_DOC_FUNCTION,
 283   DNTT_TYPE_DOC_MEMFUNC,
 284   DNTT_TYPE_MAX
 285 };
 286
 287 /* DNTT_TYPE_SRCFILE:
 288
 289    One DNTT_TYPE_SRCFILE symbol is output for the start of each source
 290    file and at the begin and end of an included file.  A DNTT_TYPE_SRCFILE
 291    entry is also output before each DNTT_TYPE_FUNC symbol so that debuggers
 292    can determine what file a function was defined in.
 293
 294    LANGUAGE describes the source file's language.
 295
 296    NAME points to an VT entry providing the source file's name.
 297
 298    Note the name used for DNTT_TYPE_SRCFILE entries are exactly as seen
 299    by the compiler (ie they may be relative or absolute).  C include files
 300    via <> inclusion must use absolute paths.
 301
 302    ADDRESS points to an SLT entry from which line number and code locations
 303    may be determined.  */
 304
 305 struct dntt_type_srcfile
 306 {
 307   unsigned int extension:       1;
 308   unsigned int kind:            10;    /* DNTT_TYPE_SRCFILE */
 309   unsigned int language:        4;
 310   unsigned int unused:          17;
 311   vtpointer name;
 312   sltpointer address;
 313 };
 314
 315 /* DNTT_TYPE_MODULE:
 316
 317    A DNTT_TYPE_MODULE symbol is emitted for the start of a pascal
 318    module or C source file. A module indicates a compilation unit
 319    for name-scoping purposes; in that regard there should be
 320    a 1-1 correspondence between GDB "symtab"'s and MODULE symbol records.
 321
 322    Each DNTT_TYPE_MODULE must have an associated DNTT_TYPE_END symbol.
 323
 324    NAME points to a VT entry providing the module's name.  Note C
 325    source files are considered nameless modules.
 326
 327    ALIAS point to a VT entry providing a secondary name.
 328
 329    ADDRESS points to an SLT entry from which line number and code locations
 330    may be determined.  */
 331
 332 struct dntt_type_module
 333 {
 334   unsigned int extension:       1;
 335   unsigned int kind:            10;     /* DNTT_TYPE_MODULE */
 336   unsigned int unused:          21;
 337   vtpointer name;
 338   vtpointer alias;
 339   dnttpointer unused2;
 340   sltpointer address;
 341 };
 342
 343 /* DNTT_TYPE_FUNCTION,
 344    DNTT_TYPE_ENTRY,
 345    DNTT_TYPE_BLOCKDATA,
 346    DNTT_TYPE_MEMFUNC:
 347
 348    A DNTT_TYPE_FUNCTION symbol is emitted for each function definition;
 349    a DNTT_TYPE_ENTRY symbols is used for secondary entry points.  Both
 350    symbols used the dntt_type_function structure.
 351    A DNTT_TYPE_BLOCKDATA symbol is emitted ...?
 352    A DNTT_TYPE_MEMFUNC symbol is emitted for inlined member functions (C++).
 353
 354    Each of DNTT_TYPE_FUNCTION must have a matching DNTT_TYPE_END.
 355
 356    GLOBAL is nonzero if the function has global scope.
 357
 358    LANGUAGE describes the function's source language.
 359
 360    OPT_LEVEL describes the optimization level the function was compiled
 361    with.
 362
 363    VARARGS is nonzero if the function uses varargs.
 364
 365    NAME points to a VT entry providing the function's name.
 366
 367    ALIAS points to a VT entry providing a secondary name for the function.
 368
 369    FIRSTPARAM points to a LNTT entry which describes the parameter list.
 370
 371    ADDRESS points to an SLT entry from which line number and code locations
 372    may be determined.
 373
 374    ENTRYADDR is the memory address corresponding the the function's entry point
 375
 376    RETVAL points to a LNTT entry describing the function's return value.
 377
 378    LOWADDR is the lowest memory address associated with this function.
 379
 380    HIADDR is the highest memory address associated with this function.  */
 381
 382 struct dntt_type_function
 383 {
 384   unsigned int extension:       1;
 385   unsigned int kind:            10;     /* DNTT_TYPE_FUNCTION,
 386                                            DNTT_TYPE_ENTRY,
 387                                            DNTT_TYPE_BLOCKDATA
 388                                            or DNTT_TYPE_MEMFUNC */
 389   unsigned int global:          1;
 390   unsigned int language:        4;
 391   unsigned int nest_level:      5;
 392   unsigned int opt_level:       2;
 393   unsigned int varargs:         1;
 394   unsigned int lang_info:       4;
 395   unsigned int inlined:         1;
 396   unsigned int localalloc:      1;
 397   unsigned int expansion:       1;
 398   unsigned int unused:          1;
 399   vtpointer name;
 400   vtpointer alias;
 401   dnttpointer firstparam;
 402   sltpointer address;
 403   CORE_ADDR entryaddr;
 404   dnttpointer retval;
 405   CORE_ADDR lowaddr;
 406   CORE_ADDR hiaddr;
 407 };
 408
 409 /* DNTT_TYPE_BEGIN:
 410
 411    A DNTT_TYPE_BEGIN symbol is emitted to begin a new nested scope.
 412    Every DNTT_TYPE_BEGIN symbol must have a matching DNTT_TYPE_END symbol.
 413
 414    CLASSFLAG is nonzero if this is the beginning of a c++ class definition.
 415
 416    ADDRESS points to an SLT entry from which line number and code locations
 417    may be determined.  */
 418
 419 struct dntt_type_begin
 420 {
 421   unsigned int extension:       1;
 422   unsigned int kind:            10;
 423   unsigned int classflag:       1;
 424   unsigned int unused:          20;
 425   sltpointer address;
 426 };
 427
 428 /* DNTT_TYPE_END:
 429
 430    A DNTT_TYPE_END symbol is emitted when closing a scope started by
 431    a DNTT_TYPE_MODULE, DNTT_TYPE_FUNCTION, DNTT_TYPE_WITH,
 432    DNTT_TYPE_COMMON, DNTT_TYPE_BEGIN, and DNTT_TYPE_CLASS_SCOPE symbols.
 433
 434    ENDKIND describes what type of scope the DNTT_TYPE_END is closing
 435    (one of the above 6 kinds).
 436
 437    CLASSFLAG is nonzero if this is the end of a c++ class definition.
 438
 439    ADDRESS points to an SLT entry from which line number and code locations
 440    may be determined.
 441
 442    BEGINSCOPE points to the LNTT entry which opened the scope.  */
 443
 444 struct dntt_type_end
 445 {
 446   unsigned int extension:       1;
 447   unsigned int kind:            10;
 448   unsigned int endkind:         10;
 449   unsigned int classflag:       1;
 450   unsigned int unused:          10;
 451   sltpointer address;
 452   dnttpointer beginscope;
 453 };
 454
 455 /* DNTT_TYPE_IMPORT is unused by GDB.  */
 456 /* DNTT_TYPE_LABEL is unused by GDB.  */
 457
 458 /* DNTT_TYPE_FPARAM:
 459
 460    A DNTT_TYPE_FPARAM symbol is emitted for a function argument.  When
 461    chained together the symbols represent an argument list for a function.
 462
 463    REGPARAM is nonzero if this parameter was passed in a register.
 464
 465    INDIRECT is nonzero if this parameter is a pointer to the parameter
 466    (pass by reference or pass by value for large items).
 467
 468    LONGADDR is nonzero if the parameter is a 64bit pointer.
 469
 470    NAME is a pointer into the VT for the parameter's name.
 471
 472    LOCATION describes where the parameter is stored.  Depending on the
 473    parameter type LOCATION could be a register number, or an offset
 474    from the stack pointer.
 475
 476    TYPE points to a NTT entry describing the type of this parameter.
 477
 478    NEXTPARAM points to the LNTT entry describing the next parameter.  */
 479
 480 struct dntt_type_fparam
 481 {
 482   unsigned int extension:       1;
 483   unsigned int kind:            10;
 484   unsigned int regparam:        1;
 485   unsigned int indirect:        1;
 486   unsigned int longaddr:        1;
 487   unsigned int copyparam:       1;
 488   unsigned int dflt:            1;
 489   unsigned int doc_ranges:      1;
 490   unsigned int misc_kind:       1;
 491   unsigned int unused:          14;
 492   vtpointer name;
 493   CORE_ADDR location;
 494   dnttpointer type;
 495   dnttpointer nextparam;
 496   int misc;
 497 };
 498
 499 /* DNTT_TYPE_SVAR:
 500
 501    A DNTT_TYPE_SVAR is emitted to describe a variable in static storage.
 502
 503    GLOBAL is nonzero if the variable has global scope.
 504
 505    INDIRECT is nonzero if the variable is a pointer to an object.
 506
 507    LONGADDR is nonzero if the variable is in long pointer space.
 508
 509    STATICMEM is nonzero if the variable is a member of a class.
 510
 511    A_UNION is nonzero if the variable is an anonymous union member.
 512
 513    NAME is a pointer into the VT for the variable's name.
 514
 515    LOCATION provides the memory address for the variable.
 516
 517    TYPE is a pointer into either the GNTT or LNTT which describes
 518    the type of this variable.  */
 519
 520 struct dntt_type_svar
 521 {
 522   unsigned int extension:       1;
 523   unsigned int kind:            10;
 524   unsigned int global:          1;
 525   unsigned int indirect:        1;
 526   unsigned int longaddr:        1;
 527   unsigned int staticmem:       1;
 528   unsigned int a_union:         1;
 529   unsigned int unused1:         1;
 530   unsigned int thread_specific: 1;
 531   unsigned int unused2:         14;
 532   vtpointer name;
 533   CORE_ADDR location;
 534   dnttpointer type;
 535   unsigned int offset;
 536   unsigned int displacement;
 537 };
 538
 539 /* DNTT_TYPE_DVAR:
 540
 541    A DNTT_TYPE_DVAR is emitted to describe automatic variables and variables
 542    held in registers.
 543
 544    GLOBAL is nonzero if the variable has global scope.
 545
 546    INDIRECT is nonzero if the variable is a pointer to an object.
 547
 548    REGVAR is nonzero if the variable is in a register.
 549
 550    A_UNION is nonzero if the variable is an anonymous union member.
 551
 552    NAME is a pointer into the VT for the variable's name.
 553
 554    LOCATION provides the memory address or register number for the variable.
 555
 556    TYPE is a pointer into either the GNTT or LNTT which describes
 557    the type of this variable.  */
 558
 559 struct dntt_type_dvar
 560 {
 561   unsigned int extension:       1;
 562   unsigned int kind:            10;
 563   unsigned int global:          1;
 564   unsigned int indirect:        1;
 565   unsigned int regvar:          1;
 566   unsigned int a_union:         1;
 567   unsigned int unused:          17;
 568   vtpointer name;
 569   int location;
 570   dnttpointer type;
 571   unsigned int offset;
 572 };
 573
 574 /* DNTT_TYPE_CONST:
 575
 576    A DNTT_TYPE_CONST symbol is emitted for program constants.
 577
 578    GLOBAL is nonzero if the constant has global scope.
 579
 580    INDIRECT is nonzero if the constant is a pointer to an object.
 581
 582    LOCATION_TYPE describes where to find the constant's value
 583    (in the VT, memory, or embedded in an instruction).
 584
 585    CLASSMEM is nonzero if the constant is a member of a class.
 586
 587    NAME is a pointer into the VT for the constant's name.
 588
 589    LOCATION provides the memory address, register number or pointer
 590    into the VT for the constant's value.
 591
 592    TYPE is a pointer into either the GNTT or LNTT which describes
 593    the type of this variable.  */
 594
 595 struct dntt_type_const
 596 {
 597   unsigned int extension:       1;
 598   unsigned int kind:            10;
 599   unsigned int global:          1;
 600   unsigned int indirect:        1;
 601   unsigned int location_type:   3;
 602   unsigned int classmem:        1;
 603   unsigned int unused:          15;
 604   vtpointer name;
 605   CORE_ADDR location;
 606   dnttpointer type;
 607   unsigned int offset;
 608   unsigned int displacement;
 609 };
 610
 611 /* DNTT_TYPE_TYPEDEF and DNTT_TYPE_TAGDEF:
 612
 613    The same structure is used to describe typedefs and tagdefs.
 614
 615    DNTT_TYPE_TYPEDEFS are associated with C "typedefs".
 616
 617    DNTT_TYPE_TAGDEFs are associated with C "struct", "union", and "enum"
 618    tags, which may have the same name as a typedef in the same scope.
 619    Also they are associated with C++ "class" tags, which implicitly have
 620    the same name as the class type.
 621
 622    GLOBAL is nonzero if the typedef/tagdef has global scope.
 623
 624    TYPEINFO is used to determine if full type information is available
 625    for a tag.  (usually 1, but can be zero for opaque types in C).
 626
 627    NAME is a pointer into the VT for the constant's name.
 628
 629    TYPE points to the underlying type for the typedef/tagdef in the
 630    GNTT or LNTT.  */
 631
 632 struct dntt_type_type
 633 {
 634   unsigned int extension:       1;
 635   unsigned int kind:            10;    /* DNTT_TYPE_TYPEDEF or
 636                                           DNTT_TYPE_TAGDEF
 637                                         */
 638   unsigned int global:          1;
 639   unsigned int typeinfo:        1;
 640   unsigned int unused:          19;
 641   vtpointer name;
 642   dnttpointer type;                    /* Underlying type, which for TAGDEF's may be
 643                                         * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION,
 644                                         * DNTT_TYPE_ENUM, or DNTT_TYPE_CLASS.
 645                                         * For TYPEDEF's other underlying types
 646                                         * are also possible.
 647                                         */
 648 };
 649
 650 /* DNTT_TYPE_POINTER:
 651
 652    Used to describe a pointer to an underlying type.
 653
 654    POINTSTO is a pointer into the GNTT or LNTT for the type which this
 655    pointer points to.
 656
 657    BITLENGTH is the length of the pointer (not the underlying type). */
 658
 659 struct dntt_type_pointer
 660 {
 661   unsigned int extension:       1;
 662   unsigned int kind:            10;
 663   unsigned int unused:          21;
 664   dnttpointer pointsto;
 665   unsigned int bitlength;
 666 };
 667
 668
 669 /* DNTT_TYPE_ENUM:
 670
 671    Used to describe enumerated types.
 672
 673    FIRSTMEM is a pointer to a DNTT_TYPE_MEMENUM in the GNTT/LNTT which
 674    describes the first member (and contains a pointer to the chain of
 675    members).
 676
 677    BITLENGTH is the number of bits used to hold the values of the enum's
 678    members.  */
 679
 680 struct dntt_type_enum
 681 {
 682   unsigned int extension:       1;
 683   unsigned int kind:    10;
 684   unsigned int unused:          21;
 685   dnttpointer firstmem;
 686   unsigned int bitlength;
 687 };
 688
 689 /* DNTT_TYPE_MEMENUM
 690
 691    Used to describe members of an enumerated type.
 692
 693    CLASSMEM is nonzero if this member is part of a class.
 694
 695    NAME points into the VT for the name of this member.
 696
 697    VALUE is the value of this enumeration member.
 698
 699    NEXTMEM points to the next DNTT_TYPE_MEMENUM in the chain.  */
 700
 701 struct dntt_type_memenum
 702 {
 703   unsigned int extension:       1;
 704   unsigned int kind:    10;
 705   unsigned int classmem:        1;
 706   unsigned int unused:          20;
 707   vtpointer name;
 708   unsigned int value;
 709   dnttpointer nextmem;
 710 };
 711
 712 /* DNTT_TYPE_SET
 713
 714    Used to describe PASCAL "set" type.
 715
 716    DECLARATION describes the bitpacking of the set.
 717
 718    SUBTYPE points to a DNTT entry describing the type of the members.
 719
 720    BITLENGTH is the size of the set.  */
 721
 722 struct dntt_type_set
 723 {
 724   unsigned int extension:       1;
 725   unsigned int kind:    10;
 726   unsigned int declaration:     2;
 727   unsigned int unused:          19;
 728   dnttpointer subtype;
 729   unsigned int bitlength;
 730 };
 731
 732 /* DNTT_TYPE_SUBRANGE
 733
 734    Used to describe subrange type.
 735
 736    DYN_LOW describes the lower bound of the subrange:
 737
 738      00 for a constant lower bound (found in LOWBOUND).
 739
 740      01 for a dynamic lower bound with the lower bound found in the the
 741      memory address pointed to by LOWBOUND.
 742
 743      10 for a dynamic lower bound described by an variable found in the
 744      DNTT/LNTT (LOWBOUND would be a pointer into the DNTT/LNTT).
 745
 746    DYN_HIGH is similar to DYN_LOW, except it describes the upper bound.
 747
 748    SUBTYPE points to the type of the subrange.
 749
 750    BITLENGTH is the length in bits needed to describe the subrange's
 751    values.  */
 752
 753 struct dntt_type_subrange
 754 {
 755   unsigned int extension:       1;
 756   unsigned int kind:    10;
 757   unsigned int dyn_low:         2;
 758   unsigned int dyn_high:        2;
 759   unsigned int unused:          17;
 760   int lowbound;
 761   int highbound;
 762   dnttpointer subtype;
 763   unsigned int bitlength;
 764 };
 765
 766 /* DNTT_TYPE_ARRAY
 767
 768    Used to describe an array type.
 769
 770    DECLARATION describes the bit packing used in the array.
 771
 772    ARRAYISBYTES is nonzero if the field in arraylength describes the
 773    length in bytes rather than in bits.  A value of zero is used to
 774    describe an array with size 2**32.
 775
 776    ELEMISBYTES is nonzero if the length if each element in the array
 777    is describes in bytes rather than bits.  A value of zero is used
 778    to an element with size 2**32.
 779
 780    ELEMORDER is nonzero if the elements are indexed in increasing order.
 781
 782    JUSTIFIED if the elements are left justified to index zero.
 783
 784    ARRAYLENGTH is the length of the array.
 785
 786    INDEXTYPE is a DNTT pointer to the type used to index the array.
 787
 788    ELEMTYPE is a DNTT pointer to the type for the array elements.
 789
 790    ELEMLENGTH is the length of each element in the array (including
 791    any padding).
 792
 793    Multi-dimensional arrays are represented by ELEMTYPE pointing to
 794    another DNTT_TYPE_ARRAY.  */
 795
 796 struct dntt_type_array
 797 {
 798   unsigned int extension:       1;
 799   unsigned int kind:    10;
 800   unsigned int declaration:     2;
 801   unsigned int dyn_low:         2;
 802   unsigned int dyn_high:        2;
 803   unsigned int arrayisbytes:    1;
 804   unsigned int elemisbytes:     1;
 805   unsigned int elemorder:       1;
 806   unsigned int justified:       1;
 807   unsigned int unused:          11;
 808   unsigned int arraylength;
 809   dnttpointer indextype;
 810   dnttpointer elemtype;
 811   unsigned int elemlength;
 812 };
 813
 814 /* DNTT_TYPE_STRUCT
 815
 816    DNTT_TYPE_STRUCT is used to describe a C structure.
 817
 818    DECLARATION describes the bitpacking used.
 819
 820    FIRSTFIELD is a DNTT pointer to the first field of the structure
 821    (each field contains a pointer to the next field, walk the list
 822    to access all fields of the structure).
 823
 824    VARTAGFIELD and VARLIST are used for Pascal variant records.
 825
 826    BITLENGTH is the size of the structure in bits.  */
 827
 828 struct dntt_type_struct
 829 {
 830   unsigned int extension:       1;
 831   unsigned int kind:    10;
 832   unsigned int declaration:     2;
 833   unsigned int unused:          19;
 834   dnttpointer firstfield;
 835   dnttpointer vartagfield;
 836   dnttpointer varlist;
 837   unsigned int bitlength;
 838 };
 839
 840 /* DNTT_TYPE_UNION
 841
 842    DNTT_TYPE_UNION is used to describe a C union.
 843
 844    FIRSTFIELD is a DNTT pointer to the beginning of the field chain.
 845
 846    BITLENGTH is the size of the union in bits.  */
 847
 848 struct dntt_type_union
 849 {
 850   unsigned int extension:       1;
 851   unsigned int kind:    10;
 852   unsigned int unused:          21;
 853   dnttpointer firstfield;
 854   unsigned int bitlength;
 855 };
 856
 857 /* DNTT_TYPE_FIELD
 858
 859    DNTT_TYPE_FIELD describes one field in a structure or union
 860    or C++ class.
 861
 862    VISIBILITY is used to describe the visibility of the field
 863    (for c++.  public = 0, protected = 1, private = 2).
 864
 865    A_UNION is nonzero if this field is a member of an anonymous union.
 866
 867    STATICMEM is nonzero if this field is a static member of a template.
 868
 869    NAME is a pointer into the VT for the name of the field.
 870
 871    BITOFFSET gives the offset of this field in bits from the beginning
 872    of the structure or union this field is a member of.
 873
 874    TYPE is a DNTT pointer to the type describing this field.
 875
 876    BITLENGTH is the size of the entry in bits.
 877
 878    NEXTFIELD is a DNTT pointer to the next field in the chain.  */
 879
 880 struct dntt_type_field
 881 {
 882   unsigned int extension:       1;
 883   unsigned int kind:    10;
 884   unsigned int visibility:      2;
 885   unsigned int a_union:         1;
 886   unsigned int staticmem:       1;
 887   unsigned int unused:          17;
 888   vtpointer name;
 889   unsigned int bitoffset;
 890   dnttpointer type;
 891   unsigned int bitlength;
 892   dnttpointer nextfield;
 893 };
 894
 895 /* DNTT_TYPE_VARIANT is unused by GDB.  */
 896 /* DNTT_TYPE_FILE is unused by GDB.  */
 897
 898 /* DNTT_TYPE_FUNCTYPE
 899
 900    I think this is used to describe a function type (e.g., would
 901    be emitted as part of a function-pointer description).
 902
 903    VARARGS is nonzero if this function uses varargs.
 904
 905    FIRSTPARAM is a DNTT pointer to the first entry in the parameter
 906    chain.
 907
 908    RETVAL is a DNTT pointer to the type of the return value.  */
 909
 910 struct dntt_type_functype
 911 {
 912   unsigned int extension:       1;
 913   unsigned int kind:            10;
 914   unsigned int varargs:         1;
 915   unsigned int info:            4;
 916   unsigned int unused:          16;
 917   unsigned int bitlength;
 918   dnttpointer firstparam;
 919   dnttpointer retval;
 920 };
 921
 922 /* DNTT_TYPE_WITH is emitted by C++ to indicate "with" scoping semantics.
 923    (Probably also emitted by PASCAL to support "with"...).
 924
 925    C++ example: Say "memfunc" is a method of class "c", and say
 926    "m" is a data member of class "c". Then from within "memfunc",
 927    it is legal to reference "m" directly (e.g. you don't have to
 928    say "this->m". The symbol table indicates
 929    this by emitting a DNTT_TYPE_WITH symbol within the function "memfunc",
 930    pointing to the type symbol for class "c".
 931
 932    In GDB, this symbol record is unnecessary,
 933    because GDB's symbol lookup algorithm
 934    infers the "with" semantics when it sees a "this" argument to the member
 935    function. So GDB can safely ignore the DNTT_TYPE_WITH record.
 936
 937    A DNTT_TYPE_WITH has a matching DNTT_TYPE_END symbol
 938  */
 939
 940 struct dntt_type_with {
 941   unsigned int extension:       1;    /* always zero */
 942   unsigned int kind:            10;   /* always DNTT_TYPE_WITH */
 943   unsigned int addrtype:        2;    /* 0 => STATTYPE                */
 944                                       /* 1 => DYNTYPE                 */
 945                                       /* 2 => REGTYPE                 */
 946   unsigned int indirect:        1;    /* 1 => pointer to object       */
 947   unsigned int longaddr:        1;    /* 1 => in long pointer space   */
 948   unsigned int nestlevel:       6;    /* # of nesting levels back     */
 949   unsigned int doc_ranges:      1;    /* 1 => location is range list  */
 950   unsigned int unused:          10;
 951   long location;                      /* where stored (allocated)     */
 952   sltpointer address;
 953   dnttpointer type;                   /* type of with expression      */
 954   vtpointer name;                     /* name of with expression      */
 955   unsigned long  offset;              /* byte offset from location    */
 956 };
 957
 958 /* DNTT_TYPE_COMMON is unsupported by GDB.  */
 959 /* A DNTT_TYPE_COMMON symbol must have a matching DNTT_TYPE_END symbol */
 960
 961 /* DNTT_TYPE_COBSTRUCT is unsupported by GDB.  */
 962 /* DNTT_TYPE_XREF is unsupported by GDB.  */
 963 /* DNTT_TYPE_SA is unsupported by GDB.  */
 964 /* DNTT_TYPE_MACRO is unsupported by GDB */
 965
 966 /* DNTT_TYPE_BLOCKDATA has the same structure as DNTT_TYPE_FUNCTION */
 967
 968 /* The following are the C++ specific SOM records */
 969
 970 /*  The purpose of the DNTT_TYPE_CLASS_SCOPE is to bracket C++ methods
 971     and indicate the method name belongs in the "class scope" rather
 972     than in the module they are being defined in. For example:
 973
 974     class c {
 975     ...
 976     void memfunc(); // member function
 977     };
 978
 979     void c::memfunc()   // definition of class c's "memfunc"
 980     {
 981     ...
 982     }
 983
 984     main()
 985     {
 986     ...
 987     }
 988
 989     In the above, the name "memfunc" is not directly visible from "main".
 990     I.e., you have to say "break c::memfunc".
 991     If it were a normal function (not a method), it would be visible
 992     via the simple "break memfunc". Since "memfunc" otherwise looks
 993     like a normal FUNCTION in the symbol table, the bracketing
 994     CLASS_SCOPE is what is used to indicate it is really a method.
 995
 996
 997    A DNTT_TYPE_CLASS_SCOPE symbol must have a matching DNTT_TYPE_END symbol
 998 */
 999
1000 struct dntt_type_class_scope {
1001   unsigned int extension:   1;     /* always zero */
1002   unsigned int kind:       10;     /* always DNTT_TYPE_CLASS_SCOPE */
1003   unsigned int unused:     21;
1004   sltpointer address         ;    /* pointer to SLT entry */
1005   dnttpointer type           ;     /* pointer to class type DNTT */
1006 };
1007
1008 /* C++ reference parameter.
1009    The structure of this record is the same as DNTT_TYPE_POINTER -
1010    refer to struct dntt_type_pointer.
1011  */
1012
1013 /* The next two describe C++ pointer-to-data-member type, and
1014    pointer-to-member-function type, respectively.
1015    DNTT_TYPE_PTRMEM and DNTT_TYPE_PTRMEMFUNC have the same structure
1016  */
1017
1018 struct dntt_type_ptrmem {
1019   unsigned int extension:   1;     /* always zero */
1020   unsigned int kind:       10;     /* always DNTT_TYPE_PTRMEM */
1021   unsigned int unused:     21;
1022   dnttpointer pointsto       ;     /* pointer to class DNTT         */
1023   dnttpointer memtype        ;     /* type of member                */
1024 };
1025
1026 struct dntt_type_ptrmemfunc {
1027   unsigned int extension:   1;     /* always zero */
1028   unsigned int kind:       10;     /* always DNTT_TYPE_PTRMEMFUNC */
1029   unsigned int unused:     21;
1030   dnttpointer pointsto       ;     /* pointer to class DNTT         */
1031   dnttpointer memtype        ;     /* type of member                */
1032 };
1033
1034 /* The DNTT_TYPE_CLASS symbol is emitted to describe a class type.
1035  * "memberlist" points to a chained list of FIELD or GENFIELD records
1036  * indicating the class members. "parentlist" points to a chained list
1037  * of INHERITANCE records indicating classes from which we inherit
1038  * fields.
1039  */
1040
1041 struct dntt_type_class
1042 {
1043   unsigned int extension:   1;     /* always 0 */
1044   unsigned int kind:       10;     /* always DNTT_TYPE_CLASS */
1045   unsigned int abstract:    1;     /* is this an abstract class?    */
1046   unsigned int class_decl:  2;     /* 0=class,1=union,2=struct      */
1047   unsigned int expansion:   1;     /* 1=template expansion          */
1048   unsigned int unused:     17;
1049   dnttpointer memberlist     ;     /* ptr to chain of [GEN]FIELDs */
1050   unsigned long vtbl_loc     ;     /* offset in obj of ptr to vtbl  */
1051   dnttpointer parentlist     ;     /* ptr to K_INHERITANCE list     */
1052   unsigned long bitlength    ;     /* total at this level           */
1053   dnttpointer identlist      ;     /* ptr to chain of class ident's */
1054   dnttpointer friendlist     ;     /* ptr to K_FRIEND list          */
1055   dnttpointer templateptr    ;     /* ptr to template               */
1056   dnttpointer nextexp        ;     /* ptr to next expansion         */
1057 };
1058
1059 /* Class members are indicated via either the FIELD record (for
1060    data members, same as for C struct fields), or by the GENFIELD record
1061    (for member functions).
1062  */
1063
1064 struct dntt_type_genfield {
1065   unsigned int extension:   1;     /* always zero */
1066   unsigned int kind:       10;     /* always DNTT_TYPE_GENFIELD */
1067   unsigned int visibility:  2;     /* pub = 0, prot = 1, priv = 2   */
1068   unsigned int a_union:     1;     /* 1 => anonymous union member   */
1069   unsigned int unused:     18;
1070   dnttpointer field          ;     /* pointer to field or qualifier */
1071   dnttpointer nextfield      ;     /* pointer to next field         */
1072 };
1073
1074 /* C++ virtual functions */
1075
1076 struct dntt_type_vfunc {
1077   unsigned int extension:   1;     /* always zero */
1078   unsigned int kind:       10;     /* always DNTT_TYPE_VFUNC */
1079   unsigned int pure:        1;     /* pure virtual function ?       */
1080   unsigned int unused:     20;
1081   dnttpointer funcptr        ;     /* points to FUNCTION symbol     */
1082   unsigned long vtbl_offset  ;     /* offset into vtbl for virtual  */
1083 };
1084
1085 /* Not precisely sure what this is intended for - DDE ignores it */
1086
1087 struct dntt_type_memaccess {
1088   unsigned int extension:   1;     /* always zero */
1089   unsigned int kind:       10;     /* always DNTT_TYPE_MEMACCESS */
1090   unsigned int unused:     21;
1091   dnttpointer classptr       ;     /* pointer to base class         */
1092   dnttpointer field          ;     /* pointer field                 */
1093 };
1094
1095 /* The DNTT_TYPE_INHERITANCE record describes derived classes.
1096  * In particular, the "parentlist" field of the CLASS record points
1097  * to a list of INHERITANCE records for classes from which we
1098  * inherit members.
1099  */
1100
1101 struct dntt_type_inheritance {
1102   unsigned int extension:   1;     /* always zero */
1103   unsigned int kind:       10;     /* always DNTT_TYPE_INHERITANCE */
1104   unsigned int Virtual:     1;     /* virtual base class ?          */
1105   unsigned int visibility:  2;     /* pub = 0, prot = 1, priv = 2   */
1106   unsigned int unused:     18;
1107   dnttpointer classname      ;     /* first parent class, if any    */
1108   unsigned long offset       ;     /* offset to start of base class */
1109   dnttpointer next           ;     /* pointer to next K_INHERITANCE */
1110   unsigned long future[2]    ;     /* padding to 3-word block end   */
1111 };
1112
1113 /* C++ "friend" classes ... */
1114
1115 struct dntt_type_friend_class {
1116   unsigned int extension:   1;     /* always zero */
1117   unsigned int kind:       10;     /* always DNTT_TYPE_FRIEND_CLASS */
1118   unsigned int unused:     21;
1119   dnttpointer classptr       ;     /* pointer to class DNTT         */
1120   dnttpointer next           ;     /* next DNTT_FRIEND              */
1121 };
1122
1123 struct dntt_type_friend_func {
1124   unsigned int extension:   1;     /* always zero */
1125   unsigned int kind:       10;     /* always DNTT_TYPE_FRIEND_FUNC */
1126   unsigned int unused:     21;
1127   dnttpointer funcptr        ;     /* pointer to function           */
1128   dnttpointer classptr       ;     /* pointer to class DNTT         */
1129   dnttpointer next           ;     /* next DNTT_FRIEND              */
1130   unsigned long future[2]    ;     /* padding to 3-word block end   */
1131 };
1132
1133 /* DDE appears to ignore the DNTT_TYPE_MODIFIER record.
1134  * It could perhaps be used to give better "ptype" output in GDB;
1135  * otherwise it is probably safe for GDB to ignore it also.
1136  */
1137
1138 struct dntt_type_modifier {
1139   unsigned int extension:   1;     /* always zero */
1140   unsigned int kind:       10;     /* always DNTT_TYPE_MODIFIER */
1141   unsigned int m_const:     1;     /* const                         */
1142   unsigned int m_static:    1;     /* static                        */
1143   unsigned int m_void:      1;     /* void                          */
1144   unsigned int m_volatile:  1;     /* volatile                      */
1145   unsigned int m_duplicate: 1;     /* duplicate                     */
1146   unsigned int unused:     16;
1147   dnttpointer type           ;     /* subtype                       */
1148   unsigned long future       ;     /* padding to 3-word block end   */
1149 };
1150
1151 /* I'm not sure what this was intended for - DDE ignores it */
1152
1153 struct dntt_type_object_id {
1154   unsigned int extension:   1;     /* always zero */
1155   unsigned int kind:       10;     /* always DNTT_TYPE_OBJECT_ID */
1156   unsigned int indirect:    1;     /* Is object_ident addr of addr? */
1157   unsigned int unused:     20;
1158   unsigned long object_ident ;     /* object identifier             */
1159   unsigned long offset       ;     /* offset to start of base class */
1160   dnttpointer next           ;     /* pointer to next K_OBJECT_ID   */
1161   unsigned long segoffset    ;     /* for linker fixup              */
1162   unsigned long future       ;     /* padding to 3-word block end   */
1163 };
1164
1165 /* No separate dntt_type_memfunc; same as dntt_type_func */
1166
1167 /* Symbol records to support templates. These only get used
1168  * in DDE's "describe" output (like GDB's "ptype").
1169  */
1170
1171 /* The TEMPLATE record is the header for a template-class.
1172  * Like the CLASS record, a TEMPLATE record has a memberlist that
1173  * points to a list of template members. It also has an arglist
1174  * pointing to a list of TEMPLATE_ARG records.
1175  */
1176
1177 struct dntt_type_template {
1178   unsigned int extension:   1;     /* always zero */
1179   unsigned int kind:       10;     /* always DNTT_TYPE_TEMPLATE */
1180   unsigned int abstract:    1;     /* is this an abstract class?    */
1181   unsigned int class_decl:  2;     /* 0=class,1=union,2=struct      */
1182   unsigned int unused:     18;
1183   dnttpointer memberlist     ;     /* ptr to chain of K_[GEN]FIELDs */
1184   long unused2               ;     /* offset in obj of ptr to vtbl  */
1185   dnttpointer parentlist     ;     /* ptr to K_INHERITANCE list     */
1186   unsigned long bitlength    ;     /* total at this level           */
1187   dnttpointer identlist      ;     /* ptr to chain of class ident's */
1188   dnttpointer friendlist     ;     /* ptr to K_FRIEND list          */
1189   dnttpointer arglist        ;     /* ptr to argument list          */
1190   dnttpointer expansions     ;     /* ptr to expansion list         */
1191 };
1192
1193 /* Template-class arguments are a list of TEMPL_ARG records
1194  * chained together. The "name" field is the name of the formal.
1195  * E.g.:
1196  * template <class T> class q { ... };
1197  * Then "T" is the name of the formal argument.
1198  */
1199 struct dntt_type_templ_arg {
1200   unsigned int extension:   1;     /* always zero */
1201   unsigned int kind:       10;     /* always DNTT_TYPE_TEMPL_ARG */
1202   unsigned int usagetype:   1;     /* 0 type-name 1 expression     */
1203   unsigned int unused:     20;
1204   vtpointer name             ;     /* name of argument             */
1205   dnttpointer type           ;     /* for non type arguments       */
1206   dnttpointer nextarg        ;     /* Next argument if any         */
1207   long future[2]             ;     /* padding to 3-word block end  */
1208 };
1209
1210 /* FUNC_TEMPLATE records are sort of like FUNCTION, but are emitted
1211  * for template member functions. E.g.,
1212  * template <class T> class q {
1213       ...
1214       void f();
1215       ...
1216    };
1217  * Within the list of FIELDs/GENFIELDs defining the member list
1218  * of the template "q", "f" would appear as a FUNC_TEMPLATE.
1219  * We'll also see instances of FUNCTION "f" records for each
1220  * instantiation of the template.
1221  */
1222
1223 struct dntt_type_func_template {
1224   unsigned int extension:   1;     /* always zero */
1225   unsigned int kind:       10;     /* always DNTT_TYPE_FUNC_TEMPLATE */
1226   unsigned int public:      1;     /* 1 => globally visible        */
1227   unsigned int language:    4;     /* type of language             */
1228   unsigned int level:       5;     /* nesting level (top level = 0)*/
1229   unsigned int optimize:    2;     /* level of optimization        */
1230   unsigned int varargs:     1;     /* ellipses.  Pascal/800 later  */
1231   unsigned int info:        4;     /* lang-specific stuff; F_xxxx  */
1232   unsigned int inlined:     1;
1233   unsigned int localloc:    1;     /* 0 at top, 1 at end of block  */
1234   unsigned int unused:      2;
1235   vtpointer name             ;     /* name of function             */
1236   vtpointer alias            ;     /* alternate name, if any       */
1237   dnttpointer firstparam     ;     /* first FPARAM, if any         */
1238   dnttpointer retval         ;     /* return type, if any          */
1239   dnttpointer arglist        ;     /* ptr to argument list         */
1240 };
1241
1242 /* LINK is apparently intended to link together function template
1243  * definitions with their instantiations. However, it is not clear
1244  * why this would be needed, except to provide the information on
1245  * a "ptype" command. And as far as I can tell, aCC does not
1246  * generate this record.
1247  */
1248
1249 struct dntt_type_link {
1250   unsigned int extension:   1;     /* always zero */
1251   unsigned int kind:       10;     /* always DNTT_TYPE_LINK */
1252   unsigned int linkKind:    4;     /* always LINK_UNKNOWN          */
1253   unsigned int unused:     17;
1254   long future1               ;     /* expansion                    */
1255   dnttpointer ptr1           ;     /* link from template           */
1256   dnttpointer ptr2           ;     /* to expansion                 */
1257   long future[2]             ;     /* padding to 3-word block end  */
1258 };
1259
1260 /* end of C++ specific SOM's */
1261
1262 /* DNTT_TYPE_DYN_ARRAY_DESC is unused by GDB */
1263 /* DNTT_TYPE_DESC_SUBRANGE is unused by GDB */
1264 /* DNTT_TYPE_BEGIN_EXT is unused by GDB */
1265 /* DNTT_TYPE_INLN is unused by GDB */
1266 /* DNTT_TYPE_INLN_LIST is unused by GDB */
1267 /* DNTT_TYPE_ALIAS is unused by GDB */
1268
1269 struct dntt_type_doc_function {
1270   unsigned int extension: 1;   /* always zero                  */
1271   unsigned int kind:     10;   /* K_DOC_FUNCTION or            */
1272                                /* K_DOC_MEMFUNC                */
1273   unsigned int global:    1;   /* 1 => globally visible        */
1274   unsigned int language:  4;   /* type of language             */
1275   unsigned int level:     5;   /* nesting level (top level = 0)*/
1276   unsigned int optimize:  2;   /* level of optimization        */
1277   unsigned int varargs:   1;   /* ellipses.  Pascal/800 later  */
1278   unsigned int info:      4;   /* lang-specific stuff; F_xxxx  */
1279   unsigned int inlined:   1;
1280   unsigned int localloc:  1;   /* 0 at top, 1 at end of block  */
1281   unsigned int expansion: 1;   /* 1 = function expansion       */
1282   unsigned int doc_clone: 1;
1283   vtpointer name;              /* name of function             */
1284   vtpointer alias;             /* alternate name, if any       */
1285   dnttpointer firstparam;      /* first FPARAM, if any         */
1286   sltpointer address;          /* code and text locations      */
1287   CORE_ADDR entryaddr;         /* address of entry point       */
1288   dnttpointer retval;          /* return type, if any          */
1289   CORE_ADDR lowaddr;           /* lowest address of function   */
1290   CORE_ADDR hiaddr;            /* highest address of function  */
1291   dnttpointer inline_list;     /* pointer to first inline    */
1292   ltpointer lt_offset;         /* start of frag/cp line table  */
1293   ctxtpointer ctxt_offset;     /* start of context table for this routine */
1294 };
1295
1296 /* DNTT_TYPE_DOC_MEMFUNC is unused by GDB */
1297
1298 /* DNTT_TYPE_GENERIC and DNTT_TYPE_BLOCK are convience structures
1299    so we can examine a DNTT entry in a generic fashion.  */
1300 struct dntt_type_generic
1301 {
1302   unsigned int word[9];
1303 };
1304
1305 struct dntt_type_block
1306 {
1307   unsigned int extension:       1;
1308   unsigned int kind:            10;
1309   unsigned int unused:          21;
1310   unsigned int word[2];
1311 };
1312
1313 /* One entry in a DNTT (either the LNTT or GNTT).
1314  * This is a union of the above 60 or so structure definitions.
1315  */
1316 union dnttentry
1317 {
1318   struct dntt_type_srcfile dsfile;
1319   struct dntt_type_module dmodule;
1320   struct dntt_type_function dfunc;
1321   struct dntt_type_function dentry;
1322   struct dntt_type_begin dbegin;
1323   struct dntt_type_end dend;
1324   struct dntt_type_fparam dfparam;
1325   struct dntt_type_svar dsvar;
1326   struct dntt_type_dvar ddvar;
1327   struct dntt_type_const dconst;
1328   struct dntt_type_type dtype;
1329   struct dntt_type_type dtag;
1330   struct dntt_type_pointer dptr;
1331   struct dntt_type_enum denum;
1332   struct dntt_type_memenum dmember;
1333   struct dntt_type_set dset;
1334   struct dntt_type_subrange dsubr;
1335   struct dntt_type_array darray;
1336   struct dntt_type_struct dstruct;
1337   struct dntt_type_union dunion;
1338   struct dntt_type_field dfield;
1339   struct dntt_type_functype dfunctype;
1340   struct dntt_type_with dwith;
1341   struct dntt_type_function dblockdata;
1342   struct dntt_type_class_scope dclass_scope;
1343   struct dntt_type_pointer dreference;
1344   struct dntt_type_ptrmem dptrmem;
1345   struct dntt_type_ptrmemfunc dptrmemfunc;
1346   struct dntt_type_class dclass;
1347   struct dntt_type_genfield dgenfield;
1348   struct dntt_type_vfunc dvfunc;
1349   struct dntt_type_memaccess dmemaccess;
1350   struct dntt_type_inheritance dinheritance;
1351   struct dntt_type_friend_class dfriend_class;
1352   struct dntt_type_friend_func dfriend_func;
1353   struct dntt_type_modifier dmodifier;
1354   struct dntt_type_object_id dobject_id;
1355   struct dntt_type_template dtemplate;
1356   struct dntt_type_templ_arg dtempl_arg;
1357   struct dntt_type_func_template dfunc_template;
1358   struct dntt_type_link dlink;
1359   struct dntt_type_doc_function ddocfunc;
1360   struct dntt_type_generic dgeneric;
1361   struct dntt_type_block dblock;
1362 };
1363
1364 /* Source line entry types.  */
1365 enum slttype
1366 {
1367   SLT_NORMAL,
1368   SLT_SRCFILE,
1369   SLT_MODULE,
1370   SLT_FUNCTION,
1371   SLT_ENTRY,
1372   SLT_BEGIN,
1373   SLT_END,
1374   SLT_WITH,
1375   SLT_EXIT,
1376   SLT_ASSIST,
1377   SLT_MARKER,
1378   SLT_CLASS_SCOPE,
1379   SLT_INLN,
1380   SLT_NORMAL_OFFSET,
1381 };
1382
1383 /* A normal source line entry.  Simply provides a mapping of a source
1384    line number to a code address.
1385
1386    SLTDESC will always be SLT_NORMAL or SLT_EXIT.  */
1387
1388 struct slt_normal
1389 {
1390   unsigned int sltdesc: 4;
1391   unsigned int line:    28;
1392   CORE_ADDR address;
1393 };
1394
1395 struct slt_normal_off
1396 {
1397   unsigned int sltdesc: 4;
1398   unsigned int offset:  6;
1399   unsigned int line:    22;
1400   CORE_ADDR address;
1401 };
1402
1403 /* A special source line entry.  Provides a mapping of a declaration
1404    to a line number.  These entries point back into the DNTT which
1405    references them.  */
1406
1407 struct slt_special
1408 {
1409   unsigned int sltdesc: 4;
1410   unsigned int line:    28;
1411   dnttpointer backptr;
1412 };
1413
1414 /* Used to describe nesting.
1415
1416    For nested languages, an slt_assist entry must follow each SLT_FUNC
1417    entry in the SLT.  The address field will point forward to the
1418    first slt_normal entry within the function's scope.  */
1419
1420 struct slt_assist
1421 {
1422   unsigned int sltdesc: 4;
1423   unsigned int unused:  28;
1424   sltpointer address;
1425 };
1426
1427 struct slt_generic
1428 {
1429   unsigned int word[2];
1430 };
1431
1432 union sltentry
1433 {
1434   struct slt_normal snorm;
1435   struct slt_normal_off snormoff;
1436   struct slt_special sspec;
1437   struct slt_assist sasst;
1438   struct slt_generic sgeneric;
1439 };
1440
1441 /*  $LINES$ declarations
1442  *  This is the line table used for optimized code, which is only present
1443  *  in the new $PROGRAM_INFO$ debug space.
1444  */
1445
1446 #define DST_LN_ESCAPE_FLAG1   15
1447 #define DST_LN_ESCAPE_FLAG2   14
1448 #define DST_LN_CTX_SPEC1      13
1449 #define DST_LN_CTX_SPEC2      12
1450
1451 /*
1452   Escape function codes:
1453 */
1454 typedef enum
1455     {
1456     dst_ln_pad,          /* pad byte */
1457     dst_ln_escape_1,     /* reserved */
1458     dst_ln_dpc1_dln1,    /* 1 byte line delta, 1 byte pc delta */
1459     dst_ln_dpc2_dln2,    /* 2 bytes line delta, 2 bytes pc delta */
1460     dst_ln_pc4_ln4,      /* 4 bytes ABSOLUTE line number, 4 bytes ABSOLUTE pc */
1461     dst_ln_dpc0_dln1,    /* 1 byte line delta, pc delta = 0 */
1462     dst_ln_ln_off_1,     /* statement escape, stmt # = 1 (2nd stmt on line) */
1463     dst_ln_ln_off,       /* statement escape, stmt # = next byte */
1464     dst_ln_entry,        /* entry escape, next byte is entry number */
1465     dst_ln_exit,         /* exit escape */
1466     dst_ln_stmt_end,     /* gap escape, 4 bytes pc delta */
1467     dst_ln_stmt_cp,      /* current stmt is a critical point */
1468     dst_ln_escape_12,    /* reserved */
1469     dst_ln_escape_13,    /* this is an exception site record */
1470     dst_ln_nxt_byte,     /* next byte contains the real escape code */
1471     dst_ln_end,          /* end escape, final entry follows */
1472     dst_ln_escape1_END_OF_ENUM
1473     }
1474     dst_ln_escape1_t;
1475
1476 typedef enum
1477     {
1478     dst_ln_ctx_1,        /* next byte describes context switch with 5-bit */
1479                          /* index into the image table and 3-bit run length. */
1480                          /* If run length is 0, end with another cxt specifier or ctx_end */
1481     dst_ln_ctx_2,        /* next 2 bytes switch context: 13 bit index, 3 bit run length */
1482     dst_ln_ctx_4,        /* next 4 bytes switch context: 29 bit index, 3 bit run length */
1483     dst_ln_ctx_end,      /* end current context */
1484     dst_ln_col_run_1,    /* next byte is column position of start of next statement, */
1485                          /* following byte is length of statement */
1486     dst_ln_col_run_2,    /* next 2 bytes is column position of start of next statement, */
1487                          /* following 2 bytes is length of statement */
1488     dst_ln_init_base1,   /* next 4 bytes are absolute PC, followed by 1 byte of line number */
1489     dst_ln_init_base2,   /* next 4 bytes are absolute PC, followed by 2 bytes of line number */
1490     dst_ln_init_base3,   /* next 4 bytes are absolute PC, followed by 3 bytes of line number */
1491     dst_ln_escape2_END_OF_ENUM
1492     }
1493     dst_ln_escape2_t;
1494
1495 typedef union
1496     {
1497     struct
1498         {
1499         unsigned int      pc_delta : 4;      /* 4 bit pc delta */
1500         int               ln_delta : 4;      /* 4 bit line number delta */
1501         }
1502         delta;
1503
1504     struct
1505         {
1506         unsigned int      esc_flag : 4;      /* alias for pc_delta  */
1507         unsigned int      esc_code : 4;      /* escape function code (dst_ln_escape1_t, or ...2_t */
1508         }
1509         esc;
1510
1511     struct
1512         {
1513         unsigned int      esc_flag : 4;      /* dst_ln_ctx_spec1, or dst_ln_ctx_spec2 */
1514         unsigned int      run_length : 2;
1515         unsigned int      ctx_index : 2;      /* ...spec2 contains index;  ...spec1, index - 4 */
1516         }
1517         ctx_spec;
1518
1519     char               sdata;               /* signed data byte */
1520     unsigned char      udata;               /* unsigned data byte */
1521     }
1522     dst_ln_entry_t,
1523     *dst_ln_entry_ptr_t;
1524
1525 /* Warning: although the above union occupies only 1 byte the compiler treats
1526  * it as having size 2 (the minimum size of a struct).  Therefore a sequence of
1527  * dst_ln_entry_t's cannot be described as an array, and walking through such a
1528  * sequence requires convoluted code such as
1529  *      ln_ptr = (dst_ln_entry_ptr_t) (char*) ln_ptr + 1
1530  * We regret the inconvenience. */
1531
1532 /* Structure for interpreting the byte following a dst_ln_ctx1 entry */
1533 typedef struct {
1534     unsigned  int          ctx1_index : 5;      /* 5 bit index into context table */
1535     unsigned  int          ctx1_run_length : 3; /* 3 bit run length */
1536 } dst_ln_ctx1_t,
1537   *dst_ln_ctx1_ptr_t;
1538
1539 /* Structure for interpreting the bytes following a dst_ln_ctx2 entry */
1540 typedef struct {
1541     unsigned  int          ctx2_index : 13;     /* 13 bit index into context table */
1542     unsigned  int          ctx2_run_length : 3; /* 3 bit run length */
1543 } dst_ln_ctx2_t,
1544   *dst_ln_ctx2_ptr_t;
1545
1546 /* Structure for interpreting the bytes following a dst_ln_ctx4 entry */
1547 typedef struct {
1548     unsigned  int          ctx4_index : 29;     /* 29 bit index into context table */
1549     unsigned  int          ctx4_run_length : 3; /* 3 bit run length */
1550 } dst_ln_ctx4_t,
1551   *dst_ln_ctx4_ptr_t;
1552
1553
1554 /*  PXDB definitions.
1555  *
1556  * PXDB is a post-processor which takes the executable file
1557  * and massages the debug information so that the debugger may
1558  * start up and run more efficiently.  Some of the tasks
1559  * performed by PXDB are:
1560  *
1561  * o   Remove duplicate global type and variable information
1562  *     from the GNTT,
1563  *
1564  * o   Append the GNTT onto the end of the LNTT and place both
1565  *     back in the LNTT section,
1566  *
1567  * o   Build quick look-up tables (description follows) for
1568  *     files, procedures, modules, and paragraphs (for Cobol),
1569  *     placing these in the GNTT section,
1570  *
1571  * o   Reconstruct the header appearing in the header section
1572  *     to access this information.
1573  *
1574  * The "quick look-up" tables are in the $GNTT$ sub-space, in
1575  * the following order:
1576  *
1577  *     Procedures    -sorted by address
1578  *     Source files  -sorted by address (of the
1579  *                    generated code from routines)
1580  *     Modules       -sorted by address
1581  *     Classes       -<unsorted?>
1582  *     Address Alias -sorted by index <?>
1583  *     Object IDs    -sorted by object identifier
1584  *
1585  * Most quick entries have (0-based) indices into the LNTT tables to
1586  * the full entries for the item it describes.
1587  *
1588  * The post-PXDB header is in the $HEADER$ sub-space.  Alas, it
1589  * occurs in different forms, depending on the optimization level
1590  * in the compilation step and whether PXDB was run or not. The
1591  * worst part is the forms aren't self-describing, so we'll have
1592  * to grovel in the bits to figure out what kind we're looking at
1593  * (see hp_get_header in hp-psymtab-read.c).
1594  */
1595
1596 /* PXDB versions
1597  */
1598 #define PXDB_VERSION_CPLUSPLUS  1
1599 #define PXDB_VERSION_7_4        2
1600 #define PXDB_VERSION_CPP_30     3
1601 #define PXDB_VERSION_DDE_3_2A   4
1602 #define PXDB_VERSION_DDE_3_2    5
1603 #define PXDB_VERSION_DDE_4_0    6
1604
1605 #define PXDB_VERSION_2_1        1
1606
1607 /* Header version for the case that there is no DOC info
1608  * but the executable has been processed by pxdb (the easy
1609  * case, from "cc -g").
1610  */
1611 typedef struct PXDB_struct {
1612     int              pd_entries;   /* # of entries in function look-up table */
1613     int              fd_entries;   /* # of entries in file look-up table */
1614     int              md_entries;   /* # of entries in module look-up table */
1615     unsigned int     pxdbed : 1;   /* 1 => file has been preprocessed      */
1616     unsigned int     bighdr : 1;   /* 1 => this header contains 'time' word */
1617     unsigned int     sa_header : 1;/* 1 => created by SA version of pxdb */
1618                                    /*   used for version check in xdb */
1619     unsigned int     inlined: 1;   /* one or more functions have been inlined */
1620     unsigned int     spare:12;
1621     short            version;      /* pxdb header version */
1622     int              globals;      /* index into the DNTT where GNTT begins */
1623     unsigned int     time;         /* modify time of file before being pxdbed */
1624     int              pg_entries;   /* # of entries in label look-up table */
1625     int              functions;    /* actual number of functions */
1626     int              files;        /* actual number of files */
1627     int              cd_entries;   /* # of entries in class look-up table */
1628     int              aa_entries;   /* # of entries in addr alias look-up table */
1629     int              oi_entries;   /* # of entries in object id look-up table */
1630 } PXDB_header, *PXDB_header_ptr;
1631
1632 /* Header version for the case that there is no DOC info and the
1633  * executable has NOT been processed by pxdb.
1634  */
1635 typedef struct XDB_header_struct {
1636     long gntt_length;
1637     long lntt_length;
1638     long slt_length;
1639     long vt_length;
1640     long xt_length;
1641 } XDB_header;
1642
1643 /* Header version for the case that there is DOC info and the
1644  * executable has been processed by pxdb.
1645  */
1646 typedef struct DOC_info_PXDB_header_struct {
1647         unsigned int xdb_header: 1;         /* bit set if this is post-3.1 xdb */
1648         unsigned int doc_header: 1;         /* bit set if this is doc-style header*/
1649         unsigned int version: 8;            /* version of pxdb see defines
1650                                              * PXDB_VERSION_* in this file */
1651         unsigned int reserved_for_flags: 16;/* for future use; -- must be
1652                                              *  set to zero
1653                                              */
1654         unsigned int has_aux_pd_table: 1;   /* $GNTT$ has aux PD table */
1655         unsigned int has_expr_table: 1;     /* space has $EXPR$ */
1656         unsigned int has_range_table: 1;    /* space has $RANGE$ */
1657         unsigned int has_context_table: 1;  /* space has $SRC_CTXT$ */
1658         unsigned int has_lines_table: 1;    /* space contains a $LINES$
1659                                              *  subspace for line tables.
1660                                              */
1661         unsigned int has_lt_offset_map: 1;  /* space contains an lt_offset
1662                                              *  subspace for line table mapping
1663                                              */
1664      /* the following fields are the same as those in the PXDB_header in $DEBUG$ */
1665         int      pd_entries;   /* # of entries in function look-up table */
1666         int      fd_entries;   /* # of entries in file look-up table */
1667         int      md_entries;   /* # of entries in module look-up table */
1668         unsigned int     pxdbed : 1;   /* 1 => file has been preprocessed      */
1669         unsigned int     bighdr : 1;   /* 1 => this header contains 'time' word */
1670         unsigned int     sa_header : 1;/* 1 => created by SA version of pxdb */
1671                                /*   used for version check in xdb */
1672         unsigned int     inlined: 1;   /* one or more functions have been inlined */
1673         unsigned int     spare : 28;
1674         int      globals;      /* index into the DNTT where GNTT begins */
1675         unsigned int     time;         /* modify time of file before being pxdbed */
1676         int      pg_entries;   /* # of entries in label look-up table */
1677         int      functions;    /* actual number of functions */
1678         int      files;        /* actual number of files */
1679         int      cd_entries;   /* # of entries in class look-up table */
1680         int      aa_entries;   /* # of entries in addr alias look-up table */
1681         int      oi_entries;   /* # of entries in object id look-up table */
1682 } DOC_info_PXDB_header;
1683
1684 /* Header version for the case that there is DOC info and the
1685  * executable has NOT been processed by pxdb.
1686  */
1687 typedef struct DOC_info_header_struct {
1688         unsigned int xdb_header: 1;     /* bit set if this is post-3.1 xdb */
1689         unsigned int doc_header: 1;     /* bit set if this is doc-style header*/
1690         unsigned int version: 8;             /* version of debug/header
1691                                                 format. For 10.0 the value
1692                                                 will be 1. For "Davis" the
1693                                                 value is 2.
1694                                               */
1695         unsigned int reserved_for_flags: 18; /* for future use; -- must be
1696                                                 set to zero
1697                                               */
1698         unsigned int has_range_table: 1;     /* space contains a $RANGE$
1699                                                 subspace for variable ranges.
1700                                               */
1701         unsigned int has_context_table: 1;     /* space contains a $CTXT$
1702                                                 subspace for context/inline
1703                                                 table.
1704                                               */
1705         unsigned int has_lines_table: 1;     /* space contains a $LINES$
1706                                                 subspace for line tables.
1707                                               */
1708         unsigned int has_lt_offset_map: 1;   /* space contains an lt_offset
1709                                                 subspace for line table mapping
1710                                               */
1711
1712         long   gntt_length;  /* same as old header */
1713         long   lntt_length;  /* same as old header */
1714         long   slt_length;   /* same as old header */
1715         long   vt_length;    /* same as old header */
1716         long   xt_length;    /* same as old header */
1717         long   ctxt_length;  /* present only if version >= 2 */
1718         long   range_length;  /* present only if version >= 2 */
1719         long   expr_length;  /* present only if version >= 2 */
1720
1721 } DOC_info_header;
1722
1723 typedef union GenericDebugHeader_union
1724 {
1725    PXDB_header          no_doc;
1726    DOC_info_PXDB_header doc;
1727    XDB_header           no_pxdb_no_doc;
1728    DOC_info_header      no_pxdb_doc;
1729 } GenericDebugHeader;
1730
1731
1732 /*  Procedure Descriptor:
1733  *
1734  *  An element of the procedure quick look-up table
1735  */
1736 typedef struct quick_procedure {
1737         long             isym;          /* 0-based index of first symbol*/
1738                                         /*   for procedure in $LNTT$,   */
1739                                         /*   i.e. the procedure itself  */
1740         CORE_ADDR        adrStart;      /* memory adr of start of proc  */
1741         CORE_ADDR        adrEnd;        /* memory adr of end of proc    */
1742         char            *sbAlias;       /* alias name of procedure      */
1743         char            *sbProc;        /* real name of procedure       */
1744         CORE_ADDR        adrBp;         /* address of entry breakpoint  */
1745         CORE_ADDR        adrExitBp;     /* address of exit breakpoint   */
1746         int              icd;           /* member of this class (index) */
1747         unsigned int     ipd;           /* index of template for this   */
1748                                         /*   function (index)           */
1749         unsigned int     unused:    5;
1750         unsigned int     no_lt_offset: 1;/* no entry in lt_offset table */
1751         unsigned int     fTemplate: 1;  /* function template            */
1752         unsigned int     fExpansion: 1; /* function expansion           */
1753         unsigned int     linked   : 1;  /* linked with other expansions */
1754         unsigned int     duplicate: 1;  /* clone of another procedure   */
1755         unsigned int     overloaded:1;  /* overloaded function          */
1756         unsigned int     member:    1;  /* class member function        */
1757         unsigned int     constructor:1; /* constructor function         */
1758         unsigned int     destructor:1;  /* destructor function          */
1759         unsigned int     Static:    1;  /* static function              */
1760         unsigned int     Virtual:   1;  /* virtual function             */
1761         unsigned int     constant:  1;  /* constant function            */
1762         unsigned int     pure:      1;  /* pure (virtual) function      */
1763         unsigned int     language:  4;  /* procedure's language         */
1764         unsigned int     inlined:   1;  /* function has been inlined    */
1765         unsigned int     Operator:  1;  /* operator function            */
1766         unsigned int     stub:      1;  /* bodyless function            */
1767         unsigned int     optimize:  2;  /* optimization level           */
1768         unsigned int     level:     5;  /* nesting level (top=0)        */
1769 } quick_procedure_entry, *quick_procedure_entry_ptr;
1770
1771 /*  Source File Descriptor:
1772  *
1773  *  An element of the source file quick look-up table
1774  */
1775 typedef struct quick_source {
1776         long           isym;            /* 0-based index in $LNTT$ of      */
1777                                         /*   first symbol for this file    */
1778         CORE_ADDR      adrStart;        /* mem adr of start of file's code */
1779         CORE_ADDR      adrEnd;          /* mem adr of end of file's code   */
1780         char          *sbFile;          /* name of source file             */
1781         unsigned int   fHasDecl: 1;     /* do we have a .d file?           */
1782         unsigned int   fWarned:  1;     /* have warned about age problems? */
1783         unsigned int   fSrcfile: 1;     /* 0 => include 1=> source         */
1784         unsigned short ilnMac;          /* lines in file (0 if don't know) */
1785         int            ipd;             /* 0-based index of first procedure*/
1786                                         /*   in this file, in the quick    */
1787                                         /*   look-up table of procedures   */
1788         unsigned int  *rgLn;            /* line pointer array, if any      */
1789 } quick_file_entry, *quick_file_entry_ptr;
1790
1791 /*  Module Descriptor:
1792  *
1793  *  An element of the module quick reference table
1794  */
1795 typedef struct quick_module {
1796         long             isym;             /* 0-based index of first    */
1797                                            /*   symbol for module       */
1798         CORE_ADDR        adrStart;         /* adr of start of mod.      */
1799         CORE_ADDR        adrEnd;           /* adr of end of mod.        */
1800         char            *sbAlias;          /* alias name of module      */
1801         char            *sbMod;            /* real name of module       */
1802         unsigned int     imports:       1; /* module have any imports?  */
1803         unsigned int     vars_in_front: 1; /* module globals in front?  */
1804         unsigned int     vars_in_gaps:  1; /* module globals in gaps?   */
1805         unsigned int     language:      4; /* type of language          */
1806         unsigned int     unused      : 25;
1807         unsigned int     unused2;          /* space for future stuff    */
1808 } quick_module_entry, *quick_module_entry_ptr;
1809
1810 /*  Auxiliary Procedure Descriptor:
1811  *
1812  *  An element of the auxiliary procedure quick look-up table
1813  */
1814 typedef struct quick_aux_procedure {
1815         long     isym_inln;     /* start on inline list for proc */
1816         long     spare;
1817 } quick_aux_procedure_entry, *quick_aux_procedure_entry_ptr;
1818
1819 /*  Paragraph Descriptor:
1820  *
1821  *  An element of the paragraph quick look-up table
1822  */
1823 typedef struct quick_paragraph {
1824         long             isym;       /* first symbol for label (index)  */
1825         CORE_ADDR        adrStart;   /* memory adr of start of label    */
1826         CORE_ADDR        adrEnd;     /* memory adr of end of label      */
1827         char            *sbLab;      /* name of label                   */
1828         unsigned int     inst;       /* Used in xdb to store inst @ bp  */
1829         unsigned int     sect:    1; /* true = section, false = parag.  */
1830         unsigned int     unused: 31; /* future use                      */
1831 } quick_paragraph_entry, *quick_paragraph_entry_ptr;
1832
1833 /*
1834  *  Class Descriptor:
1835  *
1836  *  An element of the class quick look-up table
1837  */
1838 typedef struct quick_class {
1839         char             *sbClass;      /* name of class                */
1840         long              isym;         /* class symbol (tag)           */
1841         unsigned int      type : 2;     /* 0=class, 1=union, 2=struct   */
1842         unsigned int      fTemplate : 1;/* class template               */
1843         unsigned int      expansion : 1;/* template expansion           */
1844         unsigned int      unused    :28;
1845         sltpointer        lowscope;     /* beginning of defined scope   */
1846         sltpointer        hiscope;      /* end of defined scope         */
1847 } quick_class_entry, *quick_class_entry_ptr;
1848
1849 /*  Address Alias Entry
1850  *
1851  *  An element of the address alias quick look-up table
1852  */
1853 typedef struct quick_alias {
1854         CORE_ADDR       low;
1855         CORE_ADDR       high;
1856         int             index;
1857         unsigned int    unused : 31;
1858         unsigned int    alternate : 1;  /* alternate unnamed aliases?   */
1859 } quick_alias_entry, *quick_alias_entry_ptr;
1860
1861 /*  Object Identification Entry
1862  *
1863  *  An element of the object identification quick look-up table
1864  */
1865
1866 typedef struct quick_obj_ID {
1867         CORE_ADDR    obj_ident;         /* class identifier         */
1868         long         isym;              /* class symbol             */
1869         long         offset;            /* offset to object start   */
1870 } quick_obj_ID_entry, *quick_obj_ID_entry_ptr;
1871
1872
1873 #endif /* HP_SYMTAB_INCLUDED */
1874