debug.h revision 104834
1/* debug.h -- Describe generic debugging information. 2 Copyright 1995, 1996 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 2 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., 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, 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 convertor from stabs to HP IEEE-695 29 debugging format. */ 30 31/* Different kinds of types. */ 32 33enum 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 87enum 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 105enum 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 121enum 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 135typedef struct debug_type *debug_type; 136 137#define DEBUG_TYPE_NULL ((debug_type) NULL) 138 139/* A field in a struct or union. */ 140 141typedef struct debug_field *debug_field; 142 143#define DEBUG_FIELD_NULL ((debug_field) NULL) 144 145/* A base class for an object. */ 146 147typedef struct debug_baseclass *debug_baseclass; 148 149#define DEBUG_BASECLASS_NULL ((debug_baseclass) NULL) 150 151/* A method of an object. */ 152 153typedef struct debug_method *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 160typedef struct debug_method_variant *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 168struct 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 boolean (*start_compilation_unit) PARAMS ((PTR, 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 boolean (*start_source) PARAMS ((PTR, 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 boolean (*empty_type) PARAMS ((PTR)); 184 185 /* Push a void type onto the type stack. */ 186 boolean (*void_type) PARAMS ((PTR)); 187 188 /* Push an integer type onto the type stack, given the size and 189 whether it is unsigned. */ 190 boolean (*int_type) PARAMS ((PTR, unsigned int, boolean)); 191 192 /* Push a floating type onto the type stack, given the size. */ 193 boolean (*float_type) PARAMS ((PTR, unsigned int)); 194 195 /* Push a complex type onto the type stack, given the size. */ 196 boolean (*complex_type) PARAMS ((PTR, unsigned int)); 197 198 /* Push a boolean type onto the type stack, given the size. */ 199 boolean (*bool_type) PARAMS ((PTR, 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 boolean (*enum_type) PARAMS ((PTR, const char *, const char **, 206 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 boolean (*pointer_type) PARAMS ((PTR)); 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 boolean (*function_type) PARAMS ((PTR, int, boolean)); 221 222 /* Pop the top type on the type stack, and push a reference to that 223 type onto the type stack. */ 224 boolean (*reference_type) PARAMS ((PTR)); 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 boolean (*range_type) PARAMS ((PTR, 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 boolean (*array_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, 236 boolean)); 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 boolean (*set_type) PARAMS ((PTR, boolean)); 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 boolean (*offset_type) PARAMS ((PTR)); 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 boolean (*method_type) PARAMS ((PTR, boolean, int, boolean)); 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 boolean (*const_type) PARAMS ((PTR)); 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 boolean (*volatile_type) PARAMS ((PTR)); 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 boolean (*start_struct_type) PARAMS ((PTR, const char *, unsigned int, 281 boolean, 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 boolean (*struct_field) PARAMS ((PTR, const char *, bfd_vma, bfd_vma, 288 enum debug_visibility)); 289 290 /* Finish building a struct, and push it onto the type stack. */ 291 boolean (*end_struct_type) PARAMS ((PTR)); 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 boolean (*start_class_type) PARAMS ((PTR, const char *, unsigned int, 305 boolean, unsigned int, boolean, 306 boolean)); 307 308 /* Add a static member to the class currently being built. The 309 arguments are the field name, the physical name, and the 310 visibility. The type must be popped off the type stack. */ 311 boolean (*class_static_member) PARAMS ((PTR, const char *, const char *, 312 enum debug_visibility)); 313 314 /* Add a baseclass to the class currently being built. The type of 315 the baseclass must be popped off the type stack. The arguments 316 are the bit position, whether the class is virtual, and the 317 visibility. */ 318 boolean (*class_baseclass) PARAMS ((PTR, bfd_vma, boolean, 319 enum debug_visibility)); 320 321 /* Start adding a method to the class currently being built. This 322 is followed by calls to class_method_variant and 323 class_static_method_variant to describe different variants of the 324 method which take different arguments. The method is finished 325 with a call to class_end_method. The argument is the method 326 name. */ 327 boolean (*class_start_method) PARAMS ((PTR, const char *)); 328 329 /* Describe a variant to the class method currently being built. 330 The type of the variant must be popped off the type stack. The 331 second argument is the physical name of the function. The 332 following arguments are the visibility, whether the variant is 333 const, whether the variant is volatile, the offset in the virtual 334 function table, and whether the context is on the type stack 335 (below the variant type). */ 336 boolean (*class_method_variant) PARAMS ((PTR, const char *, 337 enum debug_visibility, 338 boolean, boolean, 339 bfd_vma, boolean)); 340 341 /* Describe a static variant to the class method currently being 342 built. The arguments are the same as for class_method_variant, 343 except that the last two arguments are omitted. The type of the 344 variant must be popped off the type stack. */ 345 boolean (*class_static_method_variant) PARAMS ((PTR, const char *, 346 enum debug_visibility, 347 boolean, boolean)); 348 349 /* Finish describing a class method. */ 350 boolean (*class_end_method) PARAMS ((PTR)); 351 352 /* Finish describing a class, and push it onto the type stack. */ 353 boolean (*end_class_type) PARAMS ((PTR)); 354 355 /* Push a type on the stack which was given a name by an earlier 356 call to typdef. */ 357 boolean (*typedef_type) PARAMS ((PTR, const char *)); 358 359 /* Push a tagged type on the stack which was defined earlier. If 360 the second argument is not NULL, the type was defined by a call 361 to tag. If the second argument is NULL, the type was defined by 362 a call to start_struct_type or start_class_type with a tag of 363 NULL and the number of the third argument. Either way, the 364 fourth argument is the tag kind. Note that this may be called 365 for a struct (class) being defined, in between the call to 366 start_struct_type (start_class_type) and the call to 367 end_struct_type (end_class_type). */ 368 boolean (*tag_type) PARAMS ((PTR, const char *, unsigned int, 369 enum debug_type_kind)); 370 371 /* Pop the type stack, and typedef it to the given name. */ 372 boolean (*typdef) PARAMS ((PTR, const char *)); 373 374 /* Pop the type stack, and declare it as a tagged struct or union or 375 enum or whatever. The tag passed down here is redundant, since 376 was also passed when enum_type, start_struct_type, or 377 start_class_type was called. */ 378 boolean (*tag) PARAMS ((PTR, const char *)); 379 380 /* This is called to record a named integer constant. */ 381 boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma)); 382 383 /* This is called to record a named floating point constant. */ 384 boolean (*float_constant) PARAMS ((PTR, const char *, double)); 385 386 /* This is called to record a typed integer constant. The type is 387 popped off the type stack. */ 388 boolean (*typed_constant) PARAMS ((PTR, const char *, bfd_vma)); 389 390 /* This is called to record a variable. The type is popped off the 391 type stack. */ 392 boolean (*variable) PARAMS ((PTR, const char *, enum debug_var_kind, 393 bfd_vma)); 394 395 /* Start writing out a function. The return type must be popped off 396 the stack. The boolean is true if the function is global. This 397 is followed by calls to function_parameter, followed by block 398 information. */ 399 boolean (*start_function) PARAMS ((PTR, const char *, boolean)); 400 401 /* Record a function parameter for the current function. The type 402 must be popped off the stack. */ 403 boolean (*function_parameter) PARAMS ((PTR, const char *, 404 enum debug_parm_kind, bfd_vma)); 405 406 /* Start writing out a block. There is at least one top level block 407 per function. Blocks may be nested. The argument is the 408 starting address of the block. */ 409 boolean (*start_block) PARAMS ((PTR, bfd_vma)); 410 411 /* Finish writing out a block. The argument is the ending address 412 of the block. */ 413 boolean (*end_block) PARAMS ((PTR, bfd_vma)); 414 415 /* Finish writing out a function. */ 416 boolean (*end_function) PARAMS ((PTR)); 417 418 /* Record line number information for the current compilation unit. */ 419 boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma)); 420}; 421 422/* Exported functions. */ 423 424/* The first argument to most of these functions is a handle. This 425 handle is returned by the debug_init function. The purpose of the 426 handle is to permit the debugging routines to not use static 427 variables, and hence to be reentrant. This would be useful for a 428 program which wanted to handle two executables simultaneously. */ 429 430/* Return a debugging handle. */ 431 432extern PTR debug_init PARAMS ((void)); 433 434/* Set the source filename. This implicitly starts a new compilation 435 unit. */ 436 437extern boolean debug_set_filename PARAMS ((PTR, const char *)); 438 439/* Change source files to the given file name. This is used for 440 include files in a single compilation unit. */ 441 442extern boolean debug_start_source PARAMS ((PTR, const char *)); 443 444/* Record a function definition. This implicitly starts a function 445 block. The debug_type argument is the type of the return value. 446 The boolean indicates whether the function is globally visible. 447 The bfd_vma is the address of the start of the function. Currently 448 the parameter types are specified by calls to 449 debug_record_parameter. */ 450 451extern boolean debug_record_function 452 PARAMS ((PTR, const char *, debug_type, boolean, bfd_vma)); 453 454/* Record a parameter for the current function. */ 455 456extern boolean debug_record_parameter 457 PARAMS ((PTR, const char *, debug_type, enum debug_parm_kind, bfd_vma)); 458 459/* End a function definition. The argument is the address where the 460 function ends. */ 461 462extern boolean debug_end_function PARAMS ((PTR, bfd_vma)); 463 464/* Start a block in a function. All local information will be 465 recorded in this block, until the matching call to debug_end_block. 466 debug_start_block and debug_end_block may be nested. The argument 467 is the address at which this block starts. */ 468 469extern boolean debug_start_block PARAMS ((PTR, bfd_vma)); 470 471/* Finish a block in a function. This matches the call to 472 debug_start_block. The argument is the address at which this block 473 ends. */ 474 475extern boolean debug_end_block PARAMS ((PTR, bfd_vma)); 476 477/* Associate a line number in the current source file with a given 478 address. */ 479 480extern boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma)); 481 482/* Start a named common block. This is a block of variables that may 483 move in memory. */ 484 485extern boolean debug_start_common_block PARAMS ((PTR, const char *)); 486 487/* End a named common block. */ 488 489extern boolean debug_end_common_block PARAMS ((PTR, const char *)); 490 491/* Record a named integer constant. */ 492 493extern boolean debug_record_int_const PARAMS ((PTR, const char *, bfd_vma)); 494 495/* Record a named floating point constant. */ 496 497extern boolean debug_record_float_const PARAMS ((PTR, const char *, double)); 498 499/* Record a typed constant with an integral value. */ 500 501extern boolean debug_record_typed_const 502 PARAMS ((PTR, const char *, debug_type, bfd_vma)); 503 504/* Record a label. */ 505 506extern boolean debug_record_label 507 PARAMS ((PTR, const char *, debug_type, bfd_vma)); 508 509/* Record a variable. */ 510 511extern boolean debug_record_variable 512 PARAMS ((PTR, const char *, debug_type, enum debug_var_kind, bfd_vma)); 513 514/* Make an indirect type. The first argument is a pointer to the 515 location where the real type will be placed. The second argument 516 is the type tag, if there is one; this may be NULL; the only 517 purpose of this argument is so that debug_get_type_name can return 518 something useful. This function may be used when a type is 519 referenced before it is defined. */ 520 521extern debug_type debug_make_indirect_type 522 PARAMS ((PTR, debug_type *, const char *)); 523 524/* Make a void type. */ 525 526extern debug_type debug_make_void_type PARAMS ((PTR)); 527 528/* Make an integer type of a given size. The boolean argument is true 529 if the integer is unsigned. */ 530 531extern debug_type debug_make_int_type PARAMS ((PTR, unsigned int, boolean)); 532 533/* Make a floating point type of a given size. FIXME: On some 534 platforms, like an Alpha, you probably need to be able to specify 535 the format. */ 536 537extern debug_type debug_make_float_type PARAMS ((PTR, unsigned int)); 538 539/* Make a boolean type of a given size. */ 540 541extern debug_type debug_make_bool_type PARAMS ((PTR, unsigned int)); 542 543/* Make a complex type of a given size. */ 544 545extern debug_type debug_make_complex_type PARAMS ((PTR, unsigned int)); 546 547/* Make a structure type. The second argument is true for a struct, 548 false for a union. The third argument is the size of the struct. 549 The fourth argument is a NULL terminated array of fields. */ 550 551extern debug_type debug_make_struct_type 552 PARAMS ((PTR, boolean, bfd_vma, debug_field *)); 553 554/* Make an object type. The first three arguments after the handle 555 are the same as for debug_make_struct_type. The next arguments are 556 a NULL terminated array of base classes, a NULL terminated array of 557 methods, the type of the object holding the virtual function table 558 if it is not this object, and a boolean which is true if this 559 object has its own virtual function table. */ 560 561extern debug_type debug_make_object_type 562 PARAMS ((PTR, boolean, bfd_vma, debug_field *, debug_baseclass *, 563 debug_method *, debug_type, boolean)); 564 565/* Make an enumeration type. The arguments are a null terminated 566 array of strings, and an array of corresponding values. */ 567 568extern debug_type debug_make_enum_type 569 PARAMS ((PTR, const char **, bfd_signed_vma *)); 570 571/* Make a pointer to a given type. */ 572 573extern debug_type debug_make_pointer_type 574 PARAMS ((PTR, debug_type)); 575 576/* Make a function type. The second argument is the return type. The 577 third argument is a NULL terminated array of argument types. The 578 fourth argument is true if the function takes a variable number of 579 arguments. If the third argument is NULL, then the argument types 580 are unknown. */ 581 582extern debug_type debug_make_function_type 583 PARAMS ((PTR, debug_type, debug_type *, boolean)); 584 585/* Make a reference to a given type. */ 586 587extern debug_type debug_make_reference_type PARAMS ((PTR, debug_type)); 588 589/* Make a range of a given type from a lower to an upper bound. */ 590 591extern debug_type debug_make_range_type 592 PARAMS ((PTR, debug_type, bfd_signed_vma, bfd_signed_vma)); 593 594/* Make an array type. The second argument is the type of an element 595 of the array. The third argument is the type of a range of the 596 array. The fourth and fifth argument are the lower and upper 597 bounds, respectively (if the bounds are not known, lower should be 598 0 and upper should be -1). The sixth argument is true if this 599 array is actually a string, as in C. */ 600 601extern debug_type debug_make_array_type 602 PARAMS ((PTR, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma, 603 boolean)); 604 605/* Make a set of a given type. For example, a Pascal set type. The 606 boolean argument is true if this set is actually a bitstring, as in 607 CHILL. */ 608 609extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, boolean)); 610 611/* Make a type for a pointer which is relative to an object. The 612 second argument is the type of the object to which the pointer is 613 relative. The third argument is the type that the pointer points 614 to. */ 615 616extern debug_type debug_make_offset_type 617 PARAMS ((PTR, debug_type, debug_type)); 618 619/* Make a type for a method function. The second argument is the 620 return type. The third argument is the domain. The fourth 621 argument is a NULL terminated array of argument types. The fifth 622 argument is true if the function takes a variable number of 623 arguments, in which case the array of argument types indicates the 624 types of the first arguments. The domain and the argument array 625 may be NULL, in which case this is a stub method and that 626 information is not available. Stabs debugging uses this, and gets 627 the argument types from the mangled name. */ 628 629extern debug_type debug_make_method_type 630 PARAMS ((PTR, debug_type, debug_type, debug_type *, boolean)); 631 632/* Make a const qualified version of a given type. */ 633 634extern debug_type debug_make_const_type PARAMS ((PTR, debug_type)); 635 636/* Make a volatile qualified version of a given type. */ 637 638extern debug_type debug_make_volatile_type PARAMS ((PTR, debug_type)); 639 640/* Make an undefined tagged type. For example, a struct which has 641 been mentioned, but not defined. */ 642 643extern debug_type debug_make_undefined_tagged_type 644 PARAMS ((PTR, const char *, enum debug_type_kind)); 645 646/* Make a base class for an object. The second argument is the base 647 class type. The third argument is the bit position of this base 648 class in the object. The fourth argument is whether this is a 649 virtual class. The fifth argument is the visibility of the base 650 class. */ 651 652extern debug_baseclass debug_make_baseclass 653 PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility)); 654 655/* Make a field for a struct. The second argument is the name. The 656 third argument is the type of the field. The fourth argument is 657 the bit position of the field. The fifth argument is the size of 658 the field (it may be zero). The sixth argument is the visibility 659 of the field. */ 660 661extern debug_field debug_make_field 662 PARAMS ((PTR, const char *, debug_type, bfd_vma, bfd_vma, 663 enum debug_visibility)); 664 665/* Make a static member of an object. The second argument is the 666 name. The third argument is the type of the member. The fourth 667 argument is the physical name of the member (i.e., the name as a 668 global variable). The fifth argument is the visibility of the 669 member. */ 670 671extern debug_field debug_make_static_member 672 PARAMS ((PTR, const char *, debug_type, const char *, 673 enum debug_visibility)); 674 675/* Make a method. The second argument is the name, and the third 676 argument is a NULL terminated array of method variants. Each 677 method variant is a method with this name but with different 678 argument types. */ 679 680extern debug_method debug_make_method 681 PARAMS ((PTR, const char *, debug_method_variant *)); 682 683/* Make a method variant. The second argument is the physical name of 684 the function. The third argument is the type of the function, 685 probably constructed by debug_make_method_type. The fourth 686 argument is the visibility. The fifth argument is whether this is 687 a const function. The sixth argument is whether this is a volatile 688 function. The seventh argument is the index in the virtual 689 function table, if any. The eighth argument is the virtual 690 function context. */ 691 692extern debug_method_variant debug_make_method_variant 693 PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean, 694 boolean, bfd_vma, debug_type)); 695 696/* Make a static method argument. The arguments are the same as for 697 debug_make_method_variant, except that the last two are omitted 698 since a static method can not also be virtual. */ 699 700extern debug_method_variant debug_make_static_method_variant 701 PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean, 702 boolean)); 703 704/* Name a type. This returns a new type with an attached name. */ 705 706extern debug_type debug_name_type PARAMS ((PTR, const char *, debug_type)); 707 708/* Give a tag to a type, such as a struct or union. This returns a 709 new type with an attached tag. */ 710 711extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type)); 712 713/* Record the size of a given type. */ 714 715extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int)); 716 717/* Find a named type. */ 718 719extern debug_type debug_find_named_type PARAMS ((PTR, const char *)); 720 721/* Find a tagged type. */ 722 723extern debug_type debug_find_tagged_type 724 PARAMS ((PTR, const char *, enum debug_type_kind)); 725 726/* Get the kind of a type. */ 727 728extern enum debug_type_kind debug_get_type_kind PARAMS ((PTR, debug_type)); 729 730/* Get the name of a type. */ 731 732extern const char *debug_get_type_name PARAMS ((PTR, debug_type)); 733 734/* Get the size of a type. */ 735 736extern bfd_vma debug_get_type_size PARAMS ((PTR, debug_type)); 737 738/* Get the return type of a function or method type. */ 739 740extern debug_type debug_get_return_type PARAMS ((PTR, debug_type)); 741 742/* Get the NULL terminated array of parameter types for a function or 743 method type (actually, parameter types are not currently stored for 744 function types). This may be used to determine whether a method 745 type is a stub method or not. The last argument points to a 746 boolean which is set to true if the function takes a variable 747 number of arguments. */ 748 749extern const debug_type *debug_get_parameter_types PARAMS ((PTR, 750 debug_type, 751 boolean *)); 752 753/* Get the target type of a pointer or reference or const or volatile 754 type. */ 755 756extern debug_type debug_get_target_type PARAMS ((PTR, debug_type)); 757 758/* Get the NULL terminated array of fields for a struct, union, or 759 class. */ 760 761extern const debug_field *debug_get_fields PARAMS ((PTR, debug_type)); 762 763/* Get the type of a field. */ 764 765extern debug_type debug_get_field_type PARAMS ((PTR, debug_field)); 766 767/* Get the name of a field. */ 768 769extern const char *debug_get_field_name PARAMS ((PTR, debug_field)); 770 771/* Get the bit position of a field within the containing structure. 772 If the field is a static member, this will return (bfd_vma) -1. */ 773 774extern bfd_vma debug_get_field_bitpos PARAMS ((PTR, debug_field)); 775 776/* Get the bit size of a field. If the field is a static member, this 777 will return (bfd_vma) -1. */ 778 779extern bfd_vma debug_get_field_bitsize PARAMS ((PTR, debug_field)); 780 781/* Get the visibility of a field. */ 782 783extern enum debug_visibility debug_get_field_visibility 784 PARAMS ((PTR, debug_field)); 785 786/* Get the physical name of a field, if it is a static member. If the 787 field is not a static member, this will return NULL. */ 788 789extern const char *debug_get_field_physname PARAMS ((PTR, debug_field)); 790 791/* Write out the recorded debugging information. This takes a set of 792 function pointers which are called to do the actual writing. The 793 first PTR is the debugging handle. The second PTR is a handle 794 which is passed to the functions. */ 795 796extern boolean debug_write PARAMS ((PTR, const struct debug_write_fns *, PTR)); 797 798#endif /* DEBUG_H */ 799