binutils/debug.h

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