1
/* debug.h -- Describe generic debugging information.
2
Copyright (C) 1995, 1996 Free Software Foundation, Inc.
3
Written by Ian Lance Taylor <ian@cygnus.com>.
5
This file is part of GNU Binutils.
7
This program is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2 of the License, or
10
(at your option) any later version.
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.
17
You should have received a copy of the GNU General Public License
18
along with this program; if not, write to the Free Software
19
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25
/* This header file describes a generic debugging information format.
26
We may eventually have readers which convert different formats into
27
this generic format, and writers which write it out. The initial
28
impetus for this was writing a convertor from stabs to HP IEEE-695
31
/* Different kinds of types. */
37
/* Indirect via a pointer. */
55
/* Union class (can this really happen?). */
56
DEBUG_KIND_UNION_CLASS,
57
/* Enumeration type. */
75
/* Const qualified type. */
77
/* Volatile qualified type. */
85
/* Different kinds of variables. */
91
/* A global variable. */
93
/* A static variable. */
95
/* A local static variable. */
97
/* A local variable. */
99
/* A register variable. */
103
/* Different kinds of function parameters. */
109
/* A stack based parameter. */
111
/* A register parameter. */
113
/* A stack based reference parameter. */
114
DEBUG_PARM_REFERENCE,
115
/* A register reference parameter. */
119
/* Different kinds of visibility. */
121
enum debug_visibility
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
135
typedef struct debug_type *debug_type;
137
#define DEBUG_TYPE_NULL ((debug_type) NULL)
139
/* A field in a struct or union. */
141
typedef struct debug_field *debug_field;
143
#define DEBUG_FIELD_NULL ((debug_field) NULL)
145
/* A base class for an object. */
147
typedef struct debug_baseclass *debug_baseclass;
149
#define DEBUG_BASECLASS_NULL ((debug_baseclass) NULL)
151
/* A method of an object. */
153
typedef struct debug_method *debug_method;
155
#define DEBUG_METHOD_NULL ((debug_method) NULL)
157
/* The arguments to a method function of an object. These indicate
158
which method to run. */
160
typedef struct debug_method_variant *debug_method_variant;
162
#define DEBUG_METHOD_VARIANT_NULL ((debug_method_variant) NULL)
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. */
168
struct debug_write_fns
170
/* This is called at the start of each new compilation unit with the
171
name of the main file in the new unit. */
172
boolean (*start_compilation_unit) PARAMS ((PTR, const char *));
174
/* This is called at the start of each source file within a
175
compilation unit, before outputting any global information for
176
that file. The argument is the name of the file. */
177
boolean (*start_source) PARAMS ((PTR, const char *));
179
/* Each writer must keep a stack of types. */
181
/* Push an empty type onto the type stack. This type can appear if
182
there is a reference to a type which is never defined. */
183
boolean (*empty_type) PARAMS ((PTR));
185
/* Push a void type onto the type stack. */
186
boolean (*void_type) PARAMS ((PTR));
188
/* Push an integer type onto the type stack, given the size and
189
whether it is unsigned. */
190
boolean (*int_type) PARAMS ((PTR, unsigned int, boolean));
192
/* Push a floating type onto the type stack, given the size. */
193
boolean (*float_type) PARAMS ((PTR, unsigned int));
195
/* Push a complex type onto the type stack, given the size. */
196
boolean (*complex_type) PARAMS ((PTR, unsigned int));
198
/* Push a boolean type onto the type stack, given the size. */
199
boolean (*bool_type) PARAMS ((PTR, unsigned int));
201
/* Push an enum type onto the type stack, given the tag, a NULL
202
terminated array of names and the associated values. If there is
203
no tag, the tag argument will be NULL. If this is an undefined
204
enum, the names and values arguments will be NULL. */
205
boolean (*enum_type) PARAMS ((PTR, const char *, const char **,
208
/* Pop the top type on the type stack, and push a pointer to that
209
type onto the type stack. */
210
boolean (*pointer_type) PARAMS ((PTR));
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
220
boolean (*function_type) PARAMS ((PTR, int, boolean));
222
/* Pop the top type on the type stack, and push a reference to that
223
type onto the type stack. */
224
boolean (*reference_type) PARAMS ((PTR));
226
/* Pop the top type on the type stack, and push a range of that type
227
with the given lower and upper bounds onto the type stack. */
228
boolean (*range_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
230
/* Push an array type onto the type stack. The top type on the type
231
stack is the range, and the next type on the type stack is the
232
element type. These should be popped before the array type is
233
pushed. The arguments are the lower bound, the upper bound, and
234
whether the array is a string. */
235
boolean (*array_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma,
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
241
boolean (*set_type) PARAMS ((PTR, boolean));
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
247
boolean (*offset_type) PARAMS ((PTR));
249
/* Push a method type onto the type stack. If the second argument
250
is true, the top type on the stack is the class to which the
251
method belongs; otherwise, the class must be determined by the
252
class to which the method is attached. The third argument is the
253
number of argument types; these are pushed onto the type stack in
254
reverse order (the first type popped is the last argument to the
255
method). A value of -1 for the third argument means that no
256
argument information is available. The fourth argument is true
257
if the function takes a variable number of arguments. The next
258
type on the type stack below the domain and the argument types is
259
the return type of the method. All these types must be popped,
260
and then the method type must be pushed. */
261
boolean (*method_type) PARAMS ((PTR, boolean, int, boolean));
263
/* Pop the top type off the type stack, and push a const qualified
264
version of that type onto the type stack. */
265
boolean (*const_type) PARAMS ((PTR));
267
/* Pop the top type off the type stack, and push a volatile
268
qualified version of that type onto the type stack. */
269
boolean (*volatile_type) PARAMS ((PTR));
271
/* Start building a struct. This is followed by calls to the
272
struct_field function, and finished by a call to the
273
end_struct_type function. The second argument is the tag; this
274
will be NULL if there isn't one. If the second argument is NULL,
275
the third argument is a constant identifying this struct for use
276
with tag_type. The fourth argument is true for a struct, false
277
for a union. The fifth argument is the size. If this is an
278
undefined struct or union, the size will be 0 and struct_field
279
will not be called before end_struct_type is called. */
280
boolean (*start_struct_type) PARAMS ((PTR, const char *, unsigned int,
281
boolean, unsigned int));
283
/* Add a field to the struct type currently being built. The type
284
of the field should be popped off the type stack. The arguments
285
are the name, the bit position, the bit size (may be zero if the
286
field is not packed), and the visibility. */
287
boolean (*struct_field) PARAMS ((PTR, const char *, bfd_vma, bfd_vma,
288
enum debug_visibility));
290
/* Finish building a struct, and push it onto the type stack. */
291
boolean (*end_struct_type) PARAMS ((PTR));
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
304
boolean (*start_class_type) PARAMS ((PTR, const char *, unsigned int,
305
boolean, unsigned int, boolean,
308
/* Add a static member to the class currently being built. The
309
arguments are the field name, the physical name, and the
310
visibility. The type must be popped off the type stack. */
311
boolean (*class_static_member) PARAMS ((PTR, const char *, const char *,
312
enum debug_visibility));
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
318
boolean (*class_baseclass) PARAMS ((PTR, bfd_vma, boolean,
319
enum debug_visibility));
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
327
boolean (*class_start_method) PARAMS ((PTR, const char *));
329
/* Describe a variant to the class method currently being built.
330
The type of the variant must be popped off the type stack. The
331
second argument is the physical name of the function. The
332
following arguments are the visibility, whether the variant is
333
const, whether the variant is volatile, the offset in the virtual
334
function table, and whether the context is on the type stack
335
(below the variant type). */
336
boolean (*class_method_variant) PARAMS ((PTR, const char *,
337
enum debug_visibility,
341
/* Describe a static variant to the class method currently being
342
built. The arguments are the same as for class_method_variant,
343
except that the last two arguments are omitted. The type of the
344
variant must be popped off the type stack. */
345
boolean (*class_static_method_variant) PARAMS ((PTR, const char *,
346
enum debug_visibility,
349
/* Finish describing a class method. */
350
boolean (*class_end_method) PARAMS ((PTR));
352
/* Finish describing a class, and push it onto the type stack. */
353
boolean (*end_class_type) PARAMS ((PTR));
355
/* Push a type on the stack which was given a name by an earlier
357
boolean (*typedef_type) PARAMS ((PTR, const char *));
359
/* Push a tagged type on the stack which was defined earlier. If
360
the second argument is not NULL, the type was defined by a call
361
to tag. If the second argument is NULL, the type was defined by
362
a call to start_struct_type or start_class_type with a tag of
363
NULL and the number of the third argument. Either way, the
364
fourth argument is the tag kind. Note that this may be called
365
for a struct (class) being defined, in between the call to
366
start_struct_type (start_class_type) and the call to
367
end_struct_type (end_class_type). */
368
boolean (*tag_type) PARAMS ((PTR, const char *, unsigned int,
369
enum debug_type_kind));
371
/* Pop the type stack, and typedef it to the given name. */
372
boolean (*typdef) PARAMS ((PTR, const char *));
374
/* Pop the type stack, and declare it as a tagged struct or union or
375
enum or whatever. The tag passed down here is redundant, since
376
was also passed when enum_type, start_struct_type, or
377
start_class_type was called. */
378
boolean (*tag) PARAMS ((PTR, const char *));
380
/* This is called to record a named integer constant. */
381
boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma));
383
/* This is called to record a named floating point constant. */
384
boolean (*float_constant) PARAMS ((PTR, const char *, double));
386
/* This is called to record a typed integer constant. The type is
387
popped off the type stack. */
388
boolean (*typed_constant) PARAMS ((PTR, const char *, bfd_vma));
390
/* This is called to record a variable. The type is popped off the
392
boolean (*variable) PARAMS ((PTR, const char *, enum debug_var_kind,
395
/* Start writing out a function. The return type must be popped off
396
the stack. The boolean is true if the function is global. This
397
is followed by calls to function_parameter, followed by block
399
boolean (*start_function) PARAMS ((PTR, const char *, boolean));
401
/* Record a function parameter for the current function. The type
402
must be popped off the stack. */
403
boolean (*function_parameter) PARAMS ((PTR, const char *,
404
enum debug_parm_kind, bfd_vma));
406
/* Start writing out a block. There is at least one top level block
407
per function. Blocks may be nested. The argument is the
408
starting address of the block. */
409
boolean (*start_block) PARAMS ((PTR, bfd_vma));
411
/* Finish writing out a block. The argument is the ending address
413
boolean (*end_block) PARAMS ((PTR, bfd_vma));
415
/* Finish writing out a function. */
416
boolean (*end_function) PARAMS ((PTR));
418
/* Record line number information for the current compilation unit. */
419
boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma));
422
/* Exported functions. */
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. */
430
/* Return a debugging handle. */
432
extern PTR debug_init PARAMS ((void));
434
/* Set the source filename. This implicitly starts a new compilation
437
extern boolean debug_set_filename PARAMS ((PTR, const char *));
439
/* Change source files to the given file name. This is used for
440
include files in a single compilation unit. */
442
extern boolean debug_start_source PARAMS ((PTR, const char *));
444
/* Record a function definition. This implicitly starts a function
445
block. The debug_type argument is the type of the return value.
446
The boolean indicates whether the function is globally visible.
447
The bfd_vma is the address of the start of the function. Currently
448
the parameter types are specified by calls to
449
debug_record_parameter. */
451
extern boolean debug_record_function
452
PARAMS ((PTR, const char *, debug_type, boolean, bfd_vma));
454
/* Record a parameter for the current function. */
456
extern boolean debug_record_parameter
457
PARAMS ((PTR, const char *, debug_type, enum debug_parm_kind, bfd_vma));
459
/* End a function definition. The argument is the address where the
462
extern boolean debug_end_function PARAMS ((PTR, bfd_vma));
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. */
469
extern boolean debug_start_block PARAMS ((PTR, bfd_vma));
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
475
extern boolean debug_end_block PARAMS ((PTR, bfd_vma));
477
/* Associate a line number in the current source file with a given
480
extern boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma));
482
/* Start a named common block. This is a block of variables that may
485
extern boolean debug_start_common_block PARAMS ((PTR, const char *));
487
/* End a named common block. */
489
extern boolean debug_end_common_block PARAMS ((PTR, const char *));
491
/* Record a named integer constant. */
493
extern boolean debug_record_int_const PARAMS ((PTR, const char *, bfd_vma));
495
/* Record a named floating point constant. */
497
extern boolean debug_record_float_const PARAMS ((PTR, const char *, double));
499
/* Record a typed constant with an integral value. */
501
extern boolean debug_record_typed_const
502
PARAMS ((PTR, const char *, debug_type, bfd_vma));
504
/* Record a label. */
506
extern boolean debug_record_label
507
PARAMS ((PTR, const char *, debug_type, bfd_vma));
509
/* Record a variable. */
511
extern boolean debug_record_variable
512
PARAMS ((PTR, const char *, debug_type, enum debug_var_kind, bfd_vma));
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. */
521
extern debug_type debug_make_indirect_type
522
PARAMS ((PTR, debug_type *, const char *));
524
/* Make a void type. */
526
extern debug_type debug_make_void_type PARAMS ((PTR));
528
/* Make an integer type of a given size. The boolean argument is true
529
if the integer is unsigned. */
531
extern debug_type debug_make_int_type PARAMS ((PTR, unsigned int, boolean));
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
537
extern debug_type debug_make_float_type PARAMS ((PTR, unsigned int));
539
/* Make a boolean type of a given size. */
541
extern debug_type debug_make_bool_type PARAMS ((PTR, unsigned int));
543
/* Make a complex type of a given size. */
545
extern debug_type debug_make_complex_type PARAMS ((PTR, unsigned int));
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. */
551
extern debug_type debug_make_struct_type
552
PARAMS ((PTR, boolean, bfd_vma, debug_field *));
554
/* Make an object type. The first three arguments after the handle
555
are the same as for debug_make_struct_type. The next arguments are
556
a NULL terminated array of base classes, a NULL terminated array of
557
methods, the type of the object holding the virtual function table
558
if it is not this object, and a boolean which is true if this
559
object has its own virtual function table. */
561
extern debug_type debug_make_object_type
562
PARAMS ((PTR, boolean, bfd_vma, debug_field *, debug_baseclass *,
563
debug_method *, debug_type, boolean));
565
/* Make an enumeration type. The arguments are a null terminated
566
array of strings, and an array of corresponding values. */
568
extern debug_type debug_make_enum_type
569
PARAMS ((PTR, const char **, bfd_signed_vma *));
571
/* Make a pointer to a given type. */
573
extern debug_type debug_make_pointer_type
574
PARAMS ((PTR, debug_type));
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
582
extern debug_type debug_make_function_type
583
PARAMS ((PTR, debug_type, debug_type *, boolean));
585
/* Make a reference to a given type. */
587
extern debug_type debug_make_reference_type PARAMS ((PTR, debug_type));
589
/* Make a range of a given type from a lower to an upper bound. */
591
extern debug_type debug_make_range_type
592
PARAMS ((PTR, debug_type, bfd_signed_vma, bfd_signed_vma));
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. */
601
extern debug_type debug_make_array_type
602
PARAMS ((PTR, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma,
605
/* Make a set of a given type. For example, a Pascal set type. The
606
boolean argument is true if this set is actually a bitstring, as in
609
extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, boolean));
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
616
extern debug_type debug_make_offset_type
617
PARAMS ((PTR, debug_type, debug_type));
619
/* Make a type for a method function. The second argument is the
620
return type. The third argument is the domain. The fourth
621
argument is a NULL terminated array of argument types. The fifth
622
argument is true if the function takes a variable number of
623
arguments, in which case the array of argument types indicates the
624
types of the first arguments. The domain and the argument array
625
may be NULL, in which case this is a stub method and that
626
information is not available. Stabs debugging uses this, and gets
627
the argument types from the mangled name. */
629
extern debug_type debug_make_method_type
630
PARAMS ((PTR, debug_type, debug_type, debug_type *, boolean));
632
/* Make a const qualified version of a given type. */
634
extern debug_type debug_make_const_type PARAMS ((PTR, debug_type));
636
/* Make a volatile qualified version of a given type. */
638
extern debug_type debug_make_volatile_type PARAMS ((PTR, debug_type));
640
/* Make an undefined tagged type. For example, a struct which has
641
been mentioned, but not defined. */
643
extern debug_type debug_make_undefined_tagged_type
644
PARAMS ((PTR, const char *, enum debug_type_kind));
646
/* Make a base class for an object. The second argument is the base
647
class type. The third argument is the bit position of this base
648
class in the object. The fourth argument is whether this is a
649
virtual class. The fifth argument is the visibility of the base
652
extern debug_baseclass debug_make_baseclass
653
PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility));
655
/* Make a field for a struct. The second argument is the name. The
656
third argument is the type of the field. The fourth argument is
657
the bit position of the field. The fifth argument is the size of
658
the field (it may be zero). The sixth argument is the visibility
661
extern debug_field debug_make_field
662
PARAMS ((PTR, const char *, debug_type, bfd_vma, bfd_vma,
663
enum debug_visibility));
665
/* Make a static member of an object. The second argument is the
666
name. The third argument is the type of the member. The fourth
667
argument is the physical name of the member (i.e., the name as a
668
global variable). The fifth argument is the visibility of the
671
extern debug_field debug_make_static_member
672
PARAMS ((PTR, const char *, debug_type, const char *,
673
enum debug_visibility));
675
/* Make a method. The second argument is the name, and the third
676
argument is a NULL terminated array of method variants. Each
677
method variant is a method with this name but with different
680
extern debug_method debug_make_method
681
PARAMS ((PTR, const char *, debug_method_variant *));
683
/* Make a method variant. The second argument is the physical name of
684
the function. The third argument is the type of the function,
685
probably constructed by debug_make_method_type. The fourth
686
argument is the visibility. The fifth argument is whether this is
687
a const function. The sixth argument is whether this is a volatile
688
function. The seventh argument is the index in the virtual
689
function table, if any. The eighth argument is the virtual
692
extern debug_method_variant debug_make_method_variant
693
PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
694
boolean, bfd_vma, debug_type));
696
/* Make a static method argument. The arguments are the same as for
697
debug_make_method_variant, except that the last two are omitted
698
since a static method can not also be virtual. */
700
extern debug_method_variant debug_make_static_method_variant
701
PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
704
/* Name a type. This returns a new type with an attached name. */
706
extern debug_type debug_name_type PARAMS ((PTR, const char *, debug_type));
708
/* Give a tag to a type, such as a struct or union. This returns a
709
new type with an attached tag. */
711
extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type));
713
/* Record the size of a given type. */
715
extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int));
717
/* Find a named type. */
719
extern debug_type debug_find_named_type PARAMS ((PTR, const char *));
721
/* Find a tagged type. */
723
extern debug_type debug_find_tagged_type
724
PARAMS ((PTR, const char *, enum debug_type_kind));
726
/* Get the kind of a type. */
728
extern enum debug_type_kind debug_get_type_kind PARAMS ((PTR, debug_type));
730
/* Get the name of a type. */
732
extern const char *debug_get_type_name PARAMS ((PTR, debug_type));
734
/* Get the size of a type. */
736
extern bfd_vma debug_get_type_size PARAMS ((PTR, debug_type));
738
/* Get the return type of a function or method type. */
740
extern debug_type debug_get_return_type PARAMS ((PTR, debug_type));
742
/* Get the NULL terminated array of parameter types for a function or
743
method type (actually, parameter types are not currently stored for
744
function types). This may be used to determine whether a method
745
type is a stub method or not. The last argument points to a
746
boolean which is set to true if the function takes a variable
747
number of arguments. */
749
extern const debug_type *debug_get_parameter_types PARAMS ((PTR,
753
/* Get the target type of a pointer or reference or const or volatile
756
extern debug_type debug_get_target_type PARAMS ((PTR, debug_type));
758
/* Get the NULL terminated array of fields for a struct, union, or
761
extern const debug_field *debug_get_fields PARAMS ((PTR, debug_type));
763
/* Get the type of a field. */
765
extern debug_type debug_get_field_type PARAMS ((PTR, debug_field));
767
/* Get the name of a field. */
769
extern const char *debug_get_field_name PARAMS ((PTR, debug_field));
771
/* Get the bit position of a field within the containing structure.
772
If the field is a static member, this will return (bfd_vma) -1. */
774
extern bfd_vma debug_get_field_bitpos PARAMS ((PTR, debug_field));
776
/* Get the bit size of a field. If the field is a static member, this
777
will return (bfd_vma) -1. */
779
extern bfd_vma debug_get_field_bitsize PARAMS ((PTR, debug_field));
781
/* Get the visibility of a field. */
783
extern enum debug_visibility debug_get_field_visibility
784
PARAMS ((PTR, debug_field));
786
/* Get the physical name of a field, if it is a static member. If the
787
field is not a static member, this will return NULL. */
789
extern const char *debug_get_field_physname PARAMS ((PTR, debug_field));
791
/* Write out the recorded debugging information. This takes a set of
792
function pointers which are called to do the actual writing. The
793
first PTR is the debugging handle. The second PTR is a handle
794
which is passed to the functions. */
796
extern boolean debug_write PARAMS ((PTR, const struct debug_write_fns *, PTR));
added
removed
pstack/debug.h
