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