contrib/binutils-2.24/binutils/debug.h

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