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 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., 675 Mass Ave, Cambridge, MA 02139, 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 basic data structures
  29    necessary to read debug symbols produced by the HP C compiler using the
  30    SOM object file format.  Definitions and structures used by other compilers
  31    for other languages or object file formats may be missing.
  32    (For a full description of the debug format, ftp hpux-symtab.h from
  33    jaguar.cs.utah.edu:/dist).
  34
  35
  36    Debug symbols are contained entirely within an unloadable space called
  37    $DEBUG$.  $DEBUG$ contains several subspaces which group related
  38    debug symbols.
  39
  40    $GNTT$ contains information for global variables, types and contants.
  41
  42    $LNTT$ contains information for procedures (including nesting), scoping
  43    information, local variables, types, and constants.
  44
  45    $SLT$ contains source line information so that code addresses may be
  46    mapped to source lines.
  47
  48    $VT$ contains various strings and constants for named objects (variables,
  49    typedefs, functions, etc).  Strings are stored as null-terminated character
  50    lists.  Constants always begin on word boundaries.  The first byte of
  51    the VT must be zero (a null string).
  52
  53    $XT$ is not currently used by GDB.
  54
  55    Many structures within the subspaces point to other structures within
  56    the same subspace, or to structures within a different subspace.  These
  57    pointers are represented as a structure index from the beginning of
  58    the appropriate subspace.  */
  59
  60 /* Used to describe where a constant is stored.  */
  61 enum location_type
  62 {
  63   LOCATION_IMMEDIATE,
  64   LOCATION_PTR,
  65   LOCATION_VT,
  66 };
  67
  68 /* Languages supported by this debug format.  Within the data structures
  69    this type is limited to 4 bits for a maximum of 16 languages.  */
  70 enum hp_language
  71 {
  72   HP_LANGUAGE_UNKNOWN,
  73   HP_LANGUAGE_C,
  74   HP_LANGUAGE_F77,
  75   HP_LANGUAGE_PASCAL,
  76   HP_LANGUAGE_COBOL,
  77   HP_LANGUAGE_BASIC,
  78   HP_LANGUAGE_ADA,
  79   HP_LANGUAGE_CPLUSPLUS,
  80 };
  81
  82
  83 /* Basic data types available in this debug format.  Within the data
  84    structures this type is limited to 5 bits for a maximum of 32 basic
  85    data types.  */
  86 enum hp_type
  87 {
  88   HP_TYPE_UNDEFINED,
  89   HP_TYPE_BOOLEAN,
  90   HP_TYPE_CHAR,
  91   HP_TYPE_INT,
  92   HP_TYPE_UNSIGNED_INT,
  93   HP_TYPE_REAL,
  94   HP_TYPE_COMPLEX,
  95   HP_TYPE_STRING200,
  96   HP_TYPE_LONGSTRING200,
  97   HP_TYPE_TEXT,
  98   HP_TYPE_FLABEL,
  99   HP_TYPE_FTN_STRING_SPEC,
 100   HP_TYPE_MOD_STRING_SPEC,
 101   HP_TYPE_PACKED_DECIMAL,
 102   HP_TYPE_REAL_3000,
 103   HP_TYPE_MOD_STRING_3000,
 104   HP_TYPE_ANYPOINTER,
 105   HP_TYPE_GLOBAL_ANYPOINTER,
 106   HP_TYPE_LOCAL_ANYPOINTER,
 107   HP_TYPE_COMPLEXS3000,
 108   HP_TYPE_FTN_STRING_S300_COMPAT,
 109   HP_TYPE_FTN_STRING_VAX_COMPAT,
 110   HP_TYPE_BOOLEAN_S300_COMPAT,
 111   HP_TYPE_BOOLEAN_VAX_COMPAT,
 112   HP_TYPE_WIDE_CHAR,
 113   HP_TYPE_LONG,
 114   HP_TYPE_UNSIGNED_LONG,
 115   HP_TYPE_DOUBLE,
 116   HP_TYPE_TEMPLATE_ARG,
 117 };
 118
 119 /* An immediate name and type table entry.
 120
 121    extension and immediate will always be one.
 122    global will always be zero.
 123    hp_type is the basic type this entry describes.
 124    bitlength is the length in bits for the basic type.  */
 125 struct dnttp_immediate
 126 {
 127   unsigned int extension:       1;
 128   unsigned int immediate:       1;
 129   unsigned int global:          1;
 130   enum hp_type type:            5;
 131   unsigned int bitlength:       24;
 132 };
 133
 134 /* A nonimmediate name and type table entry.
 135
 136    extension will always be one.
 137    immediate will always be zero.
 138    if global is zero, this entry points into the LNTT
 139    if global is one, this entry points into the GNTT
 140    index is the index within the GNTT or LNTT for this entry.  */
 141 struct dnttp_nonimmediate
 142 {
 143   unsigned int extension:       1;
 144   unsigned int immediate:       1;
 145   unsigned int global:          1;
 146   unsigned int index:           29;
 147 };
 148
 149 /* A pointer to an entry in the GNTT and LNTT tables.  It has two
 150    forms depending on the type being described.
 151
 152    The immediate form is used for simple entries and is one
 153    word.
 154
 155    The nonimmediate form is used for complex entries and contains
 156    an index into the LNTT or GNTT which describes the entire type.
 157
 158    If a dnttpointer is -1, then it is a NIL entry.  */
 159
 160 #define DNTTNIL (-1)
 161 typedef union dnttpointer
 162 {
 163   struct dnttp_immediate dntti;
 164   struct dnttp_nonimmediate dnttp;
 165   int word;
 166 } dnttpointer;
 167
 168 /* An index into the source line table.  As with dnttpointers, a sltpointer
 169    of -1 indicates a NIL entry.  */
 170 #define SLTNIL (-1)
 171 typedef int sltpointer;
 172
 173 /* Unsigned byte offset into the VT.  */
 174 typedef unsigned int vtpointer;
 175
 176 /* A DNTT entry (used within the GNTT and LNTT).
 177
 178    DNTT entries are variable sized objects, but are always a multiple
 179    of 3 words (we call each group of 3 words a "block").
 180
 181    The first bit in each block is an extension bit.  This bit is zero
 182    for the first block of a DNTT entry.  If the entry requires more
 183    than one block, then this bit is set to one in all blocks after
 184    the first one.  */
 185
 186 /* Each DNTT entry describes a particular debug symbol (beginning of
 187    a source file, a function, variables, structures, etc.
 188
 189    The type of the DNTT entry is stored in the "kind" field within the
 190    DNTT entry itself.  */
 191
 192 enum dntt_entry_type
 193 {
 194   DNTT_TYPE_NIL = -1,
 195   DNTT_TYPE_SRCFILE,
 196   DNTT_TYPE_MODULE,
 197   DNTT_TYPE_FUNCTION,
 198   DNTT_TYPE_ENTRY,
 199   DNTT_TYPE_BEGIN,
 200   DNTT_TYPE_END,
 201   DNTT_TYPE_IMPORT,
 202   DNTT_TYPE_LABEL,
 203   DNTT_TYPE_FPARAM,
 204   DNTT_TYPE_SVAR,
 205   DNTT_TYPE_DVAR,
 206   DNTT_TYPE_HOLE1,
 207   DNTT_TYPE_CONST,
 208   DNTT_TYPE_TYPEDEF,
 209   DNTT_TYPE_TAGDEF,
 210   DNTT_TYPE_POINTER,
 211   DNTT_TYPE_ENUM,
 212   DNTT_TYPE_MEMENUM,
 213   DNTT_TYPE_SET,
 214   DNTT_TYPE_SUBRANGE,
 215   DNTT_TYPE_ARRAY,
 216   DNTT_TYPE_STRUCT,
 217   DNTT_TYPE_UNION,
 218   DNTT_TYPE_FIELD,
 219   DNTT_TYPE_VARIANT,
 220   DNTT_TYPE_FILE,
 221   DNTT_TYPE_FUNCTYPE,
 222   DNTT_TYPE_WITH,
 223   DNTT_TYPE_COMMON,
 224   DNTT_TYPE_COBSTRUCT,
 225   DNTT_TYPE_XREF,
 226   DNTT_TYPE_SA,
 227   DNTT_TYPE_MACRO,
 228   DNTT_TYPE_BLOCKDATA,
 229   DNTT_TYPE_CLASS_SCOPE,
 230   DNTT_TYPE_REFERENCE,
 231   DNTT_TYPE_PTRMEM,
 232   DNTT_TYPE_PTRMEMFUNC,
 233   DNTT_TYPE_CLASS,
 234   DNTT_TYPE_GENFIELD,
 235   DNTT_TYPE_VFUNC,
 236   DNTT_TYPE_MEMACCESS,
 237   DNTT_TYPE_INHERITANCE,
 238   DNTT_TYPE_FRIEND_CLASS,
 239   DNTT_TYPE_FRIEND_FUNC,
 240   DNTT_TYPE_MODIFIER,
 241   DNTT_TYPE_OBJECT_ID,
 242   DNTT_TYPE_MEMFUNC,
 243   DNTT_TYPE_TEMPLATE,
 244   DNTT_TYPE_TEMPLATE_ARG,
 245   DNTT_TYPE_FUNC_TEMPLATE,
 246   DNTT_TYPE_LINK,
 247   DNTT_TYPE_MAX,
 248 };
 249
 250 /* DNTT_TYPE_SRCFILE:
 251
 252    One DNTT_TYPE_SRCFILE symbol is output for the start of each source
 253    file and at the begin and end of an included file.  A DNTT_TYPE_SRCFILE
 254    entry is also output before each DNTT_TYPE_FUNC symbol so that debuggers
 255    can determine what file a function was defined in.
 256
 257    LANGUAGE describes the source file's language.
 258
 259    NAME points to an VT entry providing the source file's name.
 260
 261    Note the name used for DNTT_TYPE_SRCFILE entries are exactly as seen
 262    by the compiler (ie they may be relative or absolute).  C include files
 263    via <> inclusion must use absolute paths.
 264
 265    ADDRESS points to an SLT entry from which line number and code locations
 266    may be determined.  */
 267
 268 struct dntt_type_srcfile
 269 {
 270   unsigned int extension:       1;
 271   enum dntt_entry_type kind:    10;
 272   enum hp_language language:    4;
 273   unsigned int unused:          17;
 274   vtpointer name;
 275   sltpointer address;
 276 };
 277
 278 /* DNTT_TYPE_MODULE:
 279
 280    A DNTT_TYPE_MODULE symbol is emitted for the start of a pascal
 281    module or C source file.
 282
 283    Each DNTT_TYPE_MODULE must have an associated DNTT_TYPE_END symbol.
 284
 285    NAME points to a VT entry providing the module's name.  Note C
 286    source files are considered nameless modules.
 287
 288    ALIAS point to a VT entry providing a secondary name.
 289
 290    ADDRESS points to an SLT entry from which line number and code locations
 291    may be determined.  */
 292
 293 struct dntt_type_module
 294 {
 295   unsigned int extension:       1;
 296   enum dntt_entry_type kind:    10;
 297   unsigned int unused:          21;
 298   vtpointer name;
 299   vtpointer alias;
 300   dnttpointer unused2;
 301   sltpointer address;
 302 };
 303
 304 /* DNTT_TYPE_FUNCTION:
 305
 306    A DNTT_TYPE_FUNCTION symbol is emitted for each function definition;
 307    a DNTT_TYPE_ENTRY symbols is used for secondary entry points.  Both
 308    symbols used the dntt_type_function structure.
 309
 310    Each DNTT_TYPE_FUNCTION must have a matching DNTT_TYPE_END.
 311
 312    GLOBAL is nonzero if the function has global scope.
 313
 314    LANGUAGE describes the function's source language.
 315
 316    OPT_LEVEL describes the optimization level the function was compiled
 317    with.
 318
 319    VARARGS is nonzero if the function uses varargs.
 320
 321    NAME points to a VT entry providing the function's name.
 322
 323    ALIAS points to a VT entry providing a secondary name for the function.
 324
 325    FIRSTPARAM points to a LNTT entry which describes the parameter list.
 326
 327    ADDRESS points to an SLT entry from which line number and code locations
 328    may be determined.
 329
 330    ENTRYADDR is the memory address corresponding the the function's entry point
 331
 332    RETVAL points to a LNTT entry describing the function's return value.
 333
 334    LOWADDR is the lowest memory address associated with this function.
 335
 336    HIADDR is the highest memory address associated with this function.  */
 337
 338 struct dntt_type_function
 339 {
 340   unsigned int extension:       1;
 341   enum dntt_entry_type kind:    10;
 342   unsigned int global:          1;
 343   enum hp_language language:    4;
 344   unsigned int nest_level:      5;
 345   unsigned int opt_level:       2;
 346   unsigned int varargs:         1;
 347   unsigned int lang_info:       4;
 348   unsigned int inlined:         1;
 349   unsigned int localalloc:      1;
 350   unsigned int expansion:       1;
 351   unsigned int unused:          1;
 352   vtpointer name;
 353   vtpointer alias;
 354   dnttpointer firstparam;
 355   sltpointer address;
 356   CORE_ADDR entryaddr;
 357   dnttpointer retval;
 358   CORE_ADDR lowaddr;
 359   CORE_ADDR hiaddr;
 360 };
 361
 362 /* DNTT_TYPE_BEGIN:
 363
 364    A DNTT_TYPE_BEGIN symbol is emitted to begin a new nested scope.
 365    Every DNTT_TYPE_BEGIN symbol must have a matching DNTT_TYPE_END symbol.
 366
 367    CLASSFLAG is nonzero if this is the beginning of a c++ class definition.
 368
 369    ADDRESS points to an SLT entry from which line number and code locations
 370    may be determined.  */
 371
 372 struct dntt_type_begin
 373 {
 374   unsigned int extension:       1;
 375   enum dntt_entry_type kind:    10;
 376   unsigned int classflag:       1;
 377   unsigned int unused:          20;
 378   sltpointer address;
 379 };
 380
 381 /* DNTT_TYPE_END:
 382
 383    A DNTT_TYPE_END symbol is emitted when closing a scope started by
 384    a DNTT_TYPE_MODULE, DNTT_TYPE_FUNCTION, and DNTT_TYPE_BEGIN symbols.
 385
 386    ENDKIND describes what type of scope the DNTT_TYPE_END is closing
 387    (DNTT_TYPE_MODULE, DNTT_TYPE_BEGIN, etc).
 388
 389    CLASSFLAG is nonzero if this is the end of a c++ class definition.
 390
 391    ADDRESS points to an SLT entry from which line number and code locations
 392    may be determined.
 393
 394    BEGINSCOPE points to the LNTT entry which opened the scope.  */
 395
 396 struct dntt_type_end
 397 {
 398   unsigned int extension:       1;
 399   enum dntt_entry_type kind:    10;
 400   enum dntt_entry_type endkind: 10;
 401   unsigned int classflag:       1;
 402   unsigned int unused:          10;
 403   sltpointer address;
 404   dnttpointer beginscope;
 405 };
 406
 407 /* DNTT_TYPE_IMPORT is unused by GDB.  */
 408 /* DNTT_TYPE_LABEL is unused by GDB.  */
 409
 410 /* DNTT_TYPE_FPARAM:
 411
 412    A DNTT_TYPE_FPARAM symbol is emitted for a function argument.  When
 413    chained together the symbols represent an argument list for a function.
 414
 415    REGPARAM is nonzero if this parameter was passed in a register.
 416
 417    INDIRECT is nonzero if this parameter is a pointer to the parameter
 418    (pass by reference or pass by value for large items).
 419
 420    LONGADDR is nonzero if the parameter is a 64bit pointer.
 421
 422    NAME is a pointer into the VT for the parameter's name.
 423
 424    LOCATION describes where the parameter is stored.  Depending on the
 425    parameter type LOCATION could be a register number, or an offset
 426    from the stack pointer.
 427
 428    TYPE points to a NTT entry describing the type of this parameter.
 429
 430    NEXTPARAM points to the LNTT entry describing the next parameter.  */
 431
 432 struct dntt_type_fparam
 433 {
 434   unsigned int extension:       1;
 435   enum dntt_entry_type kind:    10;
 436   unsigned int regparam:        1;
 437   unsigned int indirect:        1;
 438   unsigned int longaddr:        1;
 439   unsigned int copyparam:       1;
 440   unsigned int dflt:            1;
 441   unsigned int unused:          16;
 442   vtpointer name;
 443   int location;
 444   dnttpointer type;
 445   dnttpointer nextparam;
 446   int misc;
 447 };
 448
 449 /* DNTT_TYPE_SVAR:
 450
 451    A DNTT_TYPE_SVAR is emitted to describe a variable in static storage.
 452
 453    GLOBAL is nonzero if the variable has global scope.
 454
 455    INDIRECT is nonzero if the variable is a pointer to an object.
 456
 457    LONGADDR is nonzero if the variable is in long pointer space.
 458
 459    STATICMEM is nonzero if the variable is a member of a class.
 460
 461    A_UNION is nonzero if the variable is an anonymous union member.
 462
 463    NAME is a pointer into the VT for the variable's name.
 464
 465    LOCATION provides the memory address for the variable.
 466
 467    TYPE is a pointer into either the GNTT or LNTT which describes
 468    the type of this variable.  */
 469
 470 struct dntt_type_svar
 471 {
 472   unsigned int extension:       1;
 473   enum dntt_entry_type kind:    10;
 474   unsigned int global:          1;
 475   unsigned int indirect:        1;
 476   unsigned int longaddr:        1;
 477   unsigned int staticmem:       1;
 478   unsigned int a_union:         1;
 479   unsigned int unused:          16;
 480   vtpointer name;
 481   CORE_ADDR location;
 482   dnttpointer type;
 483   unsigned int offset;
 484   unsigned int displacement;
 485 };
 486
 487 /* DNTT_TYPE_DVAR:
 488
 489    A DNTT_TYPE_DVAR is emitted to describe automatic variables and variables
 490    held in registers.
 491
 492    GLOBAL is nonzero if the variable has global scope.
 493
 494    INDIRECT is nonzero if the variable is a pointer to an object.
 495
 496    REGVAR is nonzero if the variable is in a register.
 497
 498    A_UNION is nonzero if the variable is an anonymous union member.
 499
 500    NAME is a pointer into the VT for the variable's name.
 501
 502    LOCATION provides the memory address or register number for the variable.
 503
 504    TYPE is a pointer into either the GNTT or LNTT which describes
 505    the type of this variable.  */
 506
 507 struct dntt_type_dvar
 508 {
 509   unsigned int extension:       1;
 510   enum dntt_entry_type kind:    10;
 511   unsigned int global:          1;
 512   unsigned int indirect:        1;
 513   unsigned int regvar:          1;
 514   unsigned int a_union:         1;
 515   unsigned int unused:          17;
 516   vtpointer name;
 517   int location;
 518   dnttpointer type;
 519   unsigned int offset;
 520 };
 521
 522 /* DNTT_TYPE_CONST:
 523
 524    A DNTT_TYPE_CONST symbol is emitted for program constants.
 525
 526    GLOBAL is nonzero if the constant has global scope.
 527
 528    INDIRECT is nonzero if the constant is a pointer to an object.
 529
 530    LOCATION_TYPE describes where to find the constant's value
 531    (in the VT, memory, or embedded in an instruction).
 532
 533    CLASSMEM is nonzero if the constant is a member of a class.
 534
 535    NAME is a pointer into the VT for the constant's name.
 536
 537    LOCATION provides the memory address, register number or pointer
 538    into the VT for the constant's value.
 539
 540    TYPE is a pointer into either the GNTT or LNTT which describes
 541    the type of this variable.  */
 542
 543 struct dntt_type_const
 544 {
 545   unsigned int extension:       1;
 546   enum dntt_entry_type kind:    10;
 547   unsigned int global:          1;
 548   unsigned int indirect:        1;
 549   enum location_type:           3;
 550   unsigned int classmem:        1;
 551   unsigned int unused:          15;
 552   vtpointer name;
 553   CORE_ADDR location;
 554   dnttpointer type;
 555   unsigned int offset;
 556   unsigned int displacement;
 557 };
 558
 559 /* DNTT_TYPE_TYPEDEF and DNTT_TYPE_TAGDEF:
 560
 561    The same structure is used to describe typedefs and tagdefs.
 562
 563    DNTT_TYPE_TYPEDEFS are associated with C "typedefs".
 564
 565    DNTT_TYPE_TAGDEFs are associated with C "struct", "union", and "enum"
 566    tags, which may have the same name as a typedef in the same scope.
 567
 568    GLOBAL is nonzero if the typedef/tagdef has global scope.
 569
 570    TYPEINFO is used to determine if full type information is available
 571    for a tag.  (usually 1, but can be zero for opaque types in C).
 572
 573    NAME is a pointer into the VT for the constant's name.
 574
 575    TYPE points to the underlying type for the typedef/tagdef in the
 576    GNTT or LNTT.  */
 577
 578 struct dntt_type_type
 579 {
 580   unsigned int extension:       1;
 581   enum dntt_entry_type kind:    10;
 582   unsigned int global:          1;
 583   unsigned int typeinfo:        1;
 584   unsigned int unused:          19;
 585   vtpointer name;
 586   dnttpointer type;
 587 };
 588
 589 /* DNTT_TYPE_POINTER:
 590
 591    Used to describe a pointer to an underlying type.
 592
 593    POINTSTO is a pointer into the GNTT or LNTT for the type which this
 594    pointer points to.
 595
 596    BITLENGTH is the length of the pointer (not the underlying type). */
 597
 598 struct dntt_type_pointer
 599 {
 600   unsigned int extension:       1;
 601   enum dntt_entry_type kind:    10;
 602   unsigned int unused:          21;
 603   dnttpointer pointsto;
 604   unsigned int bitlength;
 605 };
 606
 607
 608 /* DNTT_TYPE_ENUM:
 609
 610    Used to describe enumerated types.
 611
 612    FIRSTMEM is a pointer to a DNTT_TYPE_MEMENUM in the GNTT/LNTT which
 613    describes the first member (and contains a pointer to the chain of
 614    members).
 615
 616    BITLENGTH is the number of bits used to hold the values of the enum's
 617    members.  */
 618
 619 struct dntt_type_enum
 620 {
 621   unsigned int extension:       1;
 622   enum dntt_entry_type kind:    10;
 623   unsigned int unused:          21;
 624   dnttpointer firstmem;
 625   unsigned int bitlength;
 626 };
 627
 628 /* DNTT_TYPE_MEMENUM
 629
 630    Used to describe members of an enumerated type.
 631
 632    CLASSMEM is nonzero if this member is part of a class.
 633
 634    NAME points into the VT for the name of this member.
 635
 636    VALUE is the value of this enumeration member.
 637
 638    NEXTMEM points to the next DNTT_TYPE_MEMENUM in the chain.  */
 639
 640 struct dntt_type_memenum
 641 {
 642   unsigned int extension:       1;
 643   enum dntt_entry_type kind:    10;
 644   unsigned int classmem:        1;
 645   unsigned int unused:          20;
 646   vtpointer name;
 647   unsigned int value;
 648   dnttpointer nextmem;
 649 };
 650
 651 /* DNTT_TYPE_SET
 652
 653    DECLARATION describes the bitpacking of the set.
 654
 655    SUBTYPE points to a DNTT entry describing the type of the members.
 656
 657    BITLENGTH is the size of the set.  */
 658
 659 struct dntt_type_set
 660 {
 661   unsigned int extension:       1;
 662   enum dntt_entry_type kind:    10;
 663   unsigned int declaration:     2;
 664   unsigned int unused:          19;
 665   dnttpointer subtype;
 666   unsigned int bitlength;
 667 };
 668
 669 /* DNTT_TYPE_SUBRANGE
 670
 671    DYN_LOW describes the lower bound of the subrange:
 672
 673      00 for a constant lower bound (found in LOWBOUND).
 674
 675      01 for a dynamic lower bound with the lower bound found in the the
 676      memory address pointed to by LOWBOUND.
 677
 678      10 for a dynamic lower bound described by an variable found in the
 679      DNTT/LNTT (LOWBOUND would be a pointer into the DNTT/LNTT).
 680
 681    DYN_HIGH is similar to DYN_LOW, except it describes the upper bound.
 682
 683    SUBTYPE points to the type of the subrange.
 684
 685    BITLENGTH is the length in bits needed to describe the subrange's
 686    values.  */
 687
 688 struct dntt_type_subrange
 689 {
 690   unsigned int extension:       1;
 691   enum dntt_entry_type kind:    10;
 692   unsigned int dyn_low:         2;
 693   unsigned int dyn_high:        2;
 694   unsigned int unused:          17;
 695   int lowbound;
 696   int highbound;
 697   dnttpointer subtype;
 698   unsigned int bitlength;
 699 };
 700
 701 /* DNTT_TYPE_ARRAY
 702
 703    DECLARATION describes the bit packing used in the array.
 704
 705    ARRAYISBYTES is nonzero if the field in arraylength describes the
 706    length in bytes rather than in bits.  A value of zero is used to
 707    describe an array with size 2**32.
 708
 709    ELEMISBYTES is nonzero if the length if each element in the array
 710    is describes in bytes rather than bits.  A value of zero is used
 711    to an element with size 2**32.
 712
 713    ELEMORDER is nonzero if the elements are indexed in increasing order.
 714
 715    JUSTIFIED if the elements are left justified to index zero.
 716
 717    ARRAYLENGTH is the length of the array.
 718
 719    INDEXTYPE is a DNTT pointer to the type used to index the array.
 720
 721    ELEMTYPE is a DNTT pointer to the type for the array elements.
 722
 723    ELEMLENGTH is the length of each element in the array (including
 724    any padding).
 725
 726    Multi-dimensional arrays are represented by ELEMTYPE pointing to
 727    another DNTT_TYPE_ARRAY.  */
 728
 729 struct dntt_type_array
 730 {
 731   unsigned int extension:       1;
 732   enum dntt_entry_type kind:    10;
 733   unsigned int declaration:     2;
 734   unsigned int dyn_low:         2;
 735   unsigned int dyn_high:        2;
 736   unsigned int arrayisbytes:    1;
 737   unsigned int elemisbytes:     1;
 738   unsigned int elemorder:       1;
 739   unsigned int justified:       1;
 740   unsigned int unused:          11;
 741   unsigned int arraylength;
 742   dnttpointer indextype;
 743   dnttpointer elemtype;
 744   unsigned int elemlength;
 745 };
 746
 747 /* DNTT_TYPE_STRUCT
 748
 749    DNTT_TYPE_STRUCT is used to describe a C structure.
 750
 751    DECLARATION describes the bitpacking used.
 752
 753    FIRSTFIELD is a DNTT pointer to the first field of the structure
 754    (each field contains a pointer to the next field, walk the list
 755    to access all fields of the structure).
 756
 757    VARTAGFIELD and VARLIST are used for Pascal variant records.
 758
 759    BITLENGTH is the size of the structure in bits.  */
 760
 761 struct dntt_type_struct
 762 {
 763   unsigned int extension:       1;
 764   enum dntt_entry_type kind:    10;
 765   unsigned int declaration:     2;
 766   unsigned int unused:          19;
 767   dnttpointer firstfield;
 768   dnttpointer vartagfield;
 769   dnttpointer varlist;
 770   unsigned int bitlength;
 771 };
 772
 773 /* DNTT_TYPE_UNION
 774
 775    DNTT_TYPE_UNION is used to describe a C union.
 776
 777    FIRSTFIELD is a DNTT pointer to the beginning of the field chain.
 778
 779    BITLENGTH is the size of the union in bits.  */
 780
 781 struct dntt_type_union
 782 {
 783   unsigned int extension:       1;
 784   enum dntt_entry_type kind:    10;
 785   unsigned int unused:          21;
 786   dnttpointer firstfield;
 787   unsigned int bitlength;
 788 };
 789
 790 /* DNTT_TYPE_FIELD
 791
 792    DNTT_TYPE_FIELD describes one field in a structure or union.
 793
 794    VISIBILITY is used to describe the visibility of the field
 795    (for c++.  public = 0, protected = 1, private = 2).
 796
 797    A_UNION is nonzero if this field is a member of an anonymous union.
 798
 799    STATICMEM is nonzero if this field is a static member of a template.
 800
 801    NAME is a pointer into the VT for the name of the field.
 802
 803    BITOFFSET gives the offset of this field in bits from the beginning
 804    of the structure or union this field is a member of.
 805
 806    TYPE is a DNTT pointer to the type describing this field.
 807
 808    BITLENGTH is the size of the entry in bits.
 809
 810    NEXTFIELD is a DNTT pointer to the next field in the chain.  */
 811
 812 struct dntt_type_field
 813 {
 814   unsigned int extension:       1;
 815   enum dntt_entry_type kind:    10;
 816   unsigned int visibility:      2;
 817   unsigned int a_union:         1;
 818   unsigned int staticmem:       1;
 819   unsigned int unused:          17;
 820   vtpointer name;
 821   unsigned int bitoffset;
 822   dnttpointer type;
 823   unsigned int bitlength;
 824   dnttpointer nextfield;
 825 };
 826
 827 /* DNTT_TYPE_VARIANT is unused by GDB.  */
 828 /* DNTT_TYPE_FILE is unused by GDB.  */
 829
 830 /* DNTT_TYPE_COMMON is unused by GDB.  */
 831 /* DNTT_TYPE_LINK is unused by GDB.  */
 832 /* DNTT_TYPE_FFUNC_LINK is unused by GDB.  */
 833 /* DNTT_TYPE_TEMPLATE is unused by GDB.  */
 834
 835 /* DNTT_TYPE_FUNCTYPE
 836
 837    VARARGS is nonzero if this function uses varargs.
 838
 839    FIRSTPARAM is a DNTT pointer to the first entry in the parameter
 840    chain.
 841
 842    RETVAL is a DNTT pointer to the type of the return value.  */
 843
 844 struct dntt_type_functype
 845 {
 846   unsigned int extension:       1;
 847   enum dntt_entry_type kind:    10;
 848   unsigned int varargs:         1;
 849   unsigned int info:            4;
 850   unsigned int unused:          16;
 851   unsigned int bitlength;
 852   dnttpointer firstparam;
 853   dnttpointer retval;
 854 };
 855
 856 /* DNTT_TYPE_WITH is unued by GDB.  */
 857 /* DNTT_TYPE_COBSTRUCT is unused by GDB.  */
 858 /* DNTT_TYPE_MODIFIER is unused by GDB.  */
 859 /* DNTT_TYPE_GENFIELD is unused by GDB.  */
 860 /* DNTT_TYPE_MEMACCESS is unused by GDB.  */
 861 /* DNTT_TYPE_VFUNC is unused by GDB.  */
 862 /* DNTT_TYPE_CLASS_SCOPE is unused by GDB.  */
 863 /* DNTT_TYPE_FRIEND_CLASS is unused by GDB.  */
 864 /* DNTT_TYPE_FRIEND_FUNC is unused by GDB.  */
 865 /* DNTT_TYPE_CLASS unused by GDB.  */
 866 /* DNTT_TYPE_TEMPLATE unused by GDB.  */
 867 /* DNTT_TYPE_TEMPL_ARG is unused by GDB.  */
 868 /* DNTT_TYPE_PTRMEM not used by GDB */
 869 /* DNTT_TYPE_INHERITANCE is unused by GDB.  */
 870 /* DNTT_TYPE_OBJECT_ID is unused by GDB. */
 871 /* DNTT_TYPE_XREF is unused by GDB.  */
 872 /* DNTT_TYPE_SA is unused by GDB.  */
 873
 874 /* DNTT_TYPE_GENERIC and DNTT_TYPE_BLOCK are convience structures
 875    so we can examine a DNTT entry in a generic fashion.  */
 876 struct dntt_type_generic
 877 {
 878   unsigned int word[9];
 879 };
 880
 881 struct dntt_type_block
 882 {
 883   unsigned int extension:       1;
 884   enum dntt_entry_type kind:    10;
 885   unsigned int unused:          21;
 886   unsigned int word[2];
 887 };
 888
 889 /* One entry in a DNTT (either the LNTT or GNTT).  */
 890 union dnttentry
 891 {
 892   struct dntt_type_srcfile dsfile;
 893   struct dntt_type_module dmodule;
 894   struct dntt_type_function dfunc;
 895   struct dntt_type_function dentry;
 896   struct dntt_type_begin dbegin;
 897   struct dntt_type_end dend;
 898   struct dntt_type_fparam dfparam;
 899   struct dntt_type_svar dsvar;
 900   struct dntt_type_dvar ddvar;
 901   struct dntt_type_const dconst;
 902   struct dntt_type_type dtype;
 903   struct dntt_type_type dtag;
 904   struct dntt_type_pointer dptr;
 905   struct dntt_type_enum denum;
 906   struct dntt_type_memenum dmember;
 907   struct dntt_type_set dset;
 908   struct dntt_type_subrange dsubr;
 909   struct dntt_type_array darray;
 910   struct dntt_type_struct dstruct;
 911   struct dntt_type_union dunion;
 912   struct dntt_type_field dfield;
 913   struct dntt_type_functype dfunctype;
 914   struct dntt_type_generic dgeneric;
 915   struct dntt_type_block dblock;
 916 };
 917
 918 /* Source line entry types.  */
 919 enum slttype
 920 {
 921   SLT_NORMAL,
 922   SLT_SRCFILE,
 923   SLT_MODULE,
 924   SLT_FUNCTION,
 925   SLT_ENTRY,
 926   SLT_BEGIN,
 927   SLT_END,
 928   SLT_WITH,
 929   SLT_EXIT,
 930   SLT_ASSIST,
 931   SLT_MARKER,
 932 };
 933
 934 /* A normal source line entry.  Simply provides a mapping of a source
 935    line number to a code address.
 936
 937    SLTDESC will always be SLT_NORMAL or SLT_EXIT.  */
 938
 939 struct slt_normal
 940 {
 941   enum slttype sltdesc: 4;
 942   unsigned int line:    28;
 943   CORE_ADDR address;
 944 };
 945
 946 /* A special source line entry.  Provides a mapping of a declaration
 947    to a line number.  These entries point back into the DNTT which
 948    references them.  */
 949
 950 struct slt_special
 951 {
 952   enum slttype sltdesc: 4;
 953   unsigned int line:    28;
 954   dnttpointer backptr;
 955 };
 956
 957 /* Used to describe nesting.
 958
 959    For nested languages, an slt_assist entry must follow each SLT_FUNC
 960    entry in the SLT.  The address field will point forward to the
 961    first slt_normal entry within the function's scope.  */
 962
 963 struct slt_assist
 964 {
 965   enum slttype sltdesc: 4;
 966   unsigned int unused:  28;
 967   sltpointer address;
 968 };
 969
 970 struct slt_generic
 971 {
 972   unsigned int word[2];
 973 };
 974
 975 union sltentry
 976 {
 977   struct slt_normal snorm;
 978   struct slt_special sspec;
 979   struct slt_assist sasst;
 980   struct slt_generic sgeneric;
 981 };
 982
 983 #endif /* HP_SYMTAB_INCLUDED */