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