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., 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 1875