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