1 /* Definitions and structures for reading debug symbols from the 2 native HP C compiler. 3 4 Written by the Center for Software Science at the University of Utah 5 and by Cygnus Support. 6 7 Copyright 1994, 1995, 1998, 1999, 2003 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 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 unsigned int global: 1; 638 unsigned int typeinfo: 1; 639 unsigned int unused: 19; 640 vtpointer name; 641 dnttpointer type; /* Underlying type, which for TAGDEF's may be 642 DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, 643 DNTT_TYPE_ENUM, or DNTT_TYPE_CLASS. 644 For TYPEDEF's other underlying types 645 are also possible. */ 646 }; 647 648 /* DNTT_TYPE_POINTER: 649 650 Used to describe a pointer to an underlying type. 651 652 POINTSTO is a pointer into the GNTT or LNTT for the type which this 653 pointer points to. 654 655 BITLENGTH is the length of the pointer (not the underlying type). */ 656 657 struct dntt_type_pointer 658 { 659 unsigned int extension: 1; 660 unsigned int kind: 10; 661 unsigned int unused: 21; 662 dnttpointer pointsto; 663 unsigned int bitlength; 664 }; 665 666 667 /* DNTT_TYPE_ENUM: 668 669 Used to describe enumerated types. 670 671 FIRSTMEM is a pointer to a DNTT_TYPE_MEMENUM in the GNTT/LNTT which 672 describes the first member (and contains a pointer to the chain of 673 members). 674 675 BITLENGTH is the number of bits used to hold the values of the enum's 676 members. */ 677 678 struct dntt_type_enum 679 { 680 unsigned int extension: 1; 681 unsigned int kind: 10; 682 unsigned int unused: 21; 683 dnttpointer firstmem; 684 unsigned int bitlength; 685 }; 686 687 /* DNTT_TYPE_MEMENUM 688 689 Used to describe members of an enumerated type. 690 691 CLASSMEM is nonzero if this member is part of a class. 692 693 NAME points into the VT for the name of this member. 694 695 VALUE is the value of this enumeration member. 696 697 NEXTMEM points to the next DNTT_TYPE_MEMENUM in the chain. */ 698 699 struct dntt_type_memenum 700 { 701 unsigned int extension: 1; 702 unsigned int kind: 10; 703 unsigned int classmem: 1; 704 unsigned int unused: 20; 705 vtpointer name; 706 unsigned int value; 707 dnttpointer nextmem; 708 }; 709 710 /* DNTT_TYPE_SET 711 712 Used to describe PASCAL "set" type. 713 714 DECLARATION describes the bitpacking of the set. 715 716 SUBTYPE points to a DNTT entry describing the type of the members. 717 718 BITLENGTH is the size of the set. */ 719 720 struct dntt_type_set 721 { 722 unsigned int extension: 1; 723 unsigned int kind: 10; 724 unsigned int declaration: 2; 725 unsigned int unused: 19; 726 dnttpointer subtype; 727 unsigned int bitlength; 728 }; 729 730 /* DNTT_TYPE_SUBRANGE 731 732 Used to describe subrange type. 733 734 DYN_LOW describes the lower bound of the subrange: 735 736 00 for a constant lower bound (found in LOWBOUND). 737 738 01 for a dynamic lower bound with the lower bound found in the 739 memory address pointed to by LOWBOUND. 740 741 10 for a dynamic lower bound described by an variable found in the 742 DNTT/LNTT (LOWBOUND would be a pointer into the DNTT/LNTT). 743 744 DYN_HIGH is similar to DYN_LOW, except it describes the upper bound. 745 746 SUBTYPE points to the type of the subrange. 747 748 BITLENGTH is the length in bits needed to describe the subrange's 749 values. */ 750 751 struct dntt_type_subrange 752 { 753 unsigned int extension: 1; 754 unsigned int kind: 10; 755 unsigned int dyn_low: 2; 756 unsigned int dyn_high: 2; 757 unsigned int unused: 17; 758 int lowbound; 759 int highbound; 760 dnttpointer subtype; 761 unsigned int bitlength; 762 }; 763 764 /* DNTT_TYPE_ARRAY 765 766 Used to describe an array type. 767 768 DECLARATION describes the bit packing used in the array. 769 770 ARRAYISBYTES is nonzero if the field in arraylength describes the 771 length in bytes rather than in bits. A value of zero is used to 772 describe an array with size 2**32. 773 774 ELEMISBYTES is nonzero if the length if each element in the array 775 is describes in bytes rather than bits. A value of zero is used 776 to an element with size 2**32. 777 778 ELEMORDER is nonzero if the elements are indexed in increasing order. 779 780 JUSTIFIED if the elements are left justified to index zero. 781 782 ARRAYLENGTH is the length of the array. 783 784 INDEXTYPE is a DNTT pointer to the type used to index the array. 785 786 ELEMTYPE is a DNTT pointer to the type for the array elements. 787 788 ELEMLENGTH is the length of each element in the array (including 789 any padding). 790 791 Multi-dimensional arrays are represented by ELEMTYPE pointing to 792 another DNTT_TYPE_ARRAY. */ 793 794 struct dntt_type_array 795 { 796 unsigned int extension: 1; 797 unsigned int kind: 10; 798 unsigned int declaration: 2; 799 unsigned int dyn_low: 2; 800 unsigned int dyn_high: 2; 801 unsigned int arrayisbytes: 1; 802 unsigned int elemisbytes: 1; 803 unsigned int elemorder: 1; 804 unsigned int justified: 1; 805 unsigned int unused: 11; 806 unsigned int arraylength; 807 dnttpointer indextype; 808 dnttpointer elemtype; 809 unsigned int elemlength; 810 }; 811 812 /* DNTT_TYPE_STRUCT 813 814 DNTT_TYPE_STRUCT is used to describe a C structure. 815 816 DECLARATION describes the bitpacking used. 817 818 FIRSTFIELD is a DNTT pointer to the first field of the structure 819 (each field contains a pointer to the next field, walk the list 820 to access all fields of the structure). 821 822 VARTAGFIELD and VARLIST are used for Pascal variant records. 823 824 BITLENGTH is the size of the structure in bits. */ 825 826 struct dntt_type_struct 827 { 828 unsigned int extension: 1; 829 unsigned int kind: 10; 830 unsigned int declaration: 2; 831 unsigned int unused: 19; 832 dnttpointer firstfield; 833 dnttpointer vartagfield; 834 dnttpointer varlist; 835 unsigned int bitlength; 836 }; 837 838 /* DNTT_TYPE_UNION 839 840 DNTT_TYPE_UNION is used to describe a C union. 841 842 FIRSTFIELD is a DNTT pointer to the beginning of the field chain. 843 844 BITLENGTH is the size of the union in bits. */ 845 846 struct dntt_type_union 847 { 848 unsigned int extension: 1; 849 unsigned int kind: 10; 850 unsigned int unused: 21; 851 dnttpointer firstfield; 852 unsigned int bitlength; 853 }; 854 855 /* DNTT_TYPE_FIELD 856 857 DNTT_TYPE_FIELD describes one field in a structure or union 858 or C++ class. 859 860 VISIBILITY is used to describe the visibility of the field 861 (for c++. public = 0, protected = 1, private = 2). 862 863 A_UNION is nonzero if this field is a member of an anonymous union. 864 865 STATICMEM is nonzero if this field is a static member of a template. 866 867 NAME is a pointer into the VT for the name of the field. 868 869 BITOFFSET gives the offset of this field in bits from the beginning 870 of the structure or union this field is a member of. 871 872 TYPE is a DNTT pointer to the type describing this field. 873 874 BITLENGTH is the size of the entry in bits. 875 876 NEXTFIELD is a DNTT pointer to the next field in the chain. */ 877 878 struct dntt_type_field 879 { 880 unsigned int extension: 1; 881 unsigned int kind: 10; 882 unsigned int visibility: 2; 883 unsigned int a_union: 1; 884 unsigned int staticmem: 1; 885 unsigned int unused: 17; 886 vtpointer name; 887 unsigned int bitoffset; 888 dnttpointer type; 889 unsigned int bitlength; 890 dnttpointer nextfield; 891 }; 892 893 /* DNTT_TYPE_VARIANT is unused by GDB. */ 894 /* DNTT_TYPE_FILE is unused by GDB. */ 895 896 /* DNTT_TYPE_FUNCTYPE 897 898 I think this is used to describe a function type (e.g., would 899 be emitted as part of a function-pointer description). 900 901 VARARGS is nonzero if this function uses varargs. 902 903 FIRSTPARAM is a DNTT pointer to the first entry in the parameter 904 chain. 905 906 RETVAL is a DNTT pointer to the type of the return value. */ 907 908 struct dntt_type_functype 909 { 910 unsigned int extension: 1; 911 unsigned int kind: 10; 912 unsigned int varargs: 1; 913 unsigned int info: 4; 914 unsigned int unused: 16; 915 unsigned int bitlength; 916 dnttpointer firstparam; 917 dnttpointer retval; 918 }; 919 920 /* DNTT_TYPE_WITH is emitted by C++ to indicate "with" scoping semantics. 921 (Probably also emitted by PASCAL to support "with"...). 922 923 C++ example: Say "memfunc" is a method of class "c", and say 924 "m" is a data member of class "c". Then from within "memfunc", 925 it is legal to reference "m" directly (e.g. you don't have to 926 say "this->m". The symbol table indicates 927 this by emitting a DNTT_TYPE_WITH symbol within the function "memfunc", 928 pointing to the type symbol for class "c". 929 930 In GDB, this symbol record is unnecessary, 931 because GDB's symbol lookup algorithm 932 infers the "with" semantics when it sees a "this" argument to the member 933 function. So GDB can safely ignore the DNTT_TYPE_WITH record. 934 935 A DNTT_TYPE_WITH has a matching DNTT_TYPE_END symbol. */ 936 937 struct dntt_type_with 938 { 939 unsigned int extension: 1; /* always zero */ 940 unsigned int kind: 10; /* always DNTT_TYPE_WITH */ 941 unsigned int addrtype: 2; /* 0 => STATTYPE */ 942 /* 1 => DYNTYPE */ 943 /* 2 => REGTYPE */ 944 unsigned int indirect: 1; /* 1 => pointer to object */ 945 unsigned int longaddr: 1; /* 1 => in long pointer space */ 946 unsigned int nestlevel: 6; /* # of nesting levels back */ 947 unsigned int doc_ranges: 1; /* 1 => location is range list */ 948 unsigned int unused: 10; 949 long location; /* where stored (allocated) */ 950 sltpointer address; 951 dnttpointer type; /* type of with expression */ 952 vtpointer name; /* name of with expression */ 953 unsigned long offset; /* byte offset from location */ 954 }; 955 956 /* DNTT_TYPE_COMMON is unsupported by GDB. */ 957 /* A DNTT_TYPE_COMMON symbol must have a matching DNTT_TYPE_END symbol */ 958 959 /* DNTT_TYPE_COBSTRUCT is unsupported by GDB. */ 960 /* DNTT_TYPE_XREF is unsupported by GDB. */ 961 /* DNTT_TYPE_SA is unsupported by GDB. */ 962 /* DNTT_TYPE_MACRO is unsupported by GDB */ 963 964 /* DNTT_TYPE_BLOCKDATA has the same structure as DNTT_TYPE_FUNCTION */ 965 966 /* The following are the C++ specific SOM records */ 967 968 /* The purpose of the DNTT_TYPE_CLASS_SCOPE is to bracket C++ methods 969 and indicate the method name belongs in the "class scope" rather 970 than in the module they are being defined in. For example: 971 972 class c { 973 ... 974 void memfunc(); // member function 975 }; 976 977 void c::memfunc() // definition of class c's "memfunc" 978 { 979 ... 980 } 981 982 main() 983 { 984 ... 985 } 986 987 In the above, the name "memfunc" is not directly visible from "main". 988 I.e., you have to say "break c::memfunc". 989 If it were a normal function (not a method), it would be visible 990 via the simple "break memfunc". Since "memfunc" otherwise looks 991 like a normal FUNCTION in the symbol table, the bracketing 992 CLASS_SCOPE is what is used to indicate it is really a method. 993 994 995 A DNTT_TYPE_CLASS_SCOPE symbol must have a matching DNTT_TYPE_END symbol. */ 996 997 struct dntt_type_class_scope 998 { 999 unsigned int extension: 1; /* Always zero. */ 1000 unsigned int kind: 10; /* Always DNTT_TYPE_CLASS_SCOPE. */ 1001 unsigned int unused: 21; 1002 sltpointer address ; /* Pointer to SLT entry. */ 1003 dnttpointer type ; /* Pointer to class type DNTT. */ 1004 }; 1005 1006 /* C++ reference parameter. 1007 The structure of this record is the same as DNTT_TYPE_POINTER - 1008 refer to struct dntt_type_pointer. */ 1009 1010 /* The next two describe C++ pointer-to-data-member type, and 1011 pointer-to-member-function type, respectively. 1012 DNTT_TYPE_PTRMEM and DNTT_TYPE_PTRMEMFUNC have the same structure. */ 1013 1014 struct dntt_type_ptrmem 1015 { 1016 unsigned int extension: 1; /* Always zero. */ 1017 unsigned int kind: 10; /* Always DNTT_TYPE_PTRMEM. */ 1018 unsigned int unused: 21; 1019 dnttpointer pointsto ; /* Pointer to class DNTT. */ 1020 dnttpointer memtype ; /* Type of member. */ 1021 }; 1022 1023 struct dntt_type_ptrmemfunc 1024 { 1025 unsigned int extension: 1; /* Always zero. */ 1026 unsigned int kind: 10; /* Always DNTT_TYPE_PTRMEMFUNC. */ 1027 unsigned int unused: 21; 1028 dnttpointer pointsto ; /* Pointer to class DNTT. */ 1029 dnttpointer memtype ; /* Type of member. */ 1030 }; 1031 1032 /* The DNTT_TYPE_CLASS symbol is emitted to describe a class type. 1033 "memberlist" points to a chained list of FIELD or GENFIELD records 1034 indicating the class members. "parentlist" points to a chained list 1035 of INHERITANCE records indicating classes from which we inherit 1036 fields. */ 1037 1038 struct dntt_type_class 1039 { 1040 unsigned int extension: 1; /* Always zero. */ 1041 unsigned int kind: 10; /* Always DNTT_TYPE_CLASS. */ 1042 unsigned int abstract: 1; /* Is this an abstract class? */ 1043 unsigned int class_decl: 2; /* 0=class,1=union,2=struct. */ 1044 unsigned int expansion: 1; /* 1=template expansion. */ 1045 unsigned int unused: 17; 1046 dnttpointer memberlist ; /* Ptr to chain of [GEN]FIELDs. */ 1047 unsigned long vtbl_loc ; /* Offset in obj of ptr to vtbl. */ 1048 dnttpointer parentlist ; /* Ptr to K_INHERITANCE list. */ 1049 unsigned long bitlength ; /* Total at this level. */ 1050 dnttpointer identlist ; /* Ptr to chain of class ident's. */ 1051 dnttpointer friendlist ; /* Ptr to K_FRIEND list. */ 1052 dnttpointer templateptr ; /* Ptr to template. */ 1053 dnttpointer nextexp ; /* Ptr to next expansion. */ 1054 }; 1055 1056 /* Class members are indicated via either the FIELD record (for 1057 data members, same as for C struct fields), or by the GENFIELD record 1058 (for member functions). */ 1059 1060 struct dntt_type_genfield 1061 { 1062 unsigned int extension: 1; /* Always zero. */ 1063 unsigned int kind: 10; /* Always DNTT_TYPE_GENFIELD. */ 1064 unsigned int visibility: 2; /* Pub = 0, prot = 1, priv = 2. */ 1065 unsigned int a_union: 1; /* 1 => anonymous union member. */ 1066 unsigned int unused: 18; 1067 dnttpointer field ; /* Pointer to field or qualifier. */ 1068 dnttpointer nextfield ; /* Pointer to next field. */ 1069 }; 1070 1071 /* C++ virtual functions. */ 1072 1073 struct dntt_type_vfunc 1074 { 1075 unsigned int extension: 1; /* always zero */ 1076 unsigned int kind: 10; /* always DNTT_TYPE_VFUNC */ 1077 unsigned int pure: 1; /* pure virtual function ? */ 1078 unsigned int unused: 20; 1079 dnttpointer funcptr ; /* points to FUNCTION symbol */ 1080 unsigned long vtbl_offset ; /* offset into vtbl for virtual */ 1081 }; 1082 1083 /* Not precisely sure what this is intended for - DDE ignores it. */ 1084 1085 struct dntt_type_memaccess 1086 { 1087 unsigned int extension: 1; /* always zero */ 1088 unsigned int kind: 10; /* always DNTT_TYPE_MEMACCESS */ 1089 unsigned int unused: 21; 1090 dnttpointer classptr ; /* pointer to base class */ 1091 dnttpointer field ; /* pointer field */ 1092 }; 1093 1094 /* The DNTT_TYPE_INHERITANCE record describes derived classes. 1095 In particular, the "parentlist" field of the CLASS record points 1096 to a list of INHERITANCE records for classes from which we 1097 inherit members. */ 1098 1099 struct dntt_type_inheritance 1100 { 1101 unsigned int extension: 1; /* always zero */ 1102 unsigned int kind: 10; /* always DNTT_TYPE_INHERITANCE */ 1103 unsigned int Virtual: 1; /* virtual base class ? */ 1104 unsigned int visibility: 2; /* pub = 0, prot = 1, priv = 2 */ 1105 unsigned int unused: 18; 1106 dnttpointer classname ; /* first parent class, if any */ 1107 unsigned long offset ; /* offset to start of base class */ 1108 dnttpointer next ; /* pointer to next K_INHERITANCE */ 1109 unsigned long future[2] ; /* padding to 3-word block end */ 1110 }; 1111 1112 /* C++ "friend" classes ... */ 1113 1114 struct dntt_type_friend_class 1115 { 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 { 1125 unsigned int extension: 1; /* always zero */ 1126 unsigned int kind: 10; /* always DNTT_TYPE_FRIEND_FUNC */ 1127 unsigned int unused: 21; 1128 dnttpointer funcptr ; /* pointer to function */ 1129 dnttpointer classptr ; /* pointer to class DNTT */ 1130 dnttpointer next ; /* next DNTT_FRIEND */ 1131 unsigned long future[2] ; /* padding to 3-word block end */ 1132 }; 1133 1134 /* DDE appears to ignore the DNTT_TYPE_MODIFIER record. 1135 It could perhaps be used to give better "ptype" output in GDB; 1136 otherwise it is probably safe for GDB to ignore it also. */ 1137 1138 struct dntt_type_modifier 1139 { 1140 unsigned int extension: 1; /* always zero */ 1141 unsigned int kind: 10; /* always DNTT_TYPE_MODIFIER */ 1142 unsigned int m_const: 1; /* const */ 1143 unsigned int m_static: 1; /* static */ 1144 unsigned int m_void: 1; /* void */ 1145 unsigned int m_volatile: 1; /* volatile */ 1146 unsigned int m_duplicate: 1; /* duplicate */ 1147 unsigned int unused: 16; 1148 dnttpointer type ; /* subtype */ 1149 unsigned long future ; /* padding to 3-word block end */ 1150 }; 1151 1152 /* I'm not sure what this was intended for - DDE ignores it. */ 1153 1154 struct dntt_type_object_id 1155 { 1156 unsigned int extension: 1; /* always zero */ 1157 unsigned int kind: 10; /* always DNTT_TYPE_OBJECT_ID */ 1158 unsigned int indirect: 1; /* Is object_ident addr of addr? */ 1159 unsigned int unused: 20; 1160 unsigned long object_ident ; /* object identifier */ 1161 unsigned long offset ; /* offset to start of base class */ 1162 dnttpointer next ; /* pointer to next K_OBJECT_ID */ 1163 unsigned long segoffset ; /* for linker fixup */ 1164 unsigned long future ; /* padding to 3-word block end */ 1165 }; 1166 1167 /* No separate dntt_type_memfunc; same as dntt_type_func */ 1168 1169 /* Symbol records to support templates. These only get used 1170 in DDE's "describe" output (like GDB's "ptype"). */ 1171 1172 /* The TEMPLATE record is the header for a template-class. 1173 Like the CLASS record, a TEMPLATE record has a memberlist that 1174 points to a list of template members. It also has an arglist 1175 pointing to a list of TEMPLATE_ARG records. */ 1176 1177 struct dntt_type_template 1178 { 1179 unsigned int extension: 1; /* always zero */ 1180 unsigned int kind: 10; /* always DNTT_TYPE_TEMPLATE */ 1181 unsigned int abstract: 1; /* is this an abstract class? */ 1182 unsigned int class_decl: 2; /* 0=class,1=union,2=struct */ 1183 unsigned int unused: 18; 1184 dnttpointer memberlist ; /* ptr to chain of K_[GEN]FIELDs */ 1185 long unused2 ; /* offset in obj of ptr to vtbl */ 1186 dnttpointer parentlist ; /* ptr to K_INHERITANCE list */ 1187 unsigned long bitlength ; /* total at this level */ 1188 dnttpointer identlist ; /* ptr to chain of class ident's */ 1189 dnttpointer friendlist ; /* ptr to K_FRIEND list */ 1190 dnttpointer arglist ; /* ptr to argument list */ 1191 dnttpointer expansions ; /* ptr to expansion list */ 1192 }; 1193 1194 /* Template-class arguments are a list of TEMPL_ARG records 1195 chained together. The "name" field is the name of the formal. 1196 E.g.: 1197 1198 template <class T> class q { ... }; 1199 1200 Then "T" is the name of the formal argument. */ 1201 1202 struct dntt_type_templ_arg 1203 { 1204 unsigned int extension: 1; /* always zero */ 1205 unsigned int kind: 10; /* always DNTT_TYPE_TEMPL_ARG */ 1206 unsigned int usagetype: 1; /* 0 type-name 1 expression */ 1207 unsigned int unused: 20; 1208 vtpointer name ; /* name of argument */ 1209 dnttpointer type ; /* for non type arguments */ 1210 dnttpointer nextarg ; /* Next argument if any */ 1211 long future[2] ; /* padding to 3-word block end */ 1212 }; 1213 1214 /* FUNC_TEMPLATE records are sort of like FUNCTION, but are emitted 1215 for template member functions. E.g., 1216 1217 template <class T> class q 1218 { 1219 ... 1220 void f(); 1221 ... 1222 }; 1223 1224 Within the list of FIELDs/GENFIELDs defining the member list 1225 of the template "q", "f" would appear as a FUNC_TEMPLATE. 1226 We'll also see instances of FUNCTION "f" records for each 1227 instantiation of the template. */ 1228 1229 struct dntt_type_func_template 1230 { 1231 unsigned int extension: 1; /* always zero */ 1232 unsigned int kind: 10; /* always DNTT_TYPE_FUNC_TEMPLATE */ 1233 unsigned int public: 1; /* 1 => globally visible */ 1234 unsigned int language: 4; /* type of language */ 1235 unsigned int level: 5; /* nesting level (top level = 0)*/ 1236 unsigned int optimize: 2; /* level of optimization */ 1237 unsigned int varargs: 1; /* ellipses. Pascal/800 later */ 1238 unsigned int info: 4; /* lang-specific stuff; F_xxxx */ 1239 unsigned int inlined: 1; 1240 unsigned int localloc: 1; /* 0 at top, 1 at end of block */ 1241 unsigned int unused: 2; 1242 vtpointer name ; /* name of function */ 1243 vtpointer alias ; /* alternate name, if any */ 1244 dnttpointer firstparam ; /* first FPARAM, if any */ 1245 dnttpointer retval ; /* return type, if any */ 1246 dnttpointer arglist ; /* ptr to argument list */ 1247 }; 1248 1249 /* LINK is apparently intended to link together function template 1250 definitions with their instantiations. However, it is not clear 1251 why this would be needed, except to provide the information on 1252 a "ptype" command. And as far as I can tell, aCC does not 1253 generate this record. */ 1254 1255 struct dntt_type_link 1256 { 1257 unsigned int extension: 1; /* always zero */ 1258 unsigned int kind: 10; /* always DNTT_TYPE_LINK */ 1259 unsigned int linkKind: 4; /* always LINK_UNKNOWN */ 1260 unsigned int unused: 17; 1261 long future1 ; /* expansion */ 1262 dnttpointer ptr1 ; /* link from template */ 1263 dnttpointer ptr2 ; /* to expansion */ 1264 long future[2] ; /* padding to 3-word block end */ 1265 }; 1266 1267 /* end of C++ specific SOM's. */ 1268 1269 /* DNTT_TYPE_DYN_ARRAY_DESC is unused by GDB */ 1270 /* DNTT_TYPE_DESC_SUBRANGE is unused by GDB */ 1271 /* DNTT_TYPE_BEGIN_EXT is unused by GDB */ 1272 /* DNTT_TYPE_INLN is unused by GDB */ 1273 /* DNTT_TYPE_INLN_LIST is unused by GDB */ 1274 /* DNTT_TYPE_ALIAS is unused by GDB */ 1275 1276 struct dntt_type_doc_function 1277 { 1278 unsigned int extension: 1; /* always zero */ 1279 unsigned int kind: 10; /* K_DOC_FUNCTION or */ 1280 /* K_DOC_MEMFUNC */ 1281 unsigned int global: 1; /* 1 => globally visible */ 1282 unsigned int language: 4; /* type of language */ 1283 unsigned int level: 5; /* nesting level (top level = 0)*/ 1284 unsigned int optimize: 2; /* level of optimization */ 1285 unsigned int varargs: 1; /* ellipses. Pascal/800 later */ 1286 unsigned int info: 4; /* lang-specific stuff; F_xxxx */ 1287 unsigned int inlined: 1; 1288 unsigned int localloc: 1; /* 0 at top, 1 at end of block */ 1289 unsigned int expansion: 1; /* 1 = function expansion */ 1290 unsigned int doc_clone: 1; 1291 vtpointer name; /* name of function */ 1292 vtpointer alias; /* alternate name, if any */ 1293 dnttpointer firstparam; /* first FPARAM, if any */ 1294 sltpointer address; /* code and text locations */ 1295 CORE_ADDR entryaddr; /* address of entry point */ 1296 dnttpointer retval; /* return type, if any */ 1297 CORE_ADDR lowaddr; /* lowest address of function */ 1298 CORE_ADDR hiaddr; /* highest address of function */ 1299 dnttpointer inline_list; /* pointer to first inline */ 1300 ltpointer lt_offset; /* start of frag/cp line table */ 1301 ctxtpointer ctxt_offset; /* start of context table for this routine */ 1302 }; 1303 1304 /* DNTT_TYPE_DOC_MEMFUNC is unused by GDB */ 1305 1306 /* DNTT_TYPE_GENERIC and DNTT_TYPE_BLOCK are convience structures 1307 so we can examine a DNTT entry in a generic fashion. */ 1308 struct dntt_type_generic 1309 { 1310 unsigned int word[9]; 1311 }; 1312 1313 struct dntt_type_block 1314 { 1315 unsigned int extension: 1; 1316 unsigned int kind: 10; 1317 unsigned int unused: 21; 1318 unsigned int word[2]; 1319 }; 1320 1321 /* One entry in a DNTT (either the LNTT or GNTT). 1322 This is a union of the above 60 or so structure definitions. */ 1323 1324 union dnttentry 1325 { 1326 struct dntt_type_srcfile dsfile; 1327 struct dntt_type_module dmodule; 1328 struct dntt_type_function dfunc; 1329 struct dntt_type_function dentry; 1330 struct dntt_type_begin dbegin; 1331 struct dntt_type_end dend; 1332 struct dntt_type_fparam dfparam; 1333 struct dntt_type_svar dsvar; 1334 struct dntt_type_dvar ddvar; 1335 struct dntt_type_const dconst; 1336 struct dntt_type_type dtype; 1337 struct dntt_type_type dtag; 1338 struct dntt_type_pointer dptr; 1339 struct dntt_type_enum denum; 1340 struct dntt_type_memenum dmember; 1341 struct dntt_type_set dset; 1342 struct dntt_type_subrange dsubr; 1343 struct dntt_type_array darray; 1344 struct dntt_type_struct dstruct; 1345 struct dntt_type_union dunion; 1346 struct dntt_type_field dfield; 1347 struct dntt_type_functype dfunctype; 1348 struct dntt_type_with dwith; 1349 struct dntt_type_function dblockdata; 1350 struct dntt_type_class_scope dclass_scope; 1351 struct dntt_type_pointer dreference; 1352 struct dntt_type_ptrmem dptrmem; 1353 struct dntt_type_ptrmemfunc dptrmemfunc; 1354 struct dntt_type_class dclass; 1355 struct dntt_type_genfield dgenfield; 1356 struct dntt_type_vfunc dvfunc; 1357 struct dntt_type_memaccess dmemaccess; 1358 struct dntt_type_inheritance dinheritance; 1359 struct dntt_type_friend_class dfriend_class; 1360 struct dntt_type_friend_func dfriend_func; 1361 struct dntt_type_modifier dmodifier; 1362 struct dntt_type_object_id dobject_id; 1363 struct dntt_type_template dtemplate; 1364 struct dntt_type_templ_arg dtempl_arg; 1365 struct dntt_type_func_template dfunc_template; 1366 struct dntt_type_link dlink; 1367 struct dntt_type_doc_function ddocfunc; 1368 struct dntt_type_generic dgeneric; 1369 struct dntt_type_block dblock; 1370 }; 1371 1372 /* Source line entry types. */ 1373 enum slttype 1374 { 1375 SLT_NORMAL, 1376 SLT_SRCFILE, 1377 SLT_MODULE, 1378 SLT_FUNCTION, 1379 SLT_ENTRY, 1380 SLT_BEGIN, 1381 SLT_END, 1382 SLT_WITH, 1383 SLT_EXIT, 1384 SLT_ASSIST, 1385 SLT_MARKER, 1386 SLT_CLASS_SCOPE, 1387 SLT_INLN, 1388 SLT_NORMAL_OFFSET, 1389 }; 1390 1391 /* A normal source line entry. Simply provides a mapping of a source 1392 line number to a code address. 1393 1394 SLTDESC will always be SLT_NORMAL or SLT_EXIT. */ 1395 1396 struct slt_normal 1397 { 1398 unsigned int sltdesc: 4; 1399 unsigned int line: 28; 1400 CORE_ADDR address; 1401 }; 1402 1403 struct slt_normal_off 1404 { 1405 unsigned int sltdesc: 4; 1406 unsigned int offset: 6; 1407 unsigned int line: 22; 1408 CORE_ADDR address; 1409 }; 1410 1411 /* A special source line entry. Provides a mapping of a declaration 1412 to a line number. These entries point back into the DNTT which 1413 references them. */ 1414 1415 struct slt_special 1416 { 1417 unsigned int sltdesc: 4; 1418 unsigned int line: 28; 1419 dnttpointer backptr; 1420 }; 1421 1422 /* Used to describe nesting. 1423 1424 For nested languages, an slt_assist entry must follow each SLT_FUNC 1425 entry in the SLT. The address field will point forward to the 1426 first slt_normal entry within the function's scope. */ 1427 1428 struct slt_assist 1429 { 1430 unsigned int sltdesc: 4; 1431 unsigned int unused: 28; 1432 sltpointer address; 1433 }; 1434 1435 struct slt_generic 1436 { 1437 unsigned int word[2]; 1438 }; 1439 1440 union sltentry 1441 { 1442 struct slt_normal snorm; 1443 struct slt_normal_off snormoff; 1444 struct slt_special sspec; 1445 struct slt_assist sasst; 1446 struct slt_generic sgeneric; 1447 }; 1448 1449 /* $LINES$ declarations 1450 This is the line table used for optimized code, which is only present 1451 in the new $PROGRAM_INFO$ debug space. */ 1452 1453 #define DST_LN_ESCAPE_FLAG1 15 1454 #define DST_LN_ESCAPE_FLAG2 14 1455 #define DST_LN_CTX_SPEC1 13 1456 #define DST_LN_CTX_SPEC2 12 1457 1458 /* Escape function codes: */ 1459 1460 typedef enum 1461 { 1462 dst_ln_pad, /* pad byte */ 1463 dst_ln_escape_1, /* reserved */ 1464 dst_ln_dpc1_dln1, /* 1 byte line delta, 1 byte pc delta */ 1465 dst_ln_dpc2_dln2, /* 2 bytes line delta, 2 bytes pc delta */ 1466 dst_ln_pc4_ln4, /* 4 bytes ABSOLUTE line number, 4 bytes ABSOLUTE pc */ 1467 dst_ln_dpc0_dln1, /* 1 byte line delta, pc delta = 0 */ 1468 dst_ln_ln_off_1, /* statement escape, stmt # = 1 (2nd stmt on line) */ 1469 dst_ln_ln_off, /* statement escape, stmt # = next byte */ 1470 dst_ln_entry, /* entry escape, next byte is entry number */ 1471 dst_ln_exit, /* exit escape */ 1472 dst_ln_stmt_end, /* gap escape, 4 bytes pc delta */ 1473 dst_ln_stmt_cp, /* current stmt is a critical point */ 1474 dst_ln_escape_12, /* reserved */ 1475 dst_ln_escape_13, /* this is an exception site record */ 1476 dst_ln_nxt_byte, /* next byte contains the real escape code */ 1477 dst_ln_end, /* end escape, final entry follows */ 1478 dst_ln_escape1_END_OF_ENUM 1479 } 1480 dst_ln_escape1_t; 1481 1482 typedef enum 1483 { 1484 dst_ln_ctx_1, /* next byte describes context switch with 5-bit */ 1485 /* index into the image table and 3-bit run length. */ 1486 /* If run length is 0, end with another cxt specifier or ctx_end */ 1487 dst_ln_ctx_2, /* next 2 bytes switch context: 13 bit index, 3 bit run length */ 1488 dst_ln_ctx_4, /* next 4 bytes switch context: 29 bit index, 3 bit run length */ 1489 dst_ln_ctx_end, /* end current context */ 1490 dst_ln_col_run_1, /* next byte is column position of start of next statement, */ 1491 /* following byte is length of statement */ 1492 dst_ln_col_run_2, /* next 2 bytes is column position of start of next statement, */ 1493 /* following 2 bytes is length of statement */ 1494 dst_ln_init_base1, /* next 4 bytes are absolute PC, followed by 1 byte of line number */ 1495 dst_ln_init_base2, /* next 4 bytes are absolute PC, followed by 2 bytes of line number */ 1496 dst_ln_init_base3, /* next 4 bytes are absolute PC, followed by 3 bytes of line number */ 1497 dst_ln_escape2_END_OF_ENUM 1498 } 1499 dst_ln_escape2_t; 1500 1501 typedef union 1502 { 1503 struct 1504 { 1505 unsigned int pc_delta : 4; /* 4 bit pc delta */ 1506 int ln_delta : 4; /* 4 bit line number delta */ 1507 } 1508 delta; 1509 1510 struct 1511 { 1512 unsigned int esc_flag : 4; /* alias for pc_delta */ 1513 unsigned int esc_code : 4; /* escape function code (dst_ln_escape1_t, or ...2_t */ 1514 } 1515 esc; 1516 1517 struct 1518 { 1519 unsigned int esc_flag : 4; /* dst_ln_ctx_spec1, or dst_ln_ctx_spec2 */ 1520 unsigned int run_length : 2; 1521 unsigned int ctx_index : 2; /* ...spec2 contains index; ...spec1, index - 4 */ 1522 } 1523 ctx_spec; 1524 1525 char sdata; /* signed data byte */ 1526 unsigned char udata; /* unsigned data byte */ 1527 } 1528 dst_ln_entry_t, 1529 * dst_ln_entry_ptr_t; 1530 1531 /* Warning: although the above union occupies only 1 byte the compiler treats 1532 it as having size 2 (the minimum size of a struct). Therefore a sequence of 1533 dst_ln_entry_t's cannot be described as an array, and walking through such a 1534 sequence requires convoluted code such as 1535 ln_ptr = (dst_ln_entry_ptr_t) (char*) ln_ptr + 1 1536 We regret the inconvenience. */ 1537 1538 /* Structure for interpreting the byte following a dst_ln_ctx1 entry. */ 1539 typedef struct 1540 { 1541 unsigned int ctx1_index : 5; /* 5 bit index into context table */ 1542 unsigned int ctx1_run_length : 3; /* 3 bit run length */ 1543 } dst_ln_ctx1_t, 1544 *dst_ln_ctx1_ptr_t; 1545 1546 /* Structure for interpreting the bytes following a dst_ln_ctx2 entry. */ 1547 typedef struct 1548 { 1549 unsigned int ctx2_index : 13; /* 13 bit index into context table */ 1550 unsigned int ctx2_run_length : 3; /* 3 bit run length */ 1551 } dst_ln_ctx2_t, 1552 *dst_ln_ctx2_ptr_t; 1553 1554 /* Structure for interpreting the bytes following a dst_ln_ctx4 entry. */ 1555 typedef struct 1556 { 1557 unsigned int ctx4_index : 29; /* 29 bit index into context table */ 1558 unsigned int ctx4_run_length : 3; /* 3 bit run length */ 1559 } dst_ln_ctx4_t, 1560 *dst_ln_ctx4_ptr_t; 1561 1562 1563 /* PXDB definitions. 1564 1565 PXDB is a post-processor which takes the executable file 1566 and massages the debug information so that the debugger may 1567 start up and run more efficiently. Some of the tasks 1568 performed by PXDB are: 1569 1570 o Remove duplicate global type and variable information 1571 from the GNTT, 1572 1573 o Append the GNTT onto the end of the LNTT and place both 1574 back in the LNTT section, 1575 1576 o Build quick look-up tables (description follows) for 1577 files, procedures, modules, and paragraphs (for Cobol), 1578 placing these in the GNTT section, 1579 1580 o Reconstruct the header appearing in the header section 1581 to access this information. 1582 1583 The "quick look-up" tables are in the $GNTT$ sub-space, in 1584 the following order: 1585 1586 Procedures -sorted by address 1587 Source files -sorted by address (of the 1588 generated code from routines) 1589 Modules -sorted by address 1590 Classes -<unsorted?> 1591 Address Alias -sorted by index <?> 1592 Object IDs -sorted by object identifier 1593 1594 Most quick entries have (0-based) indices into the LNTT tables to 1595 the full entries for the item it describes. 1596 1597 The post-PXDB header is in the $HEADER$ sub-space. Alas, it 1598 occurs in different forms, depending on the optimization level 1599 in the compilation step and whether PXDB was run or not. The 1600 worst part is the forms aren't self-describing, so we'll have 1601 to grovel in the bits to figure out what kind we're looking at 1602 (see hp_get_header in hp-psymtab-read.c). */ 1603 1604 /* PXDB versions. */ 1605 1606 #define PXDB_VERSION_CPLUSPLUS 1 1607 #define PXDB_VERSION_7_4 2 1608 #define PXDB_VERSION_CPP_30 3 1609 #define PXDB_VERSION_DDE_3_2A 4 1610 #define PXDB_VERSION_DDE_3_2 5 1611 #define PXDB_VERSION_DDE_4_0 6 1612 1613 #define PXDB_VERSION_2_1 1 1614 1615 /* Header version for the case that there is no DOC info 1616 but the executable has been processed by pxdb (the easy 1617 case, from "cc -g"). */ 1618 1619 typedef struct PXDB_struct 1620 { 1621 int pd_entries; /* # of entries in function look-up table */ 1622 int fd_entries; /* # of entries in file look-up table */ 1623 int md_entries; /* # of entries in module look-up table */ 1624 unsigned int pxdbed : 1; /* 1 => file has been preprocessed */ 1625 unsigned int bighdr : 1; /* 1 => this header contains 'time' word */ 1626 unsigned int sa_header : 1;/* 1 => created by SA version of pxdb */ 1627 /* used for version check in xdb */ 1628 unsigned int inlined: 1; /* one or more functions have been inlined */ 1629 unsigned int spare:12; 1630 short version; /* pxdb header version */ 1631 int globals; /* index into the DNTT where GNTT begins */ 1632 unsigned int time; /* modify time of file before being pxdbed */ 1633 int pg_entries; /* # of entries in label look-up table */ 1634 int functions; /* actual number of functions */ 1635 int files; /* actual number of files */ 1636 int cd_entries; /* # of entries in class look-up table */ 1637 int aa_entries; /* # of entries in addr alias look-up table */ 1638 int oi_entries; /* # of entries in object id look-up table */ 1639 } PXDB_header, *PXDB_header_ptr; 1640 1641 /* Header version for the case that there is no DOC info and the 1642 executable has NOT been processed by pxdb. */ 1643 1644 typedef struct XDB_header_struct 1645 { 1646 long gntt_length; 1647 long lntt_length; 1648 long slt_length; 1649 long vt_length; 1650 long xt_length; 1651 } XDB_header; 1652 1653 /* Header version for the case that there is DOC info and the 1654 executable has been processed by pxdb. */ 1655 1656 typedef struct DOC_info_PXDB_header_struct 1657 { 1658 unsigned int xdb_header: 1; /* bit set if this is post-3.1 xdb */ 1659 unsigned int doc_header: 1; /* bit set if this is doc-style header */ 1660 unsigned int version: 8; /* version of pxdb see defines 1661 PXDB_VERSION_* in this file. */ 1662 unsigned int reserved_for_flags: 16;/* for future use; -- must be 1663 set to zero. */ 1664 unsigned int has_aux_pd_table: 1; /* $GNTT$ has aux PD table */ 1665 unsigned int has_expr_table: 1; /* space has $EXPR$ */ 1666 unsigned int has_range_table: 1; /* space has $RANGE$ */ 1667 unsigned int has_context_table: 1; /* space has $SRC_CTXT$ */ 1668 unsigned int has_lines_table: 1; /* space contains a $LINES$ 1669 subspace for line tables. */ 1670 unsigned int has_lt_offset_map: 1; /* space contains an lt_offset 1671 subspace for line table mapping. */ 1672 /* The following fields are the same as those in the PXDB_header in $DEBUG$ */ 1673 int pd_entries; /* # of entries in function look-up table */ 1674 int fd_entries; /* # of entries in file look-up table */ 1675 int md_entries; /* # of entries in module look-up table */ 1676 unsigned int pxdbed : 1; /* 1 => file has been preprocessed */ 1677 unsigned int bighdr : 1; /* 1 => this header contains 'time' word */ 1678 unsigned int sa_header : 1;/* 1 => created by SA version of pxdb */ 1679 /* used for version check in xdb */ 1680 unsigned int inlined: 1; /* one or more functions have been inlined */ 1681 unsigned int spare : 28; 1682 int globals; /* index into the DNTT where GNTT begins */ 1683 unsigned int time; /* modify time of file before being pxdbed */ 1684 int pg_entries; /* # of entries in label look-up table */ 1685 int functions; /* actual number of functions */ 1686 int files; /* actual number of files */ 1687 int cd_entries; /* # of entries in class look-up table */ 1688 int aa_entries; /* # of entries in addr alias look-up table */ 1689 int oi_entries; /* # of entries in object id look-up table */ 1690 } DOC_info_PXDB_header; 1691 1692 /* Header version for the case that there is DOC info and the 1693 executable has NOT been processed by pxdb. */ 1694 1695 typedef struct DOC_info_header_struct 1696 { 1697 unsigned int xdb_header: 1; /* bit set if this is post-3.1 xdb */ 1698 unsigned int doc_header: 1; /* bit set if this is doc-style header*/ 1699 unsigned int version: 8; /* version of debug/header 1700 format. For 10.0 the value 1701 will be 1. For "Davis" the value is 2. */ 1702 unsigned int reserved_for_flags: 18; /* for future use; -- must be set to zero. */ 1703 unsigned int has_range_table: 1; /* space contains a $RANGE$ subspace for variable ranges. */ 1704 unsigned int has_context_table: 1; /* space contains a $CTXT$ subspace for context/inline table. */ 1705 unsigned int has_lines_table: 1; /* space contains a $LINES$ subspace for line tables. */ 1706 unsigned int has_lt_offset_map: 1; /* space contains an lt_offset subspace for line table mapping. */ 1707 1708 long gntt_length; /* same as old header */ 1709 long lntt_length; /* same as old header */ 1710 long slt_length; /* same as old header */ 1711 long vt_length; /* same as old header */ 1712 long xt_length; /* same as old header */ 1713 long ctxt_length; /* present only if version >= 2 */ 1714 long range_length; /* present only if version >= 2 */ 1715 long expr_length; /* present only if version >= 2 */ 1716 1717 } DOC_info_header; 1718 1719 typedef union GenericDebugHeader_union 1720 { 1721 PXDB_header no_doc; 1722 DOC_info_PXDB_header doc; 1723 XDB_header no_pxdb_no_doc; 1724 DOC_info_header no_pxdb_doc; 1725 } GenericDebugHeader; 1726 1727 1728 /* Procedure Descriptor: 1729 An element of the procedure quick look-up table. */ 1730 1731 typedef struct quick_procedure 1732 { 1733 long isym; /* 0-based index of first symbol 1734 for procedure in $LNTT$, 1735 i.e. the procedure itself. */ 1736 CORE_ADDR adrStart; /* memory adr of start of proc */ 1737 CORE_ADDR adrEnd; /* memory adr of end of proc */ 1738 char *sbAlias; /* alias name of procedure */ 1739 char *sbProc; /* real name of procedure */ 1740 CORE_ADDR adrBp; /* address of entry breakpoint */ 1741 CORE_ADDR adrExitBp; /* address of exit breakpoint */ 1742 int icd; /* member of this class (index) */ 1743 unsigned int ipd; /* index of template for this */ 1744 /* function (index) */ 1745 unsigned int unused: 5; 1746 unsigned int no_lt_offset: 1;/* no entry in lt_offset table */ 1747 unsigned int fTemplate: 1; /* function template */ 1748 unsigned int fExpansion: 1; /* function expansion */ 1749 unsigned int linked : 1; /* linked with other expansions */ 1750 unsigned int duplicate: 1; /* clone of another procedure */ 1751 unsigned int overloaded:1; /* overloaded function */ 1752 unsigned int member: 1; /* class member function */ 1753 unsigned int constructor:1; /* constructor function */ 1754 unsigned int destructor:1; /* destructor function */ 1755 unsigned int Static: 1; /* static function */ 1756 unsigned int Virtual: 1; /* virtual function */ 1757 unsigned int constant: 1; /* constant function */ 1758 unsigned int pure: 1; /* pure (virtual) function */ 1759 unsigned int language: 4; /* procedure's language */ 1760 unsigned int inlined: 1; /* function has been inlined */ 1761 unsigned int Operator: 1; /* operator function */ 1762 unsigned int stub: 1; /* bodyless function */ 1763 unsigned int optimize: 2; /* optimization level */ 1764 unsigned int level: 5; /* nesting level (top=0) */ 1765 } quick_procedure_entry, *quick_procedure_entry_ptr; 1766 1767 /* Source File Descriptor: 1768 An element of the source file quick look-up table. */ 1769 1770 typedef struct quick_source 1771 { 1772 long isym; /* 0-based index in $LNTT$ of 1773 first symbol for this file. */ 1774 CORE_ADDR adrStart; /* mem adr of start of file's code */ 1775 CORE_ADDR adrEnd; /* mem adr of end of file's code */ 1776 char *sbFile; /* name of source file */ 1777 unsigned int fHasDecl: 1; /* do we have a .d file? */ 1778 unsigned int fWarned: 1; /* have warned about age problems? */ 1779 unsigned int fSrcfile: 1; /* 0 => include 1=> source */ 1780 unsigned short ilnMac; /* lines in file (0 if don't know) */ 1781 int ipd; /* 0-based index of first procedure 1782 in this file, in the quick 1783 look-up table of procedures. */ 1784 unsigned int *rgLn; /* line pointer array, if any */ 1785 } quick_file_entry, *quick_file_entry_ptr; 1786 1787 /* Module Descriptor: 1788 An element of the module quick reference table. */ 1789 1790 typedef struct quick_module 1791 { 1792 long isym; /* 0-based index of first 1793 symbol for module. */ 1794 CORE_ADDR adrStart; /* adr of start of mod. */ 1795 CORE_ADDR adrEnd; /* adr of end of mod. */ 1796 char *sbAlias; /* alias name of module */ 1797 char *sbMod; /* real name of module */ 1798 unsigned int imports: 1; /* module have any imports? */ 1799 unsigned int vars_in_front: 1; /* module globals in front? */ 1800 unsigned int vars_in_gaps: 1; /* module globals in gaps? */ 1801 unsigned int language: 4; /* type of language */ 1802 unsigned int unused : 25; 1803 unsigned int unused2; /* space for future stuff */ 1804 } quick_module_entry, *quick_module_entry_ptr; 1805 1806 /* Auxiliary Procedure Descriptor: 1807 An element of the auxiliary procedure quick look-up table. */ 1808 1809 typedef struct quick_aux_procedure 1810 { 1811 long isym_inln; /* start on inline list for proc */ 1812 long spare; 1813 } quick_aux_procedure_entry, *quick_aux_procedure_entry_ptr; 1814 1815 /* Paragraph Descriptor: 1816 An element of the paragraph quick look-up table. */ 1817 1818 typedef struct quick_paragraph 1819 { 1820 long isym; /* first symbol for label (index) */ 1821 CORE_ADDR adrStart; /* memory adr of start of label */ 1822 CORE_ADDR adrEnd; /* memory adr of end of label */ 1823 char *sbLab; /* name of label */ 1824 unsigned int inst; /* Used in xdb to store inst @ bp */ 1825 unsigned int sect: 1; /* true = section, false = parag. */ 1826 unsigned int unused: 31; /* future use */ 1827 } quick_paragraph_entry, *quick_paragraph_entry_ptr; 1828 1829 /* Class Descriptor: 1830 An element of the class quick look-up table. */ 1831 1832 typedef struct quick_class 1833 { 1834 char *sbClass; /* name of class */ 1835 long isym; /* class symbol (tag) */ 1836 unsigned int type : 2; /* 0=class, 1=union, 2=struct */ 1837 unsigned int fTemplate : 1;/* class template */ 1838 unsigned int expansion : 1;/* template expansion */ 1839 unsigned int unused :28; 1840 sltpointer lowscope; /* beginning of defined scope */ 1841 sltpointer hiscope; /* end of defined scope */ 1842 } quick_class_entry, *quick_class_entry_ptr; 1843 1844 /* Address Alias Entry 1845 An element of the address alias quick look-up table. */ 1846 1847 typedef struct quick_alias 1848 { 1849 CORE_ADDR low; 1850 CORE_ADDR high; 1851 int index; 1852 unsigned int unused : 31; 1853 unsigned int alternate : 1; /* alternate unnamed aliases? */ 1854 } quick_alias_entry, *quick_alias_entry_ptr; 1855 1856 /* Object Identification Entry 1857 An element of the object identification quick look-up table. */ 1858 1859 typedef struct quick_obj_ID 1860 { 1861 CORE_ADDR obj_ident; /* class identifier */ 1862 long isym; /* class symbol */ 1863 long offset; /* offset to object start */ 1864 } quick_obj_ID_entry, *quick_obj_ID_entry_ptr; 1865 1866 #endif /* HP_SYMTAB_INCLUDED */ 1867