~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to pstack/debug.h

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* debug.h -- Describe generic debugging information.
 
2
   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
 
3
   Written by Ian Lance Taylor <ian@cygnus.com>.
 
4
 
 
5
   This file is part of GNU Binutils.
 
6
 
 
7
   This program is free software; you can redistribute it and/or modify
 
8
   it under the terms of the GNU General Public License as published by
 
9
   the Free Software Foundation; either version 2 of the License, or
 
10
   (at your option) any later version.
 
11
 
 
12
   This program is distributed in the hope that it will be useful,
 
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
   GNU General Public License for more details.
 
16
 
 
17
   You should have received a copy of the GNU General Public License
 
18
   along with this program; if not, write to the Free Software
 
19
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
20
   02111-1307, USA.  */
 
21
 
 
22
#ifndef DEBUG_H
 
23
#define DEBUG_H
 
24
 
 
25
/* This header file describes a generic debugging information format.
 
26
   We may eventually have readers which convert different formats into
 
27
   this generic format, and writers which write it out.  The initial
 
28
   impetus for this was writing a convertor from stabs to HP IEEE-695
 
29
   debugging format.  */
 
30
 
 
31
/* Different kinds of types.  */
 
32
 
 
33
enum debug_type_kind
 
34
{
 
35
  /* 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 *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 *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 *debug_baseclass;
 
148
 
 
149
#define DEBUG_BASECLASS_NULL ((debug_baseclass) NULL)
 
150
 
 
151
/* A method of an object.  */
 
152
 
 
153
typedef struct debug_method *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 *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
  boolean (*start_compilation_unit) PARAMS ((PTR, 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
  boolean (*start_source) PARAMS ((PTR, 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
  boolean (*empty_type) PARAMS ((PTR));
 
184
 
 
185
  /* Push a void type onto the type stack.  */
 
186
  boolean (*void_type) PARAMS ((PTR));
 
187
 
 
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));
 
191
 
 
192
  /* Push a floating type onto the type stack, given the size.  */
 
193
  boolean (*float_type) PARAMS ((PTR, unsigned int));
 
194
 
 
195
  /* Push a complex type onto the type stack, given the size.  */
 
196
  boolean (*complex_type) PARAMS ((PTR, unsigned int));
 
197
 
 
198
  /* Push a boolean type onto the type stack, given the size.  */
 
199
  boolean (*bool_type) PARAMS ((PTR, 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
  boolean (*enum_type) PARAMS ((PTR, const char *, const char **,
 
206
                                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
  boolean (*pointer_type) PARAMS ((PTR));
 
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
  boolean (*function_type) PARAMS ((PTR, int, boolean));
 
221
 
 
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));
 
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
  boolean (*range_type) PARAMS ((PTR, 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
  boolean (*array_type) PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma,
 
236
                                 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
  boolean (*set_type) PARAMS ((PTR, 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
  boolean (*offset_type) PARAMS ((PTR));
 
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
  boolean (*method_type) PARAMS ((PTR, boolean, int, 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
  boolean (*const_type) PARAMS ((PTR));
 
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
  boolean (*volatile_type) PARAMS ((PTR));
 
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
  boolean (*start_struct_type) PARAMS ((PTR, const char *, unsigned int,
 
281
                                        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
  boolean (*struct_field) PARAMS ((PTR, const char *, bfd_vma, bfd_vma,
 
288
                                   enum debug_visibility));
 
289
 
 
290
  /* Finish building a struct, and push it onto the type stack.  */
 
291
  boolean (*end_struct_type) PARAMS ((PTR));
 
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
  boolean (*start_class_type) PARAMS ((PTR, const char *, unsigned int,
 
305
                                       boolean, unsigned int, boolean,
 
306
                                       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
  boolean (*class_static_member) PARAMS ((PTR, const char *, const char *,
 
312
                                          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
  boolean (*class_baseclass) PARAMS ((PTR, bfd_vma, boolean,
 
319
                                      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
  boolean (*class_start_method) PARAMS ((PTR, 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
  boolean (*class_method_variant) PARAMS ((PTR, const char *,
 
337
                                           enum debug_visibility,
 
338
                                           boolean, boolean,
 
339
                                           bfd_vma, boolean));
 
340
 
 
341
  /* Describe a static variant to the class method currently being
 
342
     built.  The arguments are the same as for class_method_variant,
 
343
     except that the last two arguments are omitted.  The type of the
 
344
     variant must be popped off the type stack.  */
 
345
  boolean (*class_static_method_variant) PARAMS ((PTR, const char *,
 
346
                                                  enum debug_visibility,
 
347
                                                  boolean, boolean));
 
348
 
 
349
  /* Finish describing a class method.  */
 
350
  boolean (*class_end_method) PARAMS ((PTR));
 
351
 
 
352
  /* Finish describing a class, and push it onto the type stack.  */
 
353
  boolean (*end_class_type) PARAMS ((PTR));
 
354
 
 
355
  /* Push a type on the stack which was given a name by an earlier
 
356
     call to typdef.  */
 
357
  boolean (*typedef_type) PARAMS ((PTR, const char *));
 
358
 
 
359
  /* Push a tagged type on the stack which was defined earlier.  If
 
360
     the second argument is not NULL, the type was defined by a call
 
361
     to tag.  If the second argument is NULL, the type was defined by
 
362
     a call to start_struct_type or start_class_type with a tag of
 
363
     NULL and the number of the third argument.  Either way, the
 
364
     fourth argument is the tag kind.  Note that this may be called
 
365
     for a struct (class) being defined, in between the call to
 
366
     start_struct_type (start_class_type) and the call to
 
367
     end_struct_type (end_class_type).  */
 
368
  boolean (*tag_type) PARAMS ((PTR, const char *, unsigned int,
 
369
                               enum debug_type_kind));
 
370
 
 
371
  /* Pop the type stack, and typedef it to the given name.  */
 
372
  boolean (*typdef) PARAMS ((PTR, const char *));
 
373
 
 
374
  /* Pop the type stack, and declare it as a tagged struct or union or
 
375
     enum or whatever.  The tag passed down here is redundant, since
 
376
     was also passed when enum_type, start_struct_type, or
 
377
     start_class_type was called.  */
 
378
  boolean (*tag) PARAMS ((PTR, const char *));
 
379
 
 
380
  /* This is called to record a named integer constant.  */
 
381
  boolean (*int_constant) PARAMS ((PTR, const char *, bfd_vma));
 
382
 
 
383
  /* This is called to record a named floating point constant.  */
 
384
  boolean (*float_constant) PARAMS ((PTR, const char *, double));
 
385
 
 
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));
 
389
 
 
390
  /* This is called to record a variable.  The type is popped off the
 
391
     type stack.  */
 
392
  boolean (*variable) PARAMS ((PTR, const char *, enum debug_var_kind,
 
393
                               bfd_vma));
 
394
 
 
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
 
398
     information.  */
 
399
  boolean (*start_function) PARAMS ((PTR, const char *, boolean));
 
400
 
 
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));
 
405
 
 
406
  /* Start writing out a block.  There is at least one top level block
 
407
     per function.  Blocks may be nested.  The argument is the
 
408
     starting address of the block.  */
 
409
  boolean (*start_block) PARAMS ((PTR, bfd_vma));
 
410
 
 
411
  /* Finish writing out a block.  The argument is the ending address
 
412
     of the block.  */
 
413
  boolean (*end_block) PARAMS ((PTR, bfd_vma));
 
414
 
 
415
  /* Finish writing out a function.  */
 
416
  boolean (*end_function) PARAMS ((PTR));
 
417
 
 
418
  /* Record line number information for the current compilation unit.  */
 
419
  boolean (*lineno) PARAMS ((PTR, const char *, unsigned long, bfd_vma));
 
420
};
 
421
 
 
422
/* Exported functions.  */
 
423
 
 
424
/* The first argument to most of these functions is a handle.  This
 
425
   handle is returned by the debug_init function.  The purpose of the
 
426
   handle is to permit the debugging routines to not use static
 
427
   variables, and hence to be reentrant.  This would be useful for a
 
428
   program which wanted to handle two executables simultaneously.  */
 
429
 
 
430
/* Return a debugging handle.  */
 
431
 
 
432
extern PTR debug_init PARAMS ((void));
 
433
 
 
434
/* Set the source filename.  This implicitly starts a new compilation
 
435
   unit.  */
 
436
 
 
437
extern boolean debug_set_filename PARAMS ((PTR, const char *));
 
438
 
 
439
/* Change source files to the given file name.  This is used for
 
440
   include files in a single compilation unit.  */
 
441
 
 
442
extern boolean debug_start_source PARAMS ((PTR, const char *));
 
443
 
 
444
/* Record a function definition.  This implicitly starts a function
 
445
   block.  The debug_type argument is the type of the return value.
 
446
   The boolean indicates whether the function is globally visible.
 
447
   The bfd_vma is the address of the start of the function.  Currently
 
448
   the parameter types are specified by calls to
 
449
   debug_record_parameter.  */
 
450
 
 
451
extern boolean debug_record_function
 
452
  PARAMS ((PTR, const char *, debug_type, boolean, bfd_vma));
 
453
 
 
454
/* Record a parameter for the current function.  */
 
455
 
 
456
extern boolean debug_record_parameter
 
457
  PARAMS ((PTR, const char *, debug_type, enum debug_parm_kind, bfd_vma));
 
458
 
 
459
/* End a function definition.  The argument is the address where the
 
460
   function ends.  */
 
461
 
 
462
extern boolean debug_end_function PARAMS ((PTR, bfd_vma));
 
463
 
 
464
/* Start a block in a function.  All local information will be
 
465
   recorded in this block, until the matching call to debug_end_block.
 
466
   debug_start_block and debug_end_block may be nested.  The argument
 
467
   is the address at which this block starts.  */
 
468
 
 
469
extern boolean debug_start_block PARAMS ((PTR, bfd_vma));
 
470
 
 
471
/* Finish a block in a function.  This matches the call to
 
472
   debug_start_block.  The argument is the address at which this block
 
473
   ends.  */
 
474
 
 
475
extern boolean debug_end_block PARAMS ((PTR, bfd_vma));
 
476
 
 
477
/* Associate a line number in the current source file with a given
 
478
   address.  */
 
479
 
 
480
extern boolean debug_record_line PARAMS ((PTR, unsigned long, bfd_vma));
 
481
 
 
482
/* Start a named common block.  This is a block of variables that may
 
483
   move in memory.  */
 
484
 
 
485
extern boolean debug_start_common_block PARAMS ((PTR, const char *));
 
486
 
 
487
/* End a named common block.  */
 
488
 
 
489
extern boolean debug_end_common_block PARAMS ((PTR, const char *));
 
490
 
 
491
/* Record a named integer constant.  */
 
492
 
 
493
extern boolean debug_record_int_const PARAMS ((PTR, const char *, bfd_vma));
 
494
 
 
495
/* Record a named floating point constant.  */
 
496
 
 
497
extern boolean debug_record_float_const PARAMS ((PTR, const char *, double));
 
498
 
 
499
/* Record a typed constant with an integral value.  */
 
500
 
 
501
extern boolean debug_record_typed_const
 
502
  PARAMS ((PTR, const char *, debug_type, bfd_vma));
 
503
 
 
504
/* Record a label.  */
 
505
 
 
506
extern boolean debug_record_label
 
507
  PARAMS ((PTR, const char *, debug_type, bfd_vma));
 
508
 
 
509
/* Record a variable.  */
 
510
 
 
511
extern boolean debug_record_variable
 
512
  PARAMS ((PTR, const char *, debug_type, enum debug_var_kind, bfd_vma));
 
513
 
 
514
/* Make an indirect type.  The first argument is a pointer to the
 
515
   location where the real type will be placed.  The second argument
 
516
   is the type tag, if there is one; this may be NULL; the only
 
517
   purpose of this argument is so that debug_get_type_name can return
 
518
   something useful.  This function may be used when a type is
 
519
   referenced before it is defined.  */
 
520
 
 
521
extern debug_type debug_make_indirect_type
 
522
  PARAMS ((PTR, debug_type *, const char *));
 
523
 
 
524
/* Make a void type.  */
 
525
 
 
526
extern debug_type debug_make_void_type PARAMS ((PTR));
 
527
 
 
528
/* Make an integer type of a given size.  The boolean argument is true
 
529
   if the integer is unsigned.  */
 
530
 
 
531
extern debug_type debug_make_int_type PARAMS ((PTR, unsigned int, boolean));
 
532
 
 
533
/* Make a floating point type of a given size.  FIXME: On some
 
534
   platforms, like an Alpha, you probably need to be able to specify
 
535
   the format.  */
 
536
 
 
537
extern debug_type debug_make_float_type PARAMS ((PTR, unsigned int));
 
538
 
 
539
/* Make a boolean type of a given size.  */
 
540
 
 
541
extern debug_type debug_make_bool_type PARAMS ((PTR, unsigned int));
 
542
 
 
543
/* Make a complex type of a given size.  */
 
544
 
 
545
extern debug_type debug_make_complex_type PARAMS ((PTR, unsigned int));
 
546
 
 
547
/* Make a structure type.  The second argument is true for a struct,
 
548
   false for a union.  The third argument is the size of the struct.
 
549
   The fourth argument is a NULL terminated array of fields.  */
 
550
 
 
551
extern debug_type debug_make_struct_type
 
552
  PARAMS ((PTR, boolean, bfd_vma, debug_field *));
 
553
 
 
554
/* Make an object type.  The first three arguments after the handle
 
555
   are the same as for debug_make_struct_type.  The next arguments are
 
556
   a NULL terminated array of base classes, a NULL terminated array of
 
557
   methods, the type of the object holding the virtual function table
 
558
   if it is not this object, and a boolean which is true if this
 
559
   object has its own virtual function table.  */
 
560
 
 
561
extern debug_type debug_make_object_type
 
562
  PARAMS ((PTR, boolean, bfd_vma, debug_field *, debug_baseclass *,
 
563
           debug_method *, debug_type, boolean));
 
564
 
 
565
/* Make an enumeration type.  The arguments are a null terminated
 
566
   array of strings, and an array of corresponding values.  */
 
567
 
 
568
extern debug_type debug_make_enum_type
 
569
  PARAMS ((PTR, const char **, bfd_signed_vma *));
 
570
 
 
571
/* Make a pointer to a given type.  */
 
572
 
 
573
extern debug_type debug_make_pointer_type
 
574
  PARAMS ((PTR, 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
  PARAMS ((PTR, debug_type, debug_type *, boolean));
 
584
 
 
585
/* Make a reference to a given type.  */
 
586
 
 
587
extern debug_type debug_make_reference_type PARAMS ((PTR, 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
  PARAMS ((PTR, 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
  PARAMS ((PTR, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma,
 
603
           boolean));
 
604
 
 
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
 
607
   CHILL.  */
 
608
 
 
609
extern debug_type debug_make_set_type PARAMS ((PTR, debug_type, boolean));
 
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
 
617
  PARAMS ((PTR, debug_type, debug_type));
 
618
 
 
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.  */
 
628
 
 
629
extern debug_type debug_make_method_type
 
630
  PARAMS ((PTR, debug_type, debug_type, debug_type *, boolean));
 
631
 
 
632
/* Make a const qualified version of a given type.  */
 
633
 
 
634
extern debug_type debug_make_const_type PARAMS ((PTR, debug_type));
 
635
 
 
636
/* Make a volatile qualified version of a given type.  */
 
637
 
 
638
extern debug_type debug_make_volatile_type PARAMS ((PTR, debug_type));
 
639
 
 
640
/* Make an undefined tagged type.  For example, a struct which has
 
641
   been mentioned, but not defined.  */
 
642
 
 
643
extern debug_type debug_make_undefined_tagged_type
 
644
  PARAMS ((PTR, const char *, enum debug_type_kind));
 
645
 
 
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
 
650
   class.  */
 
651
 
 
652
extern debug_baseclass debug_make_baseclass
 
653
  PARAMS ((PTR, debug_type, bfd_vma, boolean, enum debug_visibility));
 
654
 
 
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
 
659
   of the field.  */
 
660
 
 
661
extern debug_field debug_make_field
 
662
  PARAMS ((PTR, const char *, debug_type, bfd_vma, bfd_vma,
 
663
           enum debug_visibility));
 
664
 
 
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
 
669
   member.  */
 
670
 
 
671
extern debug_field debug_make_static_member
 
672
  PARAMS ((PTR, const char *, debug_type, const char *,
 
673
           enum debug_visibility));
 
674
 
 
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
 
678
   argument types.  */
 
679
 
 
680
extern debug_method debug_make_method
 
681
  PARAMS ((PTR, const char *, debug_method_variant *));
 
682
 
 
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
 
690
   function context.  */
 
691
 
 
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));
 
695
 
 
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.  */
 
699
 
 
700
extern debug_method_variant debug_make_static_method_variant
 
701
  PARAMS ((PTR, const char *, debug_type, enum debug_visibility, boolean,
 
702
           boolean));
 
703
 
 
704
/* Name a type.  This returns a new type with an attached name.  */
 
705
 
 
706
extern debug_type debug_name_type PARAMS ((PTR, const char *, debug_type));
 
707
 
 
708
/* Give a tag to a type, such as a struct or union.  This returns a
 
709
   new type with an attached tag.  */
 
710
 
 
711
extern debug_type debug_tag_type PARAMS ((PTR, const char *, debug_type));
 
712
 
 
713
/* Record the size of a given type.  */
 
714
 
 
715
extern boolean debug_record_type_size PARAMS ((PTR, debug_type, unsigned int));
 
716
 
 
717
/* Find a named type.  */
 
718
 
 
719
extern debug_type debug_find_named_type PARAMS ((PTR, const char *));
 
720
 
 
721
/* Find a tagged type.  */
 
722
 
 
723
extern debug_type debug_find_tagged_type
 
724
  PARAMS ((PTR, const char *, enum debug_type_kind));
 
725
 
 
726
/* Get the kind of a type.  */
 
727
 
 
728
extern enum debug_type_kind debug_get_type_kind PARAMS ((PTR, debug_type));
 
729
 
 
730
/* Get the name of a type.  */
 
731
 
 
732
extern const char *debug_get_type_name PARAMS ((PTR, debug_type));
 
733
 
 
734
/* Get the size of a type.  */
 
735
 
 
736
extern bfd_vma debug_get_type_size PARAMS ((PTR, debug_type));
 
737
 
 
738
/* Get the return type of a function or method type.  */
 
739
 
 
740
extern debug_type debug_get_return_type PARAMS ((PTR, debug_type));
 
741
 
 
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.  */
 
748
 
 
749
extern const debug_type *debug_get_parameter_types PARAMS ((PTR,
 
750
                                                            debug_type,
 
751
                                                            boolean *));
 
752
 
 
753
/* Get the target type of a pointer or reference or const or volatile
 
754
   type.  */
 
755
 
 
756
extern debug_type debug_get_target_type PARAMS ((PTR, debug_type));
 
757
 
 
758
/* Get the NULL terminated array of fields for a struct, union, or
 
759
   class.  */
 
760
 
 
761
extern const debug_field *debug_get_fields PARAMS ((PTR, debug_type));
 
762
 
 
763
/* Get the type of a field.  */
 
764
 
 
765
extern debug_type debug_get_field_type PARAMS ((PTR, debug_field));
 
766
 
 
767
/* Get the name of a field.  */
 
768
 
 
769
extern const char *debug_get_field_name PARAMS ((PTR, debug_field));
 
770
 
 
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.  */
 
773
 
 
774
extern bfd_vma debug_get_field_bitpos PARAMS ((PTR, debug_field));
 
775
 
 
776
/* Get the bit size of a field.  If the field is a static member, this
 
777
   will return (bfd_vma) -1.  */
 
778
 
 
779
extern bfd_vma debug_get_field_bitsize PARAMS ((PTR, debug_field));
 
780
 
 
781
/* Get the visibility of a field.  */
 
782
 
 
783
extern enum debug_visibility debug_get_field_visibility
 
784
  PARAMS ((PTR, debug_field));
 
785
 
 
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.  */
 
788
 
 
789
extern const char *debug_get_field_physname PARAMS ((PTR, debug_field));
 
790
 
 
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.  */
 
795
 
 
796
extern boolean debug_write PARAMS ((PTR, const struct debug_write_fns *, PTR));
 
797
 
 
798
#endif /* DEBUG_H */