1 /* debug.h -- Describe generic debugging information. 2 Copyright (C) 1995-2022 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor <ian@cygnus.com>. 4 5 This file is part of GNU Binutils. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 #ifndef DEBUG_H 23 #define DEBUG_H 24 25 /* This header file describes a generic debugging information format. 26 We may eventually have readers which convert different formats into 27 this generic format, and writers which write it out. The initial 28 impetus for this was writing a converter from stabs to HP IEEE-695 29 debugging format. */ 30 31 /* Different kinds of types. */ 32 33 enum debug_type_kind 34 { 35 /* Not used. */ 36 DEBUG_KIND_ILLEGAL, 37 /* Indirect via a pointer. */ 38 DEBUG_KIND_INDIRECT, 39 /* Void. */ 40 DEBUG_KIND_VOID, 41 /* Integer. */ 42 DEBUG_KIND_INT, 43 /* Floating point. */ 44 DEBUG_KIND_FLOAT, 45 /* Complex. */ 46 DEBUG_KIND_COMPLEX, 47 /* Boolean. */ 48 DEBUG_KIND_BOOL, 49 /* Struct. */ 50 DEBUG_KIND_STRUCT, 51 /* Union. */ 52 DEBUG_KIND_UNION, 53 /* Class. */ 54 DEBUG_KIND_CLASS, 55 /* Union class (can this really happen?). */ 56 DEBUG_KIND_UNION_CLASS, 57 /* Enumeration type. */ 58 DEBUG_KIND_ENUM, 59 /* Pointer. */ 60 DEBUG_KIND_POINTER, 61 /* Function. */ 62 DEBUG_KIND_FUNCTION, 63 /* Reference. */ 64 DEBUG_KIND_REFERENCE, 65 /* Range. */ 66 DEBUG_KIND_RANGE, 67 /* Array. */ 68 DEBUG_KIND_ARRAY, 69 /* Set. */ 70 DEBUG_KIND_SET, 71 /* Based pointer. */ 72 DEBUG_KIND_OFFSET, 73 /* Method. */ 74 DEBUG_KIND_METHOD, 75 /* Const qualified type. */ 76 DEBUG_KIND_CONST, 77 /* Volatile qualified type. */ 78 DEBUG_KIND_VOLATILE, 79 /* Named type. */ 80 DEBUG_KIND_NAMED, 81 /* Tagged type. */ 82 DEBUG_KIND_TAGGED 83 }; 84 85 /* Different kinds of variables. */ 86 87 enum debug_var_kind 88 { 89 /* Not used. */ 90 DEBUG_VAR_ILLEGAL, 91 /* A global variable. */ 92 DEBUG_GLOBAL, 93 /* A static variable. */ 94 DEBUG_STATIC, 95 /* A local static variable. */ 96 DEBUG_LOCAL_STATIC, 97 /* A local variable. */ 98 DEBUG_LOCAL, 99 /* A register variable. */ 100 DEBUG_REGISTER 101 }; 102 103 /* Different kinds of function parameters. */ 104 105 enum debug_parm_kind 106 { 107 /* Not used. */ 108 DEBUG_PARM_ILLEGAL, 109 /* A stack based parameter. */ 110 DEBUG_PARM_STACK, 111 /* A register parameter. */ 112 DEBUG_PARM_REG, 113 /* A stack based reference parameter. */ 114 DEBUG_PARM_REFERENCE, 115 /* A register reference parameter. */ 116 DEBUG_PARM_REF_REG 117 }; 118 119 /* Different kinds of visibility. */ 120 121 enum debug_visibility 122 { 123 /* A public field (e.g., a field in a C struct). */ 124 DEBUG_VISIBILITY_PUBLIC, 125 /* A protected field. */ 126 DEBUG_VISIBILITY_PROTECTED, 127 /* A private field. */ 128 DEBUG_VISIBILITY_PRIVATE, 129 /* A field which should be ignored. */ 130 DEBUG_VISIBILITY_IGNORE 131 }; 132 133 /* A type. */ 134 135 typedef struct debug_type_s *debug_type; 136 137 #define DEBUG_TYPE_NULL ((debug_type) NULL) 138 139 /* A field in a struct or union. */ 140 141 typedef struct debug_field_s *debug_field; 142 143 #define DEBUG_FIELD_NULL ((debug_field) NULL) 144 145 /* A base class for an object. */ 146 147 typedef struct debug_baseclass_s *debug_baseclass; 148 149 #define DEBUG_BASECLASS_NULL ((debug_baseclass) NULL) 150 151 /* A method of an object. */ 152 153 typedef struct debug_method_s *debug_method; 154 155 #define DEBUG_METHOD_NULL ((debug_method) NULL) 156 157 /* The arguments to a method function of an object. These indicate 158 which method to run. */ 159 160 typedef struct debug_method_variant_s *debug_method_variant; 161 162 #define DEBUG_METHOD_VARIANT_NULL ((debug_method_variant) NULL) 163 164 /* This structure is passed to debug_write. It holds function 165 pointers that debug_write will call based on the accumulated 166 debugging information. */ 167 168 struct debug_write_fns 169 { 170 /* This is called at the start of each new compilation unit with the 171 name of the main file in the new unit. */ 172 bool (*start_compilation_unit) (void *, const char *); 173 174 /* This is called at the start of each source file within a 175 compilation unit, before outputting any global information for 176 that file. The argument is the name of the file. */ 177 bool (*start_source) (void *, const char *); 178 179 /* Each writer must keep a stack of types. */ 180 181 /* Push an empty type onto the type stack. This type can appear if 182 there is a reference to a type which is never defined. */ 183 bool (*empty_type) (void *); 184 185 /* Push a void type onto the type stack. */ 186 bool (*void_type) (void *); 187 188 /* Push an integer type onto the type stack, given the size and 189 whether it is unsigned. */ 190 bool (*int_type) (void *, unsigned int, bool); 191 192 /* Push a floating type onto the type stack, given the size. */ 193 bool (*float_type) (void *, unsigned int); 194 195 /* Push a complex type onto the type stack, given the size. */ 196 bool (*complex_type) (void *, unsigned int); 197 198 /* Push a bool type onto the type stack, given the size. */ 199 bool (*bool_type) (void *, unsigned int); 200 201 /* Push an enum type onto the type stack, given the tag, a NULL 202 terminated array of names and the associated values. If there is 203 no tag, the tag argument will be NULL. If this is an undefined 204 enum, the names and values arguments will be NULL. */ 205 bool (*enum_type) 206 (void *, const char *, const char **, bfd_signed_vma *); 207 208 /* Pop the top type on the type stack, and push a pointer to that 209 type onto the type stack. */ 210 bool (*pointer_type) (void *); 211 212 /* Push a function type onto the type stack. The second argument 213 indicates the number of argument types that have been pushed onto 214 the stack. If the number of argument types is passed as -1, then 215 the argument types of the function are unknown, and no types have 216 been pushed onto the stack. The third argument is TRUE if the 217 function takes a variable number of arguments. The return type 218 of the function is pushed onto the type stack below the argument 219 types, if any. */ 220 bool (*function_type) (void *, int, bool); 221 222 /* Pop the top type on the type stack, and push a reference to that 223 type onto the type stack. */ 224 bool (*reference_type) (void *); 225 226 /* Pop the top type on the type stack, and push a range of that type 227 with the given lower and upper bounds onto the type stack. */ 228 bool (*range_type) (void *, bfd_signed_vma, bfd_signed_vma); 229 230 /* Push an array type onto the type stack. The top type on the type 231 stack is the range, and the next type on the type stack is the 232 element type. These should be popped before the array type is 233 pushed. The arguments are the lower bound, the upper bound, and 234 whether the array is a string. */ 235 bool (*array_type) 236 (void *, bfd_signed_vma, bfd_signed_vma, bool); 237 238 /* Pop the top type on the type stack, and push a set of that type 239 onto the type stack. The argument indicates whether this set is 240 a bitstring. */ 241 bool (*set_type) (void *, bool); 242 243 /* Push an offset type onto the type stack. The top type on the 244 type stack is the target type, and the next type on the type 245 stack is the base type. These should be popped before the offset 246 type is pushed. */ 247 bool (*offset_type) (void *); 248 249 /* Push a method type onto the type stack. If the second argument 250 is TRUE, the top type on the stack is the class to which the 251 method belongs; otherwise, the class must be determined by the 252 class to which the method is attached. The third argument is the 253 number of argument types; these are pushed onto the type stack in 254 reverse order (the first type popped is the last argument to the 255 method). A value of -1 for the third argument means that no 256 argument information is available. The fourth argument is TRUE 257 if the function takes a variable number of arguments. The next 258 type on the type stack below the domain and the argument types is 259 the return type of the method. All these types must be popped, 260 and then the method type must be pushed. */ 261 bool (*method_type) (void *, bool, int, bool); 262 263 /* Pop the top type off the type stack, and push a const qualified 264 version of that type onto the type stack. */ 265 bool (*const_type) (void *); 266 267 /* Pop the top type off the type stack, and push a volatile 268 qualified version of that type onto the type stack. */ 269 bool (*volatile_type) (void *); 270 271 /* Start building a struct. This is followed by calls to the 272 struct_field function, and finished by a call to the 273 end_struct_type function. The second argument is the tag; this 274 will be NULL if there isn't one. If the second argument is NULL, 275 the third argument is a constant identifying this struct for use 276 with tag_type. The fourth argument is TRUE for a struct, FALSE 277 for a union. The fifth argument is the size. If this is an 278 undefined struct or union, the size will be 0 and struct_field 279 will not be called before end_struct_type is called. */ 280 bool (*start_struct_type) 281 (void *, const char *, unsigned int, bool, unsigned int); 282 283 /* Add a field to the struct type currently being built. The type 284 of the field should be popped off the type stack. The arguments 285 are the name, the bit position, the bit size (may be zero if the 286 field is not packed), and the visibility. */ 287 bool (*struct_field) 288 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 289 290 /* Finish building a struct, and push it onto the type stack. */ 291 bool (*end_struct_type) (void *); 292 293 /* Start building a class. This is followed by calls to several 294 functions: struct_field, class_static_member, class_baseclass, 295 class_start_method, class_method_variant, 296 class_static_method_variant, and class_end_method. The class is 297 finished by a call to end_class_type. The first five arguments 298 are the same as for start_struct_type. The sixth argument is 299 TRUE if there is a virtual function table; if there is, the 300 seventh argument is TRUE if the virtual function table can be 301 found in the type itself, and is FALSE if the type of the object 302 holding the virtual function table should be popped from the type 303 stack. */ 304 bool (*start_class_type) 305 (void *, const char *, unsigned int, bool, unsigned int, bool, bool); 306 307 /* Add a static member to the class currently being built. The 308 arguments are the field name, the physical name, and the 309 visibility. The type must be popped off the type stack. */ 310 bool (*class_static_member) 311 (void *, const char *, const char *, enum debug_visibility); 312 313 /* Add a baseclass to the class currently being built. The type of 314 the baseclass must be popped off the type stack. The arguments 315 are the bit position, whether the class is virtual, and the 316 visibility. */ 317 bool (*class_baseclass) 318 (void *, bfd_vma, bool, enum debug_visibility); 319 320 /* Start adding a method to the class currently being built. This 321 is followed by calls to class_method_variant and 322 class_static_method_variant to describe different variants of the 323 method which take different arguments. The method is finished 324 with a call to class_end_method. The argument is the method 325 name. */ 326 bool (*class_start_method) (void *, const char *); 327 328 /* Describe a variant to the class method currently being built. 329 The type of the variant must be popped off the type stack. The 330 second argument is the physical name of the function. The 331 following arguments are the visibility, whether the variant is 332 const, whether the variant is volatile, the offset in the virtual 333 function table, and whether the context is on the type stack 334 (below the variant type). */ 335 bool (*class_method_variant) 336 (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool); 337 338 /* Describe a static variant to the class method currently being 339 built. The arguments are the same as for class_method_variant, 340 except that the last two arguments are omitted. The type of the 341 variant must be popped off the type stack. */ 342 bool (*class_static_method_variant) 343 (void *, const char *, enum debug_visibility, bool, bool); 344 345 /* Finish describing a class method. */ 346 bool (*class_end_method) (void *); 347 348 /* Finish describing a class, and push it onto the type stack. */ 349 bool (*end_class_type) (void *); 350 351 /* Push a type on the stack which was given a name by an earlier 352 call to typdef. */ 353 bool (*typedef_type) (void *, const char *); 354 355 /* Push a tagged type on the stack which was defined earlier. If 356 the second argument is not NULL, the type was defined by a call 357 to tag. If the second argument is NULL, the type was defined by 358 a call to start_struct_type or start_class_type with a tag of 359 NULL and the number of the third argument. Either way, the 360 fourth argument is the tag kind. Note that this may be called 361 for a struct (class) being defined, in between the call to 362 start_struct_type (start_class_type) and the call to 363 end_struct_type (end_class_type). */ 364 bool (*tag_type) 365 (void *, const char *, unsigned int, enum debug_type_kind); 366 367 /* Pop the type stack, and typedef it to the given name. */ 368 bool (*typdef) (void *, const char *); 369 370 /* Pop the type stack, and declare it as a tagged struct or union or 371 enum or whatever. The tag passed down here is redundant, since 372 was also passed when enum_type, start_struct_type, or 373 start_class_type was called. */ 374 bool (*tag) (void *, const char *); 375 376 /* This is called to record a named integer constant. */ 377 bool (*int_constant) (void *, const char *, bfd_vma); 378 379 /* This is called to record a named floating point constant. */ 380 bool (*float_constant) (void *, const char *, double); 381 382 /* This is called to record a typed integer constant. The type is 383 popped off the type stack. */ 384 bool (*typed_constant) (void *, const char *, bfd_vma); 385 386 /* This is called to record a variable. The type is popped off the 387 type stack. */ 388 bool (*variable) 389 (void *, const char *, enum debug_var_kind, bfd_vma); 390 391 /* Start writing out a function. The return type must be popped off 392 the stack. The bool is TRUE if the function is global. This 393 is followed by calls to function_parameter, followed by block 394 information. */ 395 bool (*start_function) (void *, const char *, bool); 396 397 /* Record a function parameter for the current function. The type 398 must be popped off the stack. */ 399 bool (*function_parameter) 400 (void *, const char *, enum debug_parm_kind, bfd_vma); 401 402 /* Start writing out a block. There is at least one top level block 403 per function. Blocks may be nested. The argument is the 404 starting address of the block. */ 405 bool (*start_block) (void *, bfd_vma); 406 407 /* Finish writing out a block. The argument is the ending address 408 of the block. */ 409 bool (*end_block) (void *, bfd_vma); 410 411 /* Finish writing out a function. */ 412 bool (*end_function) (void *); 413 414 /* Record line number information for the current compilation unit. */ 415 bool (*lineno) (void *, const char *, unsigned long, bfd_vma); 416 }; 417 418 /* Exported functions. */ 419 420 /* The first argument to most of these functions is a handle. This 421 handle is returned by the debug_init function. The purpose of the 422 handle is to permit the debugging routines to not use static 423 variables, and hence to be reentrant. This would be useful for a 424 program which wanted to handle two executables simultaneously. */ 425 426 /* Return a debugging handle. */ 427 428 extern void *debug_init (void); 429 430 /* Set the source filename. This implicitly starts a new compilation 431 unit. */ 432 433 extern bool debug_set_filename (void *, const char *); 434 435 /* Change source files to the given file name. This is used for 436 include files in a single compilation unit. */ 437 438 extern bool debug_start_source (void *, const char *); 439 440 /* Record a function definition. This implicitly starts a function 441 block. The debug_type argument is the type of the return value. 442 The bool indicates whether the function is globally visible. 443 The bfd_vma is the address of the start of the function. Currently 444 the parameter types are specified by calls to 445 debug_record_parameter. */ 446 447 extern bool debug_record_function 448 (void *, const char *, debug_type, bool, bfd_vma); 449 450 /* Record a parameter for the current function. */ 451 452 extern bool debug_record_parameter 453 (void *, const char *, debug_type, enum debug_parm_kind, bfd_vma); 454 455 /* End a function definition. The argument is the address where the 456 function ends. */ 457 458 extern bool debug_end_function (void *, bfd_vma); 459 460 /* Start a block in a function. All local information will be 461 recorded in this block, until the matching call to debug_end_block. 462 debug_start_block and debug_end_block may be nested. The argument 463 is the address at which this block starts. */ 464 465 extern bool debug_start_block (void *, bfd_vma); 466 467 /* Finish a block in a function. This matches the call to 468 debug_start_block. The argument is the address at which this block 469 ends. */ 470 471 extern bool debug_end_block (void *, bfd_vma); 472 473 /* Associate a line number in the current source file with a given 474 address. */ 475 476 extern bool debug_record_line (void *, unsigned long, bfd_vma); 477 478 /* Start a named common block. This is a block of variables that may 479 move in memory. */ 480 481 extern bool debug_start_common_block (void *, const char *); 482 483 /* End a named common block. */ 484 485 extern bool debug_end_common_block (void *, const char *); 486 487 /* Record a named integer constant. */ 488 489 extern bool debug_record_int_const (void *, const char *, bfd_vma); 490 491 /* Record a named floating point constant. */ 492 493 extern bool debug_record_float_const (void *, const char *, double); 494 495 /* Record a typed constant with an integral value. */ 496 497 extern bool debug_record_typed_const 498 (void *, const char *, debug_type, bfd_vma); 499 500 /* Record a label. */ 501 502 extern bool debug_record_label 503 (void *, const char *, debug_type, bfd_vma); 504 505 /* Record a variable. */ 506 507 extern bool debug_record_variable 508 (void *, const char *, debug_type, enum debug_var_kind, bfd_vma); 509 510 /* Make an indirect type. The first argument is a pointer to the 511 location where the real type will be placed. The second argument 512 is the type tag, if there is one; this may be NULL; the only 513 purpose of this argument is so that debug_get_type_name can return 514 something useful. This function may be used when a type is 515 referenced before it is defined. */ 516 517 extern debug_type debug_make_indirect_type 518 (void *, debug_type *, const char *); 519 520 /* Make a void type. */ 521 522 extern debug_type debug_make_void_type (void *); 523 524 /* Make an integer type of a given size. The bool argument is TRUE 525 if the integer is unsigned. */ 526 527 extern debug_type debug_make_int_type (void *, unsigned int, bool); 528 529 /* Make a floating point type of a given size. FIXME: On some 530 platforms, like an Alpha, you probably need to be able to specify 531 the format. */ 532 533 extern debug_type debug_make_float_type (void *, unsigned int); 534 535 /* Make a boolean type of a given size. */ 536 537 extern debug_type debug_make_bool_type (void *, unsigned int); 538 539 /* Make a complex type of a given size. */ 540 541 extern debug_type debug_make_complex_type (void *, unsigned int); 542 543 /* Make a structure type. The second argument is TRUE for a struct, 544 FALSE for a union. The third argument is the size of the struct. 545 The fourth argument is a NULL terminated array of fields. */ 546 547 extern debug_type debug_make_struct_type 548 (void *, bool, bfd_vma, debug_field *); 549 550 /* Make an object type. The first three arguments after the handle 551 are the same as for debug_make_struct_type. The next arguments are 552 a NULL terminated array of base classes, a NULL terminated array of 553 methods, the type of the object holding the virtual function table 554 if it is not this object, and a bool which is TRUE if this 555 object has its own virtual function table. */ 556 557 extern debug_type debug_make_object_type 558 (void *, bool, bfd_vma, debug_field *, debug_baseclass *, 559 debug_method *, debug_type, bool); 560 561 /* Make an enumeration type. The arguments are a null terminated 562 array of strings, and an array of corresponding values. */ 563 564 extern debug_type debug_make_enum_type 565 (void *, const char **, bfd_signed_vma *); 566 567 /* Make a pointer to a given type. */ 568 569 extern debug_type debug_make_pointer_type (void *, debug_type); 570 571 /* Make a function type. The second argument is the return type. The 572 third argument is a NULL terminated array of argument types. The 573 fourth argument is TRUE if the function takes a variable number of 574 arguments. If the third argument is NULL, then the argument types 575 are unknown. */ 576 577 extern debug_type debug_make_function_type 578 (void *, debug_type, debug_type *, bool); 579 580 /* Make a reference to a given type. */ 581 582 extern debug_type debug_make_reference_type (void *, debug_type); 583 584 /* Make a range of a given type from a lower to an upper bound. */ 585 586 extern debug_type debug_make_range_type 587 (void *, debug_type, bfd_signed_vma, bfd_signed_vma); 588 589 /* Make an array type. The second argument is the type of an element 590 of the array. The third argument is the type of a range of the 591 array. The fourth and fifth argument are the lower and upper 592 bounds, respectively (if the bounds are not known, lower should be 593 0 and upper should be -1). The sixth argument is TRUE if this 594 array is actually a string, as in C. */ 595 596 extern debug_type debug_make_array_type 597 (void *, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma, 598 bool); 599 600 /* Make a set of a given type. For example, a Pascal set type. The 601 bool argument is TRUE if this set is actually a bitstring, as in 602 CHILL. */ 603 604 extern debug_type debug_make_set_type (void *, debug_type, bool); 605 606 /* Make a type for a pointer which is relative to an object. The 607 second argument is the type of the object to which the pointer is 608 relative. The third argument is the type that the pointer points 609 to. */ 610 611 extern debug_type debug_make_offset_type (void *, debug_type, debug_type); 612 613 /* Make a type for a method function. The second argument is the 614 return type. The third argument is the domain. The fourth 615 argument is a NULL terminated array of argument types. The fifth 616 argument is TRUE if the function takes a variable number of 617 arguments, in which case the array of argument types indicates the 618 types of the first arguments. The domain and the argument array 619 may be NULL, in which case this is a stub method and that 620 information is not available. Stabs debugging uses this, and gets 621 the argument types from the mangled name. */ 622 623 extern debug_type debug_make_method_type 624 (void *, debug_type, debug_type, debug_type *, bool); 625 626 /* Make a const qualified version of a given type. */ 627 628 extern debug_type debug_make_const_type (void *, debug_type); 629 630 /* Make a volatile qualified version of a given type. */ 631 632 extern debug_type debug_make_volatile_type (void *, debug_type); 633 634 /* Make an undefined tagged type. For example, a struct which has 635 been mentioned, but not defined. */ 636 637 extern debug_type debug_make_undefined_tagged_type 638 (void *, const char *, enum debug_type_kind); 639 640 /* Make a base class for an object. The second argument is the base 641 class type. The third argument is the bit position of this base 642 class in the object. The fourth argument is whether this is a 643 virtual class. The fifth argument is the visibility of the base 644 class. */ 645 646 extern debug_baseclass debug_make_baseclass 647 (void *, debug_type, bfd_vma, bool, enum debug_visibility); 648 649 /* Make a field for a struct. The second argument is the name. The 650 third argument is the type of the field. The fourth argument is 651 the bit position of the field. The fifth argument is the size of 652 the field (it may be zero). The sixth argument is the visibility 653 of the field. */ 654 655 extern debug_field debug_make_field 656 (void *, const char *, debug_type, bfd_vma, bfd_vma, enum debug_visibility); 657 658 /* Make a static member of an object. The second argument is the 659 name. The third argument is the type of the member. The fourth 660 argument is the physical name of the member (i.e., the name as a 661 global variable). The fifth argument is the visibility of the 662 member. */ 663 664 extern debug_field debug_make_static_member 665 (void *, const char *, debug_type, const char *, enum debug_visibility); 666 667 /* Make a method. The second argument is the name, and the third 668 argument is a NULL terminated array of method variants. Each 669 method variant is a method with this name but with different 670 argument types. */ 671 672 extern debug_method debug_make_method 673 (void *, const char *, debug_method_variant *); 674 675 /* Make a method variant. The second argument is the physical name of 676 the function. The third argument is the type of the function, 677 probably constructed by debug_make_method_type. The fourth 678 argument is the visibility. The fifth argument is whether this is 679 a const function. The sixth argument is whether this is a volatile 680 function. The seventh argument is the index in the virtual 681 function table, if any. The eighth argument is the virtual 682 function context. */ 683 684 extern debug_method_variant debug_make_method_variant 685 (void *, const char *, debug_type, enum debug_visibility, bool, 686 bool, bfd_vma, debug_type); 687 688 /* Make a static method argument. The arguments are the same as for 689 debug_make_method_variant, except that the last two are omitted 690 since a static method can not also be virtual. */ 691 692 extern debug_method_variant debug_make_static_method_variant 693 (void *, const char *, debug_type, enum debug_visibility, bool, 694 bool); 695 696 /* Name a type. This returns a new type with an attached name. */ 697 698 extern debug_type debug_name_type (void *, const char *, debug_type); 699 700 /* Give a tag to a type, such as a struct or union. This returns a 701 new type with an attached tag. */ 702 703 extern debug_type debug_tag_type (void *, const char *, debug_type); 704 705 /* Record the size of a given type. */ 706 707 extern bool debug_record_type_size (void *, debug_type, unsigned int); 708 709 /* Find a named type. */ 710 711 extern debug_type debug_find_named_type (void *, const char *); 712 713 /* Find a tagged type. */ 714 715 extern debug_type debug_find_tagged_type 716 (void *, const char *, enum debug_type_kind); 717 718 /* Get the kind of a type. */ 719 720 extern enum debug_type_kind debug_get_type_kind (void *, debug_type); 721 722 /* Get the name of a type. */ 723 724 extern const char *debug_get_type_name (void *, debug_type); 725 726 /* Get the size of a type. */ 727 728 extern bfd_vma debug_get_type_size (void *, debug_type); 729 730 /* Get the return type of a function or method type. */ 731 732 extern debug_type debug_get_return_type (void *, debug_type); 733 734 /* Get the NULL terminated array of parameter types for a function or 735 method type (actually, parameter types are not currently stored for 736 function types). This may be used to determine whether a method 737 type is a stub method or not. The last argument points to a 738 bool which is set to TRUE if the function takes a variable 739 number of arguments. */ 740 741 extern const debug_type *debug_get_parameter_types 742 (void *, debug_type, bool *); 743 744 /* Get the target type of a pointer or reference or const or volatile 745 type. */ 746 747 extern debug_type debug_get_target_type (void *, debug_type); 748 749 /* Get the NULL terminated array of fields for a struct, union, or 750 class. */ 751 752 extern const debug_field *debug_get_fields (void *, debug_type); 753 754 /* Get the type of a field. */ 755 756 extern debug_type debug_get_field_type (void *, debug_field); 757 758 /* Get the name of a field. */ 759 760 extern const char *debug_get_field_name (void *, debug_field); 761 762 /* Get the bit position of a field within the containing structure. 763 If the field is a static member, this will return (bfd_vma) -1. */ 764 765 extern bfd_vma debug_get_field_bitpos (void *, debug_field); 766 767 /* Get the bit size of a field. If the field is a static member, this 768 will return (bfd_vma) -1. */ 769 770 extern bfd_vma debug_get_field_bitsize (void *, debug_field); 771 772 /* Get the visibility of a field. */ 773 774 extern enum debug_visibility debug_get_field_visibility (void *, debug_field); 775 776 /* Get the physical name of a field, if it is a static member. If the 777 field is not a static member, this will return NULL. */ 778 779 extern const char *debug_get_field_physname (void *, debug_field); 780 781 /* Write out the recorded debugging information. This takes a set of 782 function pointers which are called to do the actual writing. The 783 first void * is the debugging handle. The second void * is a handle 784 which is passed to the functions. */ 785 786 extern bool debug_write 787 (void *, const struct debug_write_fns *, void *); 788 789 #endif /* DEBUG_H */ 790