projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[deliverable/binutils-gdb.git] / binutils / debug.c
CommitLineData
252b5132 1/* debug.c -- Handle generic debugging information.
3db64b00 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2007
aef6203b 3 Free Software Foundation, Inc.
252b5132
RH		 4 Written by Ian Lance Taylor <ian@cygnus.com>.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
b43b5d5f
NC		 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
252b5132
RH		 22
23/* This file implements a generic debugging format. We may eventually
24 have readers which convert different formats into this generic
25 format, and writers which write it out. The initial impetus for
50c2245b 26 this was writing a converter from stabs to HP IEEE-695 debugging
252b5132
RH		 27 format. */
28
3db64b00 29#include "sysdep.h"
252b5132 30#include <assert.h>
252b5132 31#include "bfd.h"
252b5132
RH		 32#include "libiberty.h"
33#include "debug.h"
34
35/* Global information we keep for debugging. A pointer to this
36 structure is the debugging handle passed to all the routines. */
37
38struct debug_handle
39{
40 /* A linked list of compilation units. */
41 struct debug_unit *units;
42 /* The current compilation unit. */
43 struct debug_unit *current_unit;
44 /* The current source file. */
45 struct debug_file *current_file;
46 /* The current function. */
47 struct debug_function *current_function;
48 /* The current block. */
49 struct debug_block *current_block;
50 /* The current line number information for the current unit. */
51 struct debug_lineno *current_lineno;
52 /* Mark. This is used by debug_write. */
53 unsigned int mark;
54 /* A struct/class ID used by debug_write. */
55 unsigned int class_id;
56 /* The base for class_id for this call to debug_write. */
57 unsigned int base_id;
58 /* The current line number in debug_write. */
59 struct debug_lineno *current_write_lineno;
60 unsigned int current_write_lineno_index;
61 /* A list of classes which have assigned ID's during debug_write.
62 This is linked through the next_id field of debug_class_type. */
63 struct debug_class_id *id_list;
64 /* A list used to avoid recursion during debug_type_samep. */
65 struct debug_type_compare_list *compare_list;
66};
67
68/* Information we keep for a single compilation unit. */
69
70struct debug_unit
71{
72 /* The next compilation unit. */
73 struct debug_unit *next;
74 /* A list of files included in this compilation unit. The first
75 file is always the main one, and that is where the main file name
76 is stored. */
77 struct debug_file *files;
78 /* Line number information for this compilation unit. This is not
79 stored by function, because assembler code may have line number
80 information without function information. */
81 struct debug_lineno *linenos;
82};
83
84/* Information kept for a single source file. */
85
86struct debug_file
87{
88 /* The next source file in this compilation unit. */
89 struct debug_file *next;
90 /* The name of the source file. */
91 const char *filename;
92 /* Global functions, variables, types, etc. */
93 struct debug_namespace *globals;
94};
95
96/* A type. */
97
98struct debug_type
99{
100 /* Kind of type. */
101 enum debug_type_kind kind;
102 /* Size of type (0 if not known). */
103 unsigned int size;
104 /* Type which is a pointer to this type. */
105 debug_type pointer;
106 /* Tagged union with additional information about the type. */
107 union
108 {
109 /* DEBUG_KIND_INDIRECT. */
110 struct debug_indirect_type *kindirect;
111 /* DEBUG_KIND_INT. */
112 /* Whether the integer is unsigned. */
b34976b6 113 bfd_boolean kint;
252b5132
RH		 114 /* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS,
115 DEBUG_KIND_UNION_CLASS. */
116 struct debug_class_type *kclass;
117 /* DEBUG_KIND_ENUM. */
118 struct debug_enum_type *kenum;
119 /* DEBUG_KIND_POINTER. */
120 struct debug_type *kpointer;
121 /* DEBUG_KIND_FUNCTION. */
122 struct debug_function_type *kfunction;
123 /* DEBUG_KIND_REFERENCE. */
124 struct debug_type *kreference;
125 /* DEBUG_KIND_RANGE. */
126 struct debug_range_type *krange;
127 /* DEBUG_KIND_ARRAY. */
128 struct debug_array_type *karray;
129 /* DEBUG_KIND_SET. */
130 struct debug_set_type *kset;
131 /* DEBUG_KIND_OFFSET. */
132 struct debug_offset_type *koffset;
133 /* DEBUG_KIND_METHOD. */
134 struct debug_method_type *kmethod;
135 /* DEBUG_KIND_CONST. */
136 struct debug_type *kconst;
137 /* DEBUG_KIND_VOLATILE. */
138 struct debug_type *kvolatile;
139 /* DEBUG_KIND_NAMED, DEBUG_KIND_TAGGED. */
140 struct debug_named_type *knamed;
141 } u;
142};
143
144/* Information kept for an indirect type. */
145
146struct debug_indirect_type
147{
148 /* Slot where the final type will appear. */
149 debug_type *slot;
150 /* Tag. */
151 const char *tag;
152};
153
154/* Information kept for a struct, union, or class. */
155
156struct debug_class_type
157{
158 /* NULL terminated array of fields. */
159 debug_field *fields;
160 /* A mark field which indicates whether the struct has already been
161 printed. */
162 unsigned int mark;
163 /* This is used to uniquely identify unnamed structs when printing. */
164 unsigned int id;
165 /* The remaining fields are only used for DEBUG_KIND_CLASS and
166 DEBUG_KIND_UNION_CLASS. */
167 /* NULL terminated array of base classes. */
168 debug_baseclass *baseclasses;
169 /* NULL terminated array of methods. */
170 debug_method *methods;
171 /* The type of the class providing the virtual function table for
172 this class. This may point to the type itself. */
173 debug_type vptrbase;
174};
175
176/* Information kept for an enum. */
177
178struct debug_enum_type
179{
180 /* NULL terminated array of names. */
181 const char **names;
182 /* Array of corresponding values. */
183 bfd_signed_vma *values;
184};
185
186/* Information kept for a function. FIXME: We should be able to
187 record the parameter types. */
188
189struct debug_function_type
190{
191 /* Return type. */
192 debug_type return_type;
193 /* NULL terminated array of argument types. */
194 debug_type *arg_types;
195 /* Whether the function takes a variable number of arguments. */
b34976b6 196 bfd_boolean varargs;
252b5132
RH		 197};
198
199/* Information kept for a range. */
200
201struct debug_range_type
202{
203 /* Range base type. */
204 debug_type type;
205 /* Lower bound. */
206 bfd_signed_vma lower;
207 /* Upper bound. */
208 bfd_signed_vma upper;
209};
210
211/* Information kept for an array. */
212
213struct debug_array_type
214{
215 /* Element type. */
216 debug_type element_type;
217 /* Range type. */
218 debug_type range_type;
219 /* Lower bound. */
220 bfd_signed_vma lower;
221 /* Upper bound. */
222 bfd_signed_vma upper;
223 /* Whether this array is really a string. */
b34976b6 224 bfd_boolean stringp;
252b5132
RH		 225};
226
227/* Information kept for a set. */
228
229struct debug_set_type
230{
231 /* Base type. */
232 debug_type type;
233 /* Whether this set is really a bitstring. */
b34976b6 234 bfd_boolean bitstringp;
252b5132
RH		 235};
236
237/* Information kept for an offset type (a based pointer). */
238
239struct debug_offset_type
240{
241 /* The type the pointer is an offset from. */
242 debug_type base_type;
243 /* The type the pointer points to. */
244 debug_type target_type;
245};
246
247/* Information kept for a method type. */
248
249struct debug_method_type
250{
251 /* The return type. */
252 debug_type return_type;
253 /* The object type which this method is for. */
254 debug_type domain_type;
255 /* A NULL terminated array of argument types. */
256 debug_type *arg_types;
257 /* Whether the method takes a variable number of arguments. */
b34976b6 258 bfd_boolean varargs;
252b5132
RH		 259};
260
261/* Information kept for a named type. */
262
263struct debug_named_type
264{
265 /* Name. */
266 struct debug_name *name;
267 /* Real type. */
268 debug_type type;
269};
270
271/* A field in a struct or union. */
272
273struct debug_field
274{
275 /* Name of the field. */
276 const char *name;
277 /* Type of the field. */
278 struct debug_type *type;
279 /* Visibility of the field. */
280 enum debug_visibility visibility;
281 /* Whether this is a static member. */
b34976b6 282 bfd_boolean static_member;
252b5132
RH		 283 union
284 {
285 /* If static_member is false. */
286 struct
287 {
288 /* Bit position of the field in the struct. */
289 unsigned int bitpos;
290 /* Size of the field in bits. */
291 unsigned int bitsize;
292 } f;
293 /* If static_member is true. */
294 struct
295 {
296 const char *physname;
297 } s;
298 } u;
299};
300
301/* A base class for an object. */
302
303struct debug_baseclass
304{
305 /* Type of the base class. */
306 struct debug_type *type;
307 /* Bit position of the base class in the object. */
308 unsigned int bitpos;
309 /* Whether the base class is virtual. */
b34976b6 310 bfd_boolean virtual;
252b5132
RH		 311 /* Visibility of the base class. */
312 enum debug_visibility visibility;
313};
314
315/* A method of an object. */
316
317struct debug_method
318{
319 /* The name of the method. */
320 const char *name;
321 /* A NULL terminated array of different types of variants. */
322 struct debug_method_variant **variants;
323};
324
325/* The variants of a method function of an object. These indicate
326 which method to run. */
327
328struct debug_method_variant
329{
330 /* The physical name of the function. */
331 const char *physname;
332 /* The type of the function. */
333 struct debug_type *type;
334 /* The visibility of the function. */
335 enum debug_visibility visibility;
336 /* Whether the function is const. */
b34976b6 337 bfd_boolean constp;
252b5132 338 /* Whether the function is volatile. */
b34976b6 339 bfd_boolean volatilep;
252b5132
RH		 340 /* The offset to the function in the virtual function table. */
341 bfd_vma voffset;
342 /* If voffset is VOFFSET_STATIC_METHOD, this is a static method. */
343#define VOFFSET_STATIC_METHOD ((bfd_vma) -1)
344 /* Context of a virtual method function. */
345 struct debug_type *context;
346};
347
348/* A variable. This is the information we keep for a variable object.
349 This has no name; a name is associated with a variable in a
350 debug_name structure. */
351
352struct debug_variable
353{
354 /* Kind of variable. */
355 enum debug_var_kind kind;
356 /* Type. */
357 debug_type type;
358 /* Value. The interpretation of the value depends upon kind. */
359 bfd_vma val;
360};
361
362/* A function. This has no name; a name is associated with a function
363 in a debug_name structure. */
364
365struct debug_function
366{
367 /* Return type. */
368 debug_type return_type;
369 /* Parameter information. */
370 struct debug_parameter *parameters;
371 /* Block information. The first structure on the list is the main
372 block of the function, and describes function local variables. */
373 struct debug_block *blocks;
374};
375
376/* A function parameter. */
377
378struct debug_parameter
379{
380 /* Next parameter. */
381 struct debug_parameter *next;
382 /* Name. */
383 const char *name;
384 /* Type. */
385 debug_type type;
386 /* Kind. */
387 enum debug_parm_kind kind;
388 /* Value (meaning depends upon kind). */
389 bfd_vma val;
390};
391
392/* A typed constant. */
393
394struct debug_typed_constant
395{
396 /* Type. */
397 debug_type type;
398 /* Value. FIXME: We may eventually need to support non-integral
399 values. */
400 bfd_vma val;
401};
402
403/* Information about a block within a function. */
404
405struct debug_block
406{
407 /* Next block with the same parent. */
408 struct debug_block *next;
409 /* Parent block. */
410 struct debug_block *parent;
411 /* List of child blocks. */
412 struct debug_block *children;
413 /* Start address of the block. */
414 bfd_vma start;
415 /* End address of the block. */
416 bfd_vma end;
417 /* Local variables. */
418 struct debug_namespace *locals;
419};
420
421/* Line number information we keep for a compilation unit. FIXME:
422 This structure is easy to create, but can be very space
423 inefficient. */
424
425struct debug_lineno
426{
427 /* More line number information for this block. */
428 struct debug_lineno *next;
429 /* Source file. */
430 struct debug_file *file;
431 /* Line numbers, terminated by a -1 or the end of the array. */
432#define DEBUG_LINENO_COUNT 10
433 unsigned long linenos[DEBUG_LINENO_COUNT];
434 /* Addresses for the line numbers. */
435 bfd_vma addrs[DEBUG_LINENO_COUNT];
436};
437
438/* A namespace. This is a mapping from names to objects. FIXME: This
439 should be implemented as a hash table. */
440
441struct debug_namespace
442{
443 /* List of items in this namespace. */
444 struct debug_name *list;
445 /* Pointer to where the next item in this namespace should go. */
446 struct debug_name **tail;
447};
448
449/* Kinds of objects that appear in a namespace. */
450
451enum debug_object_kind
452{
453 /* A type. */
454 DEBUG_OBJECT_TYPE,
455 /* A tagged type (really a different sort of namespace). */
456 DEBUG_OBJECT_TAG,
457 /* A variable. */
458 DEBUG_OBJECT_VARIABLE,
459 /* A function. */
460 DEBUG_OBJECT_FUNCTION,
461 /* An integer constant. */
462 DEBUG_OBJECT_INT_CONSTANT,
463 /* A floating point constant. */
464 DEBUG_OBJECT_FLOAT_CONSTANT,
465 /* A typed constant. */
466 DEBUG_OBJECT_TYPED_CONSTANT
467};
468
469/* Linkage of an object that appears in a namespace. */
470
471enum debug_object_linkage
472{
473 /* Local variable. */
474 DEBUG_LINKAGE_AUTOMATIC,
475 /* Static--either file static or function static, depending upon the
476 namespace is. */
477 DEBUG_LINKAGE_STATIC,
478 /* Global. */
479 DEBUG_LINKAGE_GLOBAL,
480 /* No linkage. */
481 DEBUG_LINKAGE_NONE
482};
483
484/* A name in a namespace. */
485
486struct debug_name
487{
488 /* Next name in this namespace. */
489 struct debug_name *next;
490 /* Name. */
491 const char *name;
492 /* Mark. This is used by debug_write. */
493 unsigned int mark;
494 /* Kind of object. */
495 enum debug_object_kind kind;
496 /* Linkage of object. */
497 enum debug_object_linkage linkage;
498 /* Tagged union with additional information about the object. */
499 union
500 {
501 /* DEBUG_OBJECT_TYPE. */
502 struct debug_type *type;
503 /* DEBUG_OBJECT_TAG. */
504 struct debug_type *tag;
505 /* DEBUG_OBJECT_VARIABLE. */
506 struct debug_variable *variable;
507 /* DEBUG_OBJECT_FUNCTION. */
508 struct debug_function *function;
509 /* DEBUG_OBJECT_INT_CONSTANT. */
510 bfd_vma int_constant;
511 /* DEBUG_OBJECT_FLOAT_CONSTANT. */
512 double float_constant;
513 /* DEBUG_OBJECT_TYPED_CONSTANT. */
514 struct debug_typed_constant *typed_constant;
515 } u;
516};
517
518/* During debug_write, a linked list of these structures is used to
519 keep track of ID numbers that have been assigned to classes. */
520
521struct debug_class_id
522{
523 /* Next ID number. */
524 struct debug_class_id *next;
525 /* The type with the ID. */
526 struct debug_type *type;
527 /* The tag; NULL if no tag. */
528 const char *tag;
529};
530
531/* During debug_type_samep, a linked list of these structures is kept
532 on the stack to avoid infinite recursion. */
533
534struct debug_type_compare_list
535{
536 /* Next type on list. */
537 struct debug_type_compare_list *next;
538 /* The types we are comparing. */
539 struct debug_type *t1;
540 struct debug_type *t2;
541};
542
543/* During debug_get_real_type, a linked list of these structures is
544 kept on the stack to avoid infinite recursion. */
545
546struct debug_type_real_list
547{
548 /* Next type on list. */
549 struct debug_type_real_list *next;
550 /* The type we are checking. */
551 struct debug_type *t;
552};
553
554/* Local functions. */
555
2da42df6 556static void debug_error (const char *);
252b5132 557static struct debug_name *debug_add_to_namespace
2da42df6
AJ		 558 (struct debug_handle *, struct debug_namespace **, const char *,
559 enum debug_object_kind, enum debug_object_linkage);
252b5132 560static struct debug_name *debug_add_to_current_namespace
2da42df6
AJ		 561 (struct debug_handle *, const char *, enum debug_object_kind,
562 enum debug_object_linkage);
252b5132 563static struct debug_type *debug_make_type
2da42df6 564 (struct debug_handle *, enum debug_type_kind, unsigned int);
252b5132 565static struct debug_type *debug_get_real_type
2da42df6 566 (void *, debug_type, struct debug_type_real_list *);
b34976b6 567static bfd_boolean debug_write_name
2da42df6
AJ		 568 (struct debug_handle *, const struct debug_write_fns *, void *,
569 struct debug_name *);
b34976b6 570static bfd_boolean debug_write_type
2da42df6
AJ		 571 (struct debug_handle *, const struct debug_write_fns *, void *,
572 struct debug_type *, struct debug_name *);
b34976b6 573static bfd_boolean debug_write_class_type
2da42df6
AJ		 574 (struct debug_handle *, const struct debug_write_fns *, void *,
575 struct debug_type *, const char *);
b34976b6 576static bfd_boolean debug_write_function
2da42df6
AJ		 577 (struct debug_handle *, const struct debug_write_fns *, void *,
578 const char *, enum debug_object_linkage, struct debug_function *);
b34976b6 579static bfd_boolean debug_write_block
2da42df6
AJ		 580 (struct debug_handle *, const struct debug_write_fns *, void *,
581 struct debug_block *);
b34976b6 582static bfd_boolean debug_write_linenos
2da42df6 583 (struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma);
b34976b6 584static bfd_boolean debug_set_class_id
2da42df6 585 (struct debug_handle *, const char *, struct debug_type *);
b34976b6 586static bfd_boolean debug_type_samep
2da42df6 587 (struct debug_handle *, struct debug_type *, struct debug_type *);
b34976b6 588static bfd_boolean debug_class_type_samep
2da42df6 589 (struct debug_handle *, struct debug_type *, struct debug_type *);
252b5132
RH		 590\f
591/* Issue an error message. */
592
593static void
2da42df6 594debug_error (const char *message)
252b5132
RH		 595{
596 fprintf (stderr, "%s\n", message);
597}
598
599/* Add an object to a namespace. */
600
601static struct debug_name *
2da42df6
AJ		 602debug_add_to_namespace (struct debug_handle *info ATTRIBUTE_UNUSED,
603 struct debug_namespace **nsp, const char *name,
604 enum debug_object_kind kind,
605 enum debug_object_linkage linkage)
252b5132
RH		 606{
607 struct debug_name *n;
608 struct debug_namespace *ns;
609
610 n = (struct debug_name *) xmalloc (sizeof *n);
611 memset (n, 0, sizeof *n);
612
613 n->name = name;
614 n->kind = kind;
615 n->linkage = linkage;
616
617 ns = *nsp;
618 if (ns == NULL)
619 {
620 ns = (struct debug_namespace *) xmalloc (sizeof *ns);
621 memset (ns, 0, sizeof *ns);
622
623 ns->tail = &ns->list;
624
625 *nsp = ns;
626 }
627
628 *ns->tail = n;
629 ns->tail = &n->next;
630
631 return n;
632}
633
634/* Add an object to the current namespace. */
635
636static struct debug_name *
2da42df6
AJ		 637debug_add_to_current_namespace (struct debug_handle *info, const char *name,
638 enum debug_object_kind kind,
639 enum debug_object_linkage linkage)
252b5132
RH		 640{
641 struct debug_namespace **nsp;
642
643 if (info->current_unit == NULL
644 || info->current_file == NULL)
645 {
646 debug_error (_("debug_add_to_current_namespace: no current file"));
647 return NULL;
648 }
649
650 if (info->current_block != NULL)
651 nsp = &info->current_block->locals;
652 else
653 nsp = &info->current_file->globals;
654
655 return debug_add_to_namespace (info, nsp, name, kind, linkage);
656}
657\f
658/* Return a handle for debugging information. */
659
2da42df6
AJ		 660void *
661debug_init (void)
252b5132
RH		 662{
663 struct debug_handle *ret;
664
665 ret = (struct debug_handle *) xmalloc (sizeof *ret);
666 memset (ret, 0, sizeof *ret);
2da42df6 667 return (void *) ret;
252b5132
RH		 668}
669
670/* Set the source filename. This implicitly starts a new compilation
671 unit. */
672
b34976b6 673bfd_boolean
2da42df6 674debug_set_filename (void *handle, const char *name)
252b5132
RH		 675{
676 struct debug_handle *info = (struct debug_handle *) handle;
677 struct debug_file *nfile;
678 struct debug_unit *nunit;
679
680 if (name == NULL)
681 name = "";
682
683 nfile = (struct debug_file *) xmalloc (sizeof *nfile);
684 memset (nfile, 0, sizeof *nfile);
685
686 nfile->filename = name;
687
688 nunit = (struct debug_unit *) xmalloc (sizeof *nunit);
689 memset (nunit, 0, sizeof *nunit);
690
691 nunit->files = nfile;
692 info->current_file = nfile;
693
694 if (info->current_unit != NULL)
695 info->current_unit->next = nunit;
696 else
697 {
698 assert (info->units == NULL);
699 info->units = nunit;
700 }
701
702 info->current_unit = nunit;
703
704 info->current_function = NULL;
705 info->current_block = NULL;
706 info->current_lineno = NULL;
707
b34976b6 708 return TRUE;
252b5132
RH		 709}
710
711/* Change source files to the given file name. This is used for
712 include files in a single compilation unit. */
713
b34976b6 714bfd_boolean
2da42df6 715debug_start_source (void *handle, const char *name)
252b5132
RH		 716{
717 struct debug_handle *info = (struct debug_handle *) handle;
718 struct debug_file *f, **pf;
719
720 if (name == NULL)
721 name = "";
722
723 if (info->current_unit == NULL)
724 {
725 debug_error (_("debug_start_source: no debug_set_filename call"));
b34976b6 726 return FALSE;
252b5132
RH		 727 }
728
729 for (f = info->current_unit->files; f != NULL; f = f->next)
730 {
731 if (f->filename[0] == name[0]
732 && f->filename[1] == name[1]
733 && strcmp (f->filename, name) == 0)
734 {
735 info->current_file = f;
b34976b6 736 return TRUE;
252b5132
RH		 737 }
738 }
739
740 f = (struct debug_file *) xmalloc (sizeof *f);
741 memset (f, 0, sizeof *f);
742
743 f->filename = name;
744
745 for (pf = &info->current_file->next;
746 *pf != NULL;
747 pf = &(*pf)->next)
748 ;
749 *pf = f;
750
751 info->current_file = f;
752
b34976b6 753 return TRUE;
252b5132
RH		 754}
755
756/* Record a function definition. This implicitly starts a function
757 block. The debug_type argument is the type of the return value.
758 The boolean indicates whether the function is globally visible.
759 The bfd_vma is the address of the start of the function. Currently
760 the parameter types are specified by calls to
761 debug_record_parameter. FIXME: There is no way to specify nested
762 functions. */
763
b34976b6 764bfd_boolean
2da42df6
AJ		 765debug_record_function (void *handle, const char *name,
766 debug_type return_type, bfd_boolean global,
767 bfd_vma addr)
252b5132
RH		 768{
769 struct debug_handle *info = (struct debug_handle *) handle;
770 struct debug_function *f;
771 struct debug_block *b;
772 struct debug_name *n;
773
774 if (name == NULL)
775 name = "";
776 if (return_type == NULL)
b34976b6 777 return FALSE;
252b5132
RH		 778
779 if (info->current_unit == NULL)
780 {
781 debug_error (_("debug_record_function: no debug_set_filename call"));
b34976b6 782 return FALSE;
252b5132
RH		 783 }
784
785 f = (struct debug_function *) xmalloc (sizeof *f);
786 memset (f, 0, sizeof *f);
787
788 f->return_type = return_type;
789
790 b = (struct debug_block *) xmalloc (sizeof *b);
791 memset (b, 0, sizeof *b);
792
793 b->start = addr;
794 b->end = (bfd_vma) -1;
795
796 f->blocks = b;
797
798 info->current_function = f;
799 info->current_block = b;
800
801 /* FIXME: If we could handle nested functions, this would be the
802 place: we would want to use a different namespace. */
803 n = debug_add_to_namespace (info,
804 &info->current_file->globals,
805 name,
806 DEBUG_OBJECT_FUNCTION,
807 (global
808 ? DEBUG_LINKAGE_GLOBAL
809 : DEBUG_LINKAGE_STATIC));
810 if (n == NULL)
b34976b6 811 return FALSE;
252b5132
RH		 812
813 n->u.function = f;
814
b34976b6 815 return TRUE;
252b5132
RH		 816}
817
818/* Record a parameter for the current function. */
819
b34976b6 820bfd_boolean
2da42df6
AJ		 821debug_record_parameter (void *handle, const char *name, debug_type type,
822 enum debug_parm_kind kind, bfd_vma val)
252b5132
RH		 823{
824 struct debug_handle *info = (struct debug_handle *) handle;
825 struct debug_parameter *p, **pp;
826
827 if (name == NULL || type == NULL)
b34976b6 828 return FALSE;
252b5132
RH		 829
830 if (info->current_unit == NULL
831 || info->current_function == NULL)
832 {
833 debug_error (_("debug_record_parameter: no current function"));
b34976b6 834 return FALSE;
252b5132
RH		 835 }
836
837 p = (struct debug_parameter *) xmalloc (sizeof *p);
838 memset (p, 0, sizeof *p);
839
840 p->name = name;
841 p->type = type;
842 p->kind = kind;
843 p->val = val;
844
845 for (pp = &info->current_function->parameters;
846 *pp != NULL;
847 pp = &(*pp)->next)
848 ;
849 *pp = p;
850
b34976b6 851 return TRUE;
252b5132
RH		 852}
853
854/* End a function. FIXME: This should handle function nesting. */
855
b34976b6 856bfd_boolean
2da42df6 857debug_end_function (void *handle, bfd_vma addr)
252b5132
RH		 858{
859 struct debug_handle *info = (struct debug_handle *) handle;
860
861 if (info->current_unit == NULL
862 || info->current_block == NULL
863 || info->current_function == NULL)
864 {
865 debug_error (_("debug_end_function: no current function"));
b34976b6 866 return FALSE;
252b5132
RH		 867 }
868
869 if (info->current_block->parent != NULL)
870 {
871 debug_error (_("debug_end_function: some blocks were not closed"));
b34976b6 872 return FALSE;
252b5132
RH		 873 }
874
875 info->current_block->end = addr;
876
877 info->current_function = NULL;
878 info->current_block = NULL;
879
b34976b6 880 return TRUE;
252b5132
RH		 881}
882
883/* Start a block in a function. All local information will be
884 recorded in this block, until the matching call to debug_end_block.
885 debug_start_block and debug_end_block may be nested. The bfd_vma
886 argument is the address at which this block starts. */
887
b34976b6 888bfd_boolean
2da42df6 889debug_start_block (void *handle, bfd_vma addr)
252b5132
RH		 890{
891 struct debug_handle *info = (struct debug_handle *) handle;
892 struct debug_block *b, **pb;
893
894 /* We must always have a current block: debug_record_function sets
895 one up. */
896 if (info->current_unit == NULL
897 || info->current_block == NULL)
898 {
899 debug_error (_("debug_start_block: no current block"));
b34976b6 900 return FALSE;
252b5132
RH		 901 }
902
903 b = (struct debug_block *) xmalloc (sizeof *b);
904 memset (b, 0, sizeof *b);
905
906 b->parent = info->current_block;
907 b->start = addr;
908 b->end = (bfd_vma) -1;
909
910 /* This new block is a child of the current block. */
911 for (pb = &info->current_block->children;
912 *pb != NULL;
913 pb = &(*pb)->next)
914 ;
915 *pb = b;
916
917 info->current_block = b;
918
b34976b6 919 return TRUE;
252b5132
RH		 920}
921
922/* Finish a block in a function. This matches the call to
923 debug_start_block. The argument is the address at which this block
924 ends. */
925
b34976b6 926bfd_boolean
2da42df6 927debug_end_block (void *handle, bfd_vma addr)
252b5132
RH		 928{
929 struct debug_handle *info = (struct debug_handle *) handle;
930 struct debug_block *parent;
931
932 if (info->current_unit == NULL
933 || info->current_block == NULL)
934 {
935 debug_error (_("debug_end_block: no current block"));
b34976b6 936 return FALSE;
252b5132
RH		 937 }
938
939 parent = info->current_block->parent;
940 if (parent == NULL)
941 {
942 debug_error (_("debug_end_block: attempt to close top level block"));
b34976b6 943 return FALSE;
252b5132
RH		 944 }
945
946 info->current_block->end = addr;
947
948 info->current_block = parent;
949
b34976b6 950 return TRUE;
252b5132
RH		 951}
952
953/* Associate a line number in the current source file and function
954 with a given address. */
955
b34976b6 956bfd_boolean
2da42df6 957debug_record_line (void *handle, unsigned long lineno, bfd_vma addr)
252b5132
RH		 958{
959 struct debug_handle *info = (struct debug_handle *) handle;
960 struct debug_lineno *l;
961 unsigned int i;
962
963 if (info->current_unit == NULL)
964 {
965 debug_error (_("debug_record_line: no current unit"));
b34976b6 966 return FALSE;
252b5132
RH		 967 }
968
969 l = info->current_lineno;
970 if (l != NULL && l->file == info->current_file)
971 {
972 for (i = 0; i < DEBUG_LINENO_COUNT; i++)
973 {
974 if (l->linenos[i] == (unsigned long) -1)
975 {
976 l->linenos[i] = lineno;
977 l->addrs[i] = addr;
b34976b6 978 return TRUE;
252b5132
RH		 979 }
980 }
981 }
982
983 /* If we get here, then either 1) there is no current_lineno
984 structure, which means this is the first line number in this
985 compilation unit, 2) the current_lineno structure is for a
986 different file, or 3) the current_lineno structure is full.
987 Regardless, we want to allocate a new debug_lineno structure, put
988 it in the right place, and make it the new current_lineno
989 structure. */
990
991 l = (struct debug_lineno *) xmalloc (sizeof *l);
992 memset (l, 0, sizeof *l);
993
994 l->file = info->current_file;
995 l->linenos[0] = lineno;
996 l->addrs[0] = addr;
997 for (i = 1; i < DEBUG_LINENO_COUNT; i++)
998 l->linenos[i] = (unsigned long) -1;
999
1000 if (info->current_lineno != NULL)
1001 info->current_lineno->next = l;
1002 else
1003 info->current_unit->linenos = l;
1004
1005 info->current_lineno = l;
1006
b34976b6 1007 return TRUE;
252b5132
RH		 1008}
1009
1010/* Start a named common block. This is a block of variables that may
1011 move in memory. */
1012
b34976b6 1013bfd_boolean
2da42df6
AJ		 1014debug_start_common_block (void *handle ATTRIBUTE_UNUSED,
1015 const char *name ATTRIBUTE_UNUSED)
252b5132
RH		 1016{
1017 /* FIXME */
1018 debug_error (_("debug_start_common_block: not implemented"));
b34976b6 1019 return FALSE;
252b5132
RH		 1020}
1021
1022/* End a named common block. */
1023
b34976b6 1024bfd_boolean
2da42df6
AJ		 1025debug_end_common_block (void *handle ATTRIBUTE_UNUSED,
1026 const char *name ATTRIBUTE_UNUSED)
252b5132
RH		 1027{
1028 /* FIXME */
1029 debug_error (_("debug_end_common_block: not implemented"));
b34976b6 1030 return FALSE;
252b5132
RH		 1031}
1032
1033/* Record a named integer constant. */
1034
b34976b6 1035bfd_boolean
2da42df6 1036debug_record_int_const (void *handle, const char *name, bfd_vma val)
252b5132
RH		 1037{
1038 struct debug_handle *info = (struct debug_handle *) handle;
1039 struct debug_name *n;
1040
1041 if (name == NULL)
b34976b6 1042 return FALSE;
252b5132
RH		 1043
1044 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT,
1045 DEBUG_LINKAGE_NONE);
1046 if (n == NULL)
b34976b6 1047 return FALSE;
252b5132
RH		 1048
1049 n->u.int_constant = val;
1050
b34976b6 1051 return TRUE;
252b5132
RH		 1052}
1053
1054/* Record a named floating point constant. */
1055
b34976b6 1056bfd_boolean
2da42df6 1057debug_record_float_const (void *handle, const char *name, double val)
252b5132
RH		 1058{
1059 struct debug_handle *info = (struct debug_handle *) handle;
1060 struct debug_name *n;
1061
1062 if (name == NULL)
b34976b6 1063 return FALSE;
252b5132
RH		 1064
1065 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT,
1066 DEBUG_LINKAGE_NONE);
1067 if (n == NULL)
b34976b6 1068 return FALSE;
252b5132
RH		 1069
1070 n->u.float_constant = val;
1071
b34976b6 1072 return TRUE;
252b5132
RH		 1073}
1074
1075/* Record a typed constant with an integral value. */
1076
b34976b6 1077bfd_boolean
2da42df6
AJ		 1078debug_record_typed_const (void *handle, const char *name, debug_type type,
1079 bfd_vma val)
252b5132
RH		 1080{
1081 struct debug_handle *info = (struct debug_handle *) handle;
1082 struct debug_name *n;
1083 struct debug_typed_constant *tc;
1084
1085 if (name == NULL || type == NULL)
b34976b6 1086 return FALSE;
252b5132
RH		 1087
1088 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT,
1089 DEBUG_LINKAGE_NONE);
1090 if (n == NULL)
b34976b6 1091 return FALSE;
252b5132
RH		 1092
1093 tc = (struct debug_typed_constant *) xmalloc (sizeof *tc);
1094 memset (tc, 0, sizeof *tc);
1095
1096 tc->type = type;
1097 tc->val = val;
1098
1099 n->u.typed_constant = tc;
1100
b34976b6 1101 return TRUE;
252b5132
RH		 1102}
1103
1104/* Record a label. */
1105
b34976b6 1106bfd_boolean
2da42df6
AJ		 1107debug_record_label (void *handle ATTRIBUTE_UNUSED,
1108 const char *name ATTRIBUTE_UNUSED,
1109 debug_type type ATTRIBUTE_UNUSED,
1110 bfd_vma addr ATTRIBUTE_UNUSED)
252b5132
RH		 1111{
1112 /* FIXME. */
3a1a2036 1113 debug_error (_("debug_record_label: not implemented"));
b34976b6 1114 return FALSE;
252b5132
RH		 1115}
1116
1117/* Record a variable. */
1118
b34976b6 1119bfd_boolean
2da42df6
AJ		 1120debug_record_variable (void *handle, const char *name, debug_type type,
1121 enum debug_var_kind kind, bfd_vma val)
252b5132
RH		 1122{
1123 struct debug_handle *info = (struct debug_handle *) handle;
1124 struct debug_namespace **nsp;
1125 enum debug_object_linkage linkage;
1126 struct debug_name *n;
1127 struct debug_variable *v;
1128
1129 if (name == NULL || type == NULL)
b34976b6 1130 return FALSE;
252b5132
RH		 1131
1132 if (info->current_unit == NULL
1133 || info->current_file == NULL)
1134 {
1135 debug_error (_("debug_record_variable: no current file"));
b34976b6 1136 return FALSE;
252b5132
RH		 1137 }
1138
1139 if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
1140 {
1141 nsp = &info->current_file->globals;
1142 if (kind == DEBUG_GLOBAL)
1143 linkage = DEBUG_LINKAGE_GLOBAL;
1144 else
1145 linkage = DEBUG_LINKAGE_STATIC;
1146 }
1147 else
1148 {
1149 if (info->current_block == NULL)
fe2c4142
NC		 1150 nsp = &info->current_file->globals;
1151 else
1152 nsp = &info->current_block->locals;
252b5132
RH		 1153 linkage = DEBUG_LINKAGE_AUTOMATIC;
1154 }
1155
1156 n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
1157 if (n == NULL)
b34976b6 1158 return FALSE;
252b5132
RH		 1159
1160 v = (struct debug_variable *) xmalloc (sizeof *v);
1161 memset (v, 0, sizeof *v);
1162
1163 v->kind = kind;
1164 v->type = type;
1165 v->val = val;
1166
1167 n->u.variable = v;
1168
b34976b6 1169 return TRUE;
252b5132
RH		 1170}
1171
1172/* Make a type with a given kind and size. */
1173
252b5132 1174static struct debug_type *
2da42df6
AJ		 1175debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED,
1176 enum debug_type_kind kind, unsigned int size)
252b5132
RH		 1177{
1178 struct debug_type *t;
1179
1180 t = (struct debug_type *) xmalloc (sizeof *t);
1181 memset (t, 0, sizeof *t);
1182
1183 t->kind = kind;
1184 t->size = size;
1185
1186 return t;
1187}
1188
1189/* Make an indirect type which may be used as a placeholder for a type
1190 which is referenced before it is defined. */
1191
1192debug_type
2da42df6 1193debug_make_indirect_type (void *handle, debug_type *slot, const char *tag)
252b5132
RH		 1194{
1195 struct debug_handle *info = (struct debug_handle *) handle;
1196 struct debug_type *t;
1197 struct debug_indirect_type *i;
1198
1199 t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0);
1200 if (t == NULL)
1201 return DEBUG_TYPE_NULL;
1202
1203 i = (struct debug_indirect_type *) xmalloc (sizeof *i);
1204 memset (i, 0, sizeof *i);
1205
1206 i->slot = slot;
1207 i->tag = tag;
1208
1209 t->u.kindirect = i;
1210
1211 return t;
1212}
1213
1214/* Make a void type. There is only one of these. */
1215
1216debug_type
2da42df6 1217debug_make_void_type (void *handle)
252b5132
RH		 1218{
1219 struct debug_handle *info = (struct debug_handle *) handle;
1220
1221 return debug_make_type (info, DEBUG_KIND_VOID, 0);
1222}
1223
1224/* Make an integer type of a given size. The boolean argument is true
1225 if the integer is unsigned. */
1226
1227debug_type
2da42df6 1228debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp)
252b5132
RH		 1229{
1230 struct debug_handle *info = (struct debug_handle *) handle;
1231 struct debug_type *t;
1232
1233 t = debug_make_type (info, DEBUG_KIND_INT, size);
1234 if (t == NULL)
1235 return DEBUG_TYPE_NULL;
1236
1237 t->u.kint = unsignedp;
1238
1239 return t;
1240}
1241
1242/* Make a floating point type of a given size. FIXME: On some
1243 platforms, like an Alpha, you probably need to be able to specify
1244 the format. */
1245
1246debug_type
2da42df6 1247debug_make_float_type (void *handle, unsigned int size)
252b5132
RH		 1248{
1249 struct debug_handle *info = (struct debug_handle *) handle;
1250
1251 return debug_make_type (info, DEBUG_KIND_FLOAT, size);
1252}
1253
1254/* Make a boolean type of a given size. */
1255
1256debug_type
2da42df6 1257debug_make_bool_type (void *handle, unsigned int size)
252b5132
RH		 1258{
1259 struct debug_handle *info = (struct debug_handle *) handle;
1260
1261 return debug_make_type (info, DEBUG_KIND_BOOL, size);
1262}
1263
1264/* Make a complex type of a given size. */
1265
1266debug_type
2da42df6 1267debug_make_complex_type (void *handle, unsigned int size)
252b5132
RH		 1268{
1269 struct debug_handle *info = (struct debug_handle *) handle;
1270
1271 return debug_make_type (info, DEBUG_KIND_COMPLEX, size);
1272}
1273
1274/* Make a structure type. The second argument is true for a struct,
1275 false for a union. The third argument is the size of the struct.
1276 The fourth argument is a NULL terminated array of fields. */
1277
1278debug_type
2da42df6
AJ		 1279debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size,
1280 debug_field *fields)
252b5132
RH		 1281{
1282 struct debug_handle *info = (struct debug_handle *) handle;
1283 struct debug_type *t;
1284 struct debug_class_type *c;
1285
1286 t = debug_make_type (info,
1287 structp ? DEBUG_KIND_STRUCT : DEBUG_KIND_UNION,
1288 size);
1289 if (t == NULL)
1290 return DEBUG_TYPE_NULL;
1291
1292 c = (struct debug_class_type *) xmalloc (sizeof *c);
1293 memset (c, 0, sizeof *c);
1294
1295 c->fields = fields;
1296
1297 t->u.kclass = c;
1298
1299 return t;
1300}
1301
1302/* Make an object type. The first three arguments after the handle
1303 are the same as for debug_make_struct_type. The next arguments are
1304 a NULL terminated array of base classes, a NULL terminated array of
1305 methods, the type of the object holding the virtual function table
1306 if it is not this object, and a boolean which is true if this
1307 object has its own virtual function table. */
1308
1309debug_type
2da42df6
AJ		 1310debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size,
1311 debug_field *fields, debug_baseclass *baseclasses,
1312 debug_method *methods, debug_type vptrbase,
1313 bfd_boolean ownvptr)
252b5132
RH		 1314{
1315 struct debug_handle *info = (struct debug_handle *) handle;
1316 struct debug_type *t;
1317 struct debug_class_type *c;
1318
1319 t = debug_make_type (info,
1320 structp ? DEBUG_KIND_CLASS : DEBUG_KIND_UNION_CLASS,
1321 size);
1322 if (t == NULL)
1323 return DEBUG_TYPE_NULL;
1324
1325 c = (struct debug_class_type *) xmalloc (sizeof *c);
1326 memset (c, 0, sizeof *c);
1327
1328 c->fields = fields;
1329 c->baseclasses = baseclasses;
1330 c->methods = methods;
1331 if (ownvptr)
1332 c->vptrbase = t;
1333 else
1334 c->vptrbase = vptrbase;
1335
1336 t->u.kclass = c;
1337
1338 return t;
1339}
1340
1341/* Make an enumeration type. The arguments are a null terminated
1342 array of strings, and an array of corresponding values. */
1343
1344debug_type
2da42df6
AJ		 1345debug_make_enum_type (void *handle, const char **names,
1346 bfd_signed_vma *values)
252b5132
RH		 1347{
1348 struct debug_handle *info = (struct debug_handle *) handle;
1349 struct debug_type *t;
1350 struct debug_enum_type *e;
1351
1352 t = debug_make_type (info, DEBUG_KIND_ENUM, 0);
1353 if (t == NULL)
1354 return DEBUG_TYPE_NULL;
1355
1356 e = (struct debug_enum_type *) xmalloc (sizeof *e);
1357 memset (e, 0, sizeof *e);
1358
1359 e->names = names;
1360 e->values = values;
1361
1362 t->u.kenum = e;
1363
1364 return t;
1365}
1366
1367/* Make a pointer to a given type. */
1368
1369debug_type
2da42df6 1370debug_make_pointer_type (void *handle, debug_type type)
252b5132
RH		 1371{
1372 struct debug_handle *info = (struct debug_handle *) handle;
1373 struct debug_type *t;
1374
1375 if (type == NULL)
1376 return DEBUG_TYPE_NULL;
1377
1378 if (type->pointer != DEBUG_TYPE_NULL)
1379 return type->pointer;
1380
1381 t = debug_make_type (info, DEBUG_KIND_POINTER, 0);
1382 if (t == NULL)
1383 return DEBUG_TYPE_NULL;
1384
1385 t->u.kpointer = type;
1386
1387 type->pointer = t;
1388
1389 return t;
1390}
1391
1392/* Make a function returning a given type. FIXME: We should be able
1393 to record the parameter types. */
1394
1395debug_type
2da42df6
AJ		 1396debug_make_function_type (void *handle, debug_type type,
1397 debug_type *arg_types, bfd_boolean varargs)
252b5132
RH		 1398{
1399 struct debug_handle *info = (struct debug_handle *) handle;
1400 struct debug_type *t;
1401 struct debug_function_type *f;
1402
1403 if (type == NULL)
1404 return DEBUG_TYPE_NULL;
1405
1406 t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0);
1407 if (t == NULL)
1408 return DEBUG_TYPE_NULL;
1409
1410 f = (struct debug_function_type *) xmalloc (sizeof *f);
1411 memset (f, 0, sizeof *f);
1412
1413 f->return_type = type;
1414 f->arg_types = arg_types;
1415 f->varargs = varargs;
1416
1417 t->u.kfunction = f;
1418
1419 return t;
1420}
1421
1422/* Make a reference to a given type. */
1423
1424debug_type
2da42df6 1425debug_make_reference_type (void *handle, debug_type type)
252b5132
RH		 1426{
1427 struct debug_handle *info = (struct debug_handle *) handle;
1428 struct debug_type *t;
1429
1430 if (type == NULL)
1431 return DEBUG_TYPE_NULL;
1432
1433 t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0);
1434 if (t == NULL)
1435 return DEBUG_TYPE_NULL;
1436
1437 t->u.kreference = type;
1438
1439 return t;
1440}
1441
1442/* Make a range of a given type from a lower to an upper bound. */
1443
1444debug_type
2da42df6
AJ		 1445debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower,
1446 bfd_signed_vma upper)
252b5132
RH		 1447{
1448 struct debug_handle *info = (struct debug_handle *) handle;
1449 struct debug_type *t;
1450 struct debug_range_type *r;
1451
1452 if (type == NULL)
1453 return DEBUG_TYPE_NULL;
1454
1455 t = debug_make_type (info, DEBUG_KIND_RANGE, 0);
1456 if (t == NULL)
1457 return DEBUG_TYPE_NULL;
1458
1459 r = (struct debug_range_type *) xmalloc (sizeof *r);
1460 memset (r, 0, sizeof *r);
1461
1462 r->type = type;
1463 r->lower = lower;
1464 r->upper = upper;
1465
1466 t->u.krange = r;
1467
1468 return t;
1469}
1470
1471/* Make an array type. The second argument is the type of an element
1472 of the array. The third argument is the type of a range of the
1473 array. The fourth and fifth argument are the lower and upper
1474 bounds, respectively. The sixth argument is true if this array is
1475 actually a string, as in C. */
1476
1477debug_type
2da42df6
AJ		 1478debug_make_array_type (void *handle, debug_type element_type,
1479 debug_type range_type, bfd_signed_vma lower,
1480 bfd_signed_vma upper, bfd_boolean stringp)
252b5132
RH		 1481{
1482 struct debug_handle *info = (struct debug_handle *) handle;
1483 struct debug_type *t;
1484 struct debug_array_type *a;
1485
1486 if (element_type == NULL || range_type == NULL)
1487 return DEBUG_TYPE_NULL;
1488
1489 t = debug_make_type (info, DEBUG_KIND_ARRAY, 0);
1490 if (t == NULL)
1491 return DEBUG_TYPE_NULL;
1492
1493 a = (struct debug_array_type *) xmalloc (sizeof *a);
1494 memset (a, 0, sizeof *a);
1495
1496 a->element_type = element_type;
1497 a->range_type = range_type;
1498 a->lower = lower;
1499 a->upper = upper;
1500 a->stringp = stringp;
1501
1502 t->u.karray = a;
1503
1504 return t;
1505}
1506
1507/* Make a set of a given type. For example, a Pascal set type. The
1508 boolean argument is true if this set is actually a bitstring, as in
1509 CHILL. */
1510
1511debug_type
2da42df6 1512debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp)
252b5132
RH		 1513{
1514 struct debug_handle *info = (struct debug_handle *) handle;
1515 struct debug_type *t;
1516 struct debug_set_type *s;
1517
1518 if (type == NULL)
1519 return DEBUG_TYPE_NULL;
1520
1521 t = debug_make_type (info, DEBUG_KIND_SET, 0);
1522 if (t == NULL)
1523 return DEBUG_TYPE_NULL;
1524
1525 s = (struct debug_set_type *) xmalloc (sizeof *s);
1526 memset (s, 0, sizeof *s);
1527
1528 s->type = type;
1529 s->bitstringp = bitstringp;
1530
1531 t->u.kset = s;
1532
1533 return t;
1534}
1535
1536/* Make a type for a pointer which is relative to an object. The
1537 second argument is the type of the object to which the pointer is
1538 relative. The third argument is the type that the pointer points
1539 to. */
1540
1541debug_type
2da42df6
AJ		 1542debug_make_offset_type (void *handle, debug_type base_type,
1543 debug_type target_type)
252b5132
RH		 1544{
1545 struct debug_handle *info = (struct debug_handle *) handle;
1546 struct debug_type *t;
1547 struct debug_offset_type *o;
1548
1549 if (base_type == NULL || target_type == NULL)
1550 return DEBUG_TYPE_NULL;
1551
1552 t = debug_make_type (info, DEBUG_KIND_OFFSET, 0);
1553 if (t == NULL)
1554 return DEBUG_TYPE_NULL;
1555
1556 o = (struct debug_offset_type *) xmalloc (sizeof *o);
1557 memset (o, 0, sizeof *o);
1558
1559 o->base_type = base_type;
1560 o->target_type = target_type;
1561
1562 t->u.koffset = o;
1563
1564 return t;
1565}
1566
1567/* Make a type for a method function. The second argument is the
1568 return type, the third argument is the domain, and the fourth
1569 argument is a NULL terminated array of argument types. */
1570
1571debug_type
2da42df6
AJ		 1572debug_make_method_type (void *handle, debug_type return_type,
1573 debug_type domain_type, debug_type *arg_types,
1574 bfd_boolean varargs)
252b5132
RH		 1575{
1576 struct debug_handle *info = (struct debug_handle *) handle;
1577 struct debug_type *t;
1578 struct debug_method_type *m;
1579
1580 if (return_type == NULL)
1581 return DEBUG_TYPE_NULL;
1582
1583 t = debug_make_type (info, DEBUG_KIND_METHOD, 0);
1584 if (t == NULL)
1585 return DEBUG_TYPE_NULL;
1586
1587 m = (struct debug_method_type *) xmalloc (sizeof *m);
1588 memset (m, 0, sizeof *m);
1589
1590 m->return_type = return_type;
1591 m->domain_type = domain_type;
1592 m->arg_types = arg_types;
1593 m->varargs = varargs;
1594
1595 t->u.kmethod = m;
1596
1597 return t;
1598}
1599
1600/* Make a const qualified version of a given type. */
1601
1602debug_type
2da42df6 1603debug_make_const_type (void *handle, debug_type type)
252b5132
RH		 1604{
1605 struct debug_handle *info = (struct debug_handle *) handle;
1606 struct debug_type *t;
1607
1608 if (type == NULL)
1609 return DEBUG_TYPE_NULL;
1610
1611 t = debug_make_type (info, DEBUG_KIND_CONST, 0);
1612 if (t == NULL)
1613 return DEBUG_TYPE_NULL;
1614
1615 t->u.kconst = type;
1616
1617 return t;
1618}
1619
1620/* Make a volatile qualified version of a given type. */
1621
1622debug_type
2da42df6 1623debug_make_volatile_type (void *handle, debug_type type)
252b5132
RH		 1624{
1625 struct debug_handle *info = (struct debug_handle *) handle;
1626 struct debug_type *t;
1627
1628 if (type == NULL)
1629 return DEBUG_TYPE_NULL;
1630
1631 t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0);
1632 if (t == NULL)
1633 return DEBUG_TYPE_NULL;
1634
1635 t->u.kvolatile = type;
1636
1637 return t;
1638}
1639
1640/* Make an undefined tagged type. For example, a struct which has
1641 been mentioned, but not defined. */
1642
1643debug_type
2da42df6
AJ		 1644debug_make_undefined_tagged_type (void *handle, const char *name,
1645 enum debug_type_kind kind)
252b5132
RH		 1646{
1647 struct debug_handle *info = (struct debug_handle *) handle;
1648 struct debug_type *t;
1649
1650 if (name == NULL)
1651 return DEBUG_TYPE_NULL;
1652
1653 switch (kind)
1654 {
1655 case DEBUG_KIND_STRUCT:
1656 case DEBUG_KIND_UNION:
1657 case DEBUG_KIND_CLASS:
1658 case DEBUG_KIND_UNION_CLASS:
1659 case DEBUG_KIND_ENUM:
1660 break;
1661
1662 default:
1663 debug_error (_("debug_make_undefined_type: unsupported kind"));
1664 return DEBUG_TYPE_NULL;
1665 }
1666
1667 t = debug_make_type (info, kind, 0);
1668 if (t == NULL)
1669 return DEBUG_TYPE_NULL;
1670
1671 return debug_tag_type (handle, name, t);
1672}
1673
1674/* Make a base class for an object. The second argument is the base
1675 class type. The third argument is the bit position of this base
1676 class in the object (always 0 unless doing multiple inheritance).
1677 The fourth argument is whether this is a virtual class. The fifth
1678 argument is the visibility of the base class. */
1679
252b5132 1680debug_baseclass
2da42df6
AJ		 1681debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type,
1682 bfd_vma bitpos, bfd_boolean virtual,
1683 enum debug_visibility visibility)
26044998 1684{
252b5132
RH		 1685 struct debug_baseclass *b;
1686
1687 b = (struct debug_baseclass *) xmalloc (sizeof *b);
1688 memset (b, 0, sizeof *b);
1689
1690 b->type = type;
1691 b->bitpos = bitpos;
1692 b->virtual = virtual;
1693 b->visibility = visibility;
1694
1695 return b;
1696}
1697
1698/* Make a field for a struct. The second argument is the name. The
1699 third argument is the type of the field. The fourth argument is
1700 the bit position of the field. The fifth argument is the size of
1701 the field (it may be zero). The sixth argument is the visibility
1702 of the field. */
1703
252b5132 1704debug_field
2da42df6
AJ		 1705debug_make_field (void *handle ATTRIBUTE_UNUSED, const char *name,
1706 debug_type type, bfd_vma bitpos, bfd_vma bitsize,
1707 enum debug_visibility visibility)
252b5132
RH		 1708{
1709 struct debug_field *f;
1710
1711 f = (struct debug_field *) xmalloc (sizeof *f);
1712 memset (f, 0, sizeof *f);
1713
1714 f->name = name;
1715 f->type = type;
b34976b6 1716 f->static_member = FALSE;
252b5132
RH		 1717 f->u.f.bitpos = bitpos;
1718 f->u.f.bitsize = bitsize;
1719 f->visibility = visibility;
1720
1721 return f;
1722}
1723
1724/* Make a static member of an object. The second argument is the
1725 name. The third argument is the type of the member. The fourth
1726 argument is the physical name of the member (i.e., the name as a
1727 global variable). The fifth argument is the visibility of the
1728 member. */
1729
252b5132 1730debug_field
2da42df6
AJ		 1731debug_make_static_member (void *handle ATTRIBUTE_UNUSED, const char *name,
1732 debug_type type, const char *physname,
1733 enum debug_visibility visibility)
252b5132
RH		 1734{
1735 struct debug_field *f;
1736
1737 f = (struct debug_field *) xmalloc (sizeof *f);
1738 memset (f, 0, sizeof *f);
1739
1740 f->name = name;
1741 f->type = type;
b34976b6 1742 f->static_member = TRUE;
252b5132
RH		 1743 f->u.s.physname = physname;
1744 f->visibility = visibility;
1745
1746 return f;
1747}
1748
1749/* Make a method. The second argument is the name, and the third
1750 argument is a NULL terminated array of method variants. */
1751
252b5132 1752debug_method
2da42df6
AJ		 1753debug_make_method (void *handle ATTRIBUTE_UNUSED, const char *name,
1754 debug_method_variant *variants)
252b5132
RH		 1755{
1756 struct debug_method *m;
1757
1758 m = (struct debug_method *) xmalloc (sizeof *m);
1759 memset (m, 0, sizeof *m);
1760
1761 m->name = name;
1762 m->variants = variants;
1763
1764 return m;
1765}
1766
1767/* Make a method argument. The second argument is the real name of
1768 the function. The third argument is the type of the function. The
1769 fourth argument is the visibility. The fifth argument is whether
1770 this is a const function. The sixth argument is whether this is a
1771 volatile function. The seventh argument is the offset in the
1772 virtual function table, if any. The eighth argument is the virtual
1773 function context. FIXME: Are the const and volatile arguments
1774 necessary? Could we just use debug_make_const_type? */
1775
252b5132 1776debug_method_variant
2da42df6
AJ		 1777debug_make_method_variant (void *handle ATTRIBUTE_UNUSED,
1778 const char *physname, debug_type type,
1779 enum debug_visibility visibility,
1780 bfd_boolean constp, bfd_boolean volatilep,
1781 bfd_vma voffset, debug_type context)
252b5132
RH		 1782{
1783 struct debug_method_variant *m;
1784
1785 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1786 memset (m, 0, sizeof *m);
1787
1788 m->physname = physname;
1789 m->type = type;
1790 m->visibility = visibility;
1791 m->constp = constp;
1792 m->volatilep = volatilep;
1793 m->voffset = voffset;
1794 m->context = context;
1795
1796 return m;
1797}
1798
1799/* Make a static method argument. The arguments are the same as for
1800 debug_make_method_variant, except that the last two are omitted
1801 since a static method can not also be virtual. */
1802
1803debug_method_variant
2da42df6
AJ		 1804debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED,
1805 const char *physname, debug_type type,
1806 enum debug_visibility visibility,
1807 bfd_boolean constp, bfd_boolean volatilep)
252b5132
RH		 1808{
1809 struct debug_method_variant *m;
1810
1811 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1812 memset (m, 0, sizeof *m);
1813
1814 m->physname = physname;
1815 m->type = type;
1816 m->visibility = visibility;
1817 m->constp = constp;
1818 m->volatilep = volatilep;
1819 m->voffset = VOFFSET_STATIC_METHOD;
1820
1821 return m;
1822}
1823
1824/* Name a type. */
1825
1826debug_type
2da42df6 1827debug_name_type (void *handle, const char *name, debug_type type)
252b5132
RH		 1828{
1829 struct debug_handle *info = (struct debug_handle *) handle;
1830 struct debug_type *t;
1831 struct debug_named_type *n;
1832 struct debug_name *nm;
1833
1834 if (name == NULL || type == NULL)
1835 return DEBUG_TYPE_NULL;
1836
1837 if (info->current_unit == NULL
1838 || info->current_file == NULL)
1839 {
1840 debug_error (_("debug_name_type: no current file"));
1841 return DEBUG_TYPE_NULL;
1842 }
1843
1844 t = debug_make_type (info, DEBUG_KIND_NAMED, 0);
1845 if (t == NULL)
1846 return DEBUG_TYPE_NULL;
1847
1848 n = (struct debug_named_type *) xmalloc (sizeof *n);
1849 memset (n, 0, sizeof *n);
1850
1851 n->type = type;
1852
1853 t->u.knamed = n;
1854
1855 /* We always add the name to the global namespace. This is probably
1856 wrong in some cases, but it seems to be right for stabs. FIXME. */
1857
1858 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1859 DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE);
1860 if (nm == NULL)
3dceb55b 1861 return DEBUG_TYPE_NULL;
252b5132
RH		 1862
1863 nm->u.type = t;
1864
1865 n->name = nm;
1866
1867 return t;
1868}
1869
1870/* Tag a type. */
1871
1872debug_type
2da42df6 1873debug_tag_type (void *handle, const char *name, debug_type type)
252b5132
RH		 1874{
1875 struct debug_handle *info = (struct debug_handle *) handle;
1876 struct debug_type *t;
1877 struct debug_named_type *n;
1878 struct debug_name *nm;
1879
1880 if (name == NULL || type == NULL)
1881 return DEBUG_TYPE_NULL;
1882
1883 if (info->current_file == NULL)
1884 {
1885 debug_error (_("debug_tag_type: no current file"));
1886 return DEBUG_TYPE_NULL;
1887 }
1888
1889 if (type->kind == DEBUG_KIND_TAGGED)
1890 {
1891 if (strcmp (type->u.knamed->name->name, name) == 0)
1892 return type;
1893 debug_error (_("debug_tag_type: extra tag attempted"));
1894 return DEBUG_TYPE_NULL;
1895 }
1896
1897 t = debug_make_type (info, DEBUG_KIND_TAGGED, 0);
1898 if (t == NULL)
1899 return DEBUG_TYPE_NULL;
1900
1901 n = (struct debug_named_type *) xmalloc (sizeof *n);
1902 memset (n, 0, sizeof *n);
1903
1904 n->type = type;
1905
1906 t->u.knamed = n;
1907
1908 /* We keep a global namespace of tags for each compilation unit. I
1909 don't know if that is the right thing to do. */
1910
1911 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1912 DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE);
1913 if (nm == NULL)
3dceb55b 1914 return DEBUG_TYPE_NULL;
252b5132
RH		 1915
1916 nm->u.tag = t;
1917
1918 n->name = nm;
1919
1920 return t;
1921}
1922
1923/* Record the size of a given type. */
1924
b34976b6 1925bfd_boolean
2da42df6
AJ		 1926debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type,
1927 unsigned int size)
252b5132
RH		 1928{
1929 if (type->size != 0 && type->size != size)
1930 fprintf (stderr, _("Warning: changing type size from %d to %d\n"),
1931 type->size, size);
1932
1933 type->size = size;
1934
b34976b6 1935 return TRUE;
252b5132
RH		 1936}
1937
1938/* Find a named type. */
1939
1940debug_type
2da42df6 1941debug_find_named_type (void *handle, const char *name)
252b5132
RH		 1942{
1943 struct debug_handle *info = (struct debug_handle *) handle;
1944 struct debug_block *b;
1945 struct debug_file *f;
1946
1947 /* We only search the current compilation unit. I don't know if
1948 this is right or not. */
1949
1950 if (info->current_unit == NULL)
1951 {
1952 debug_error (_("debug_find_named_type: no current compilation unit"));
1953 return DEBUG_TYPE_NULL;
1954 }
1955
1956 for (b = info->current_block; b != NULL; b = b->parent)
1957 {
1958 if (b->locals != NULL)
1959 {
1960 struct debug_name *n;
1961
1962 for (n = b->locals->list; n != NULL; n = n->next)
1963 {
1964 if (n->kind == DEBUG_OBJECT_TYPE
1965 && n->name[0] == name[0]
1966 && strcmp (n->name, name) == 0)
1967 return n->u.type;
1968 }
1969 }
1970 }
1971
1972 for (f = info->current_unit->files; f != NULL; f = f->next)
1973 {
1974 if (f->globals != NULL)
1975 {
1976 struct debug_name *n;
1977
1978 for (n = f->globals->list; n != NULL; n = n->next)
1979 {
1980 if (n->kind == DEBUG_OBJECT_TYPE
1981 && n->name[0] == name[0]
1982 && strcmp (n->name, name) == 0)
1983 return n->u.type;
1984 }
1985 }
1986 }
1987
26044998 1988 return DEBUG_TYPE_NULL;
252b5132
RH		 1989}
1990
1991/* Find a tagged type. */
1992
1993debug_type
2da42df6
AJ		 1994debug_find_tagged_type (void *handle, const char *name,
1995 enum debug_type_kind kind)
252b5132
RH		 1996{
1997 struct debug_handle *info = (struct debug_handle *) handle;
1998 struct debug_unit *u;
1999
2000 /* We search the globals of all the compilation units. I don't know
2001 if this is correct or not. It would be easy to change. */
2002
2003 for (u = info->units; u != NULL; u = u->next)
2004 {
2005 struct debug_file *f;
2006
2007 for (f = u->files; f != NULL; f = f->next)
2008 {
2009 struct debug_name *n;
2010
2011 if (f->globals != NULL)
2012 {
2013 for (n = f->globals->list; n != NULL; n = n->next)
2014 {
2015 if (n->kind == DEBUG_OBJECT_TAG
2016 && (kind == DEBUG_KIND_ILLEGAL
2017 || n->u.tag->kind == kind)
2018 && n->name[0] == name[0]
2019 && strcmp (n->name, name) == 0)
2020 return n->u.tag;
2021 }
2022 }
2023 }
2024 }
2025
2026 return DEBUG_TYPE_NULL;
2027}
2028
2029/* Get a base type. We build a linked list on the stack to avoid
2030 crashing if the type is defined circularly. */
2031
2032static struct debug_type *
2da42df6
AJ		 2033debug_get_real_type (void *handle, debug_type type,
2034 struct debug_type_real_list *list)
252b5132
RH		 2035{
2036 struct debug_type_real_list *l;
2037 struct debug_type_real_list rl;
2038
2039 switch (type->kind)
2040 {
2041 default:
2042 return type;
2043
2044 case DEBUG_KIND_INDIRECT:
2045 case DEBUG_KIND_NAMED:
2046 case DEBUG_KIND_TAGGED:
2047 break;
2048 }
2049
2050 for (l = list; l != NULL; l = l->next)
2051 {
7ab5f2ed 2052 if (l->t == type || l == l->next)
252b5132
RH		 2053 {
2054 fprintf (stderr,
2055 _("debug_get_real_type: circular debug information for %s\n"),
2056 debug_get_type_name (handle, type));
2057 return NULL;
2058 }
2059 }
2060
2061 rl.next = list;
2062 rl.t = type;
2063
2064 switch (type->kind)
2065 {
2066 /* The default case is just here to avoid warnings. */
2067 default:
2068 case DEBUG_KIND_INDIRECT:
2069 if (*type->u.kindirect->slot != NULL)
2070 return debug_get_real_type (handle, *type->u.kindirect->slot, &rl);
2071 return type;
2072 case DEBUG_KIND_NAMED:
2073 case DEBUG_KIND_TAGGED:
2074 return debug_get_real_type (handle, type->u.knamed->type, &rl);
2075 }
2076 /*NOTREACHED*/
2077}
2078
2079/* Get the kind of a type. */
2080
2081enum debug_type_kind
2da42df6 2082debug_get_type_kind (void *handle, debug_type type)
252b5132
RH		 2083{
2084 if (type == NULL)
2085 return DEBUG_KIND_ILLEGAL;
2086 type = debug_get_real_type (handle, type, NULL);
2087 if (type == NULL)
2088 return DEBUG_KIND_ILLEGAL;
2089 return type->kind;
2090}
2091
2092/* Get the name of a type. */
2093
2094const char *
2da42df6 2095debug_get_type_name (void *handle, debug_type type)
252b5132
RH		 2096{
2097 if (type->kind == DEBUG_KIND_INDIRECT)
2098 {
2099 if (*type->u.kindirect->slot != NULL)
2100 return debug_get_type_name (handle, *type->u.kindirect->slot);
2101 return type->u.kindirect->tag;
2102 }
2103 if (type->kind == DEBUG_KIND_NAMED
2104 || type->kind == DEBUG_KIND_TAGGED)
2105 return type->u.knamed->name->name;
2106 return NULL;
2107}
2108
2109/* Get the size of a type. */
2110
2111bfd_vma
2da42df6 2112debug_get_type_size (void *handle, debug_type type)
252b5132
RH		 2113{
2114 if (type == NULL)
2115 return 0;
2116
2117 /* We don't call debug_get_real_type, because somebody might have
2118 called debug_record_type_size on a named or indirect type. */
2119
2120 if (type->size != 0)
2121 return type->size;
2122
2123 switch (type->kind)
2124 {
2125 default:
2126 return 0;
2127 case DEBUG_KIND_INDIRECT:
2128 if (*type->u.kindirect->slot != NULL)
2129 return debug_get_type_size (handle, *type->u.kindirect->slot);
2130 return 0;
2131 case DEBUG_KIND_NAMED:
2132 case DEBUG_KIND_TAGGED:
2133 return debug_get_type_size (handle, type->u.knamed->type);
2134 }
2135 /*NOTREACHED*/
2136}
2137
2138/* Get the return type of a function or method type. */
2139
2140debug_type
2da42df6 2141debug_get_return_type (void *handle, debug_type type)
252b5132
RH		 2142{
2143 if (type == NULL)
2144 return DEBUG_TYPE_NULL;
fe2c4142 2145
252b5132
RH		 2146 type = debug_get_real_type (handle, type, NULL);
2147 if (type == NULL)
2148 return DEBUG_TYPE_NULL;
fe2c4142 2149
252b5132
RH		 2150 switch (type->kind)
2151 {
2152 default:
2153 return DEBUG_TYPE_NULL;
2154 case DEBUG_KIND_FUNCTION:
2155 return type->u.kfunction->return_type;
2156 case DEBUG_KIND_METHOD:
2157 return type->u.kmethod->return_type;
2158 }
26044998 2159 /*NOTREACHED*/
252b5132
RH		 2160}
2161
2162/* Get the parameter types of a function or method type (except that
2163 we don't currently store the parameter types of a function). */
2164
2165const debug_type *
2da42df6
AJ		 2166debug_get_parameter_types (void *handle, debug_type type,
2167 bfd_boolean *pvarargs)
252b5132
RH		 2168{
2169 if (type == NULL)
2170 return NULL;
fe2c4142 2171
252b5132
RH		 2172 type = debug_get_real_type (handle, type, NULL);
2173 if (type == NULL)
2174 return NULL;
fe2c4142 2175
252b5132
RH		 2176 switch (type->kind)
2177 {
2178 default:
2179 return NULL;
2180 case DEBUG_KIND_FUNCTION:
2181 *pvarargs = type->u.kfunction->varargs;
2182 return type->u.kfunction->arg_types;
2183 case DEBUG_KIND_METHOD:
2184 *pvarargs = type->u.kmethod->varargs;
2185 return type->u.kmethod->arg_types;
2186 }
2187 /*NOTREACHED*/
2188}
2189
2190/* Get the target type of a type. */
2191
2192debug_type
2da42df6 2193debug_get_target_type (void *handle, debug_type type)
252b5132
RH		 2194{
2195 if (type == NULL)
2196 return NULL;
fe2c4142 2197
252b5132
RH		 2198 type = debug_get_real_type (handle, type, NULL);
2199 if (type == NULL)
2200 return NULL;
fe2c4142 2201
252b5132
RH		 2202 switch (type->kind)
2203 {
2204 default:
2205 return NULL;
2206 case DEBUG_KIND_POINTER:
2207 return type->u.kpointer;
2208 case DEBUG_KIND_REFERENCE:
2209 return type->u.kreference;
2210 case DEBUG_KIND_CONST:
2211 return type->u.kconst;
2212 case DEBUG_KIND_VOLATILE:
2213 return type->u.kvolatile;
2214 }
2215 /*NOTREACHED*/
2216}
2217
2218/* Get the NULL terminated array of fields for a struct, union, or
2219 class. */
2220
2221const debug_field *
2da42df6 2222debug_get_fields (void *handle, debug_type type)
252b5132
RH		 2223{
2224 if (type == NULL)
2225 return NULL;
fe2c4142 2226
252b5132
RH		 2227 type = debug_get_real_type (handle, type, NULL);
2228 if (type == NULL)
2229 return NULL;
fe2c4142 2230
252b5132
RH		 2231 switch (type->kind)
2232 {
2233 default:
2234 return NULL;
2235 case DEBUG_KIND_STRUCT:
2236 case DEBUG_KIND_UNION:
2237 case DEBUG_KIND_CLASS:
2238 case DEBUG_KIND_UNION_CLASS:
2239 return type->u.kclass->fields;
2240 }
2241 /*NOTREACHED*/
2242}
2243
2244/* Get the type of a field. */
2245
252b5132 2246debug_type
2da42df6 2247debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2248{
2249 if (field == NULL)
2250 return NULL;
2251 return field->type;
2252}
2253
2254/* Get the name of a field. */
2255
252b5132 2256const char *
2da42df6 2257debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2258{
2259 if (field == NULL)
2260 return NULL;
2261 return field->name;
2262}
2263
2264/* Get the bit position of a field. */
2265
252b5132 2266bfd_vma
2da42df6 2267debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2268{
2269 if (field == NULL || field->static_member)
2270 return (bfd_vma) -1;
2271 return field->u.f.bitpos;
2272}
2273
2274/* Get the bit size of a field. */
2275
252b5132 2276bfd_vma
2da42df6 2277debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2278{
2279 if (field == NULL || field->static_member)
2280 return (bfd_vma) -1;
2281 return field->u.f.bitsize;
2282}
2283
2284/* Get the visibility of a field. */
2285
252b5132 2286enum debug_visibility
2da42df6 2287debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2288{
2289 if (field == NULL)
2290 return DEBUG_VISIBILITY_IGNORE;
2291 return field->visibility;
2292}
2293
2294/* Get the physical name of a field. */
2295
2296const char *
2da42df6 2297debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field)
252b5132
RH		 2298{
2299 if (field == NULL || ! field->static_member)
2300 return NULL;
2301 return field->u.s.physname;
2302}
2303\f
2304/* Write out the debugging information. This is given a handle to
2305 debugging information, and a set of function pointers to call. */
2306
b34976b6 2307bfd_boolean
2da42df6 2308debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle)
252b5132
RH		 2309{
2310 struct debug_handle *info = (struct debug_handle *) handle;
2311 struct debug_unit *u;
2312
2313 /* We use a mark to tell whether we have already written out a
2314 particular name. We use an integer, so that we don't have to
2315 clear the mark fields if we happen to write out the same
2316 information more than once. */
2317 ++info->mark;
2318
2319 /* The base_id field holds an ID value which will never be used, so
2320 that we can tell whether we have assigned an ID during this call
2321 to debug_write. */
2322 info->base_id = info->class_id;
2323
2324 /* We keep a linked list of classes for which was have assigned ID's
2325 during this call to debug_write. */
2326 info->id_list = NULL;
2327
2328 for (u = info->units; u != NULL; u = u->next)
2329 {
2330 struct debug_file *f;
b34976b6 2331 bfd_boolean first_file;
252b5132
RH		 2332
2333 info->current_write_lineno = u->linenos;
2334 info->current_write_lineno_index = 0;
2335
2336 if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
b34976b6 2337 return FALSE;
252b5132 2338
b34976b6 2339 first_file = TRUE;
252b5132
RH		 2340 for (f = u->files; f != NULL; f = f->next)
2341 {
2342 struct debug_name *n;
2343
2344 if (first_file)
b34976b6 2345 first_file = FALSE;
fe2c4142
NC		 2346 else if (! (*fns->start_source) (fhandle, f->filename))
2347 return FALSE;
252b5132
RH		 2348
2349 if (f->globals != NULL)
fe2c4142
NC		 2350 for (n = f->globals->list; n != NULL; n = n->next)
2351 if (! debug_write_name (info, fns, fhandle, n))
2352 return FALSE;
252b5132
RH		 2353 }
2354
2355 /* Output any line number information which hasn't already been
2356 handled. */
2357 if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
b34976b6 2358 return FALSE;
252b5132
RH		 2359 }
2360
b34976b6 2361 return TRUE;
252b5132
RH		 2362}
2363
2364/* Write out an element in a namespace. */
2365
b34976b6 2366static bfd_boolean
2da42df6
AJ		 2367debug_write_name (struct debug_handle *info,
2368 const struct debug_write_fns *fns, void *fhandle,
2369 struct debug_name *n)
252b5132
RH		 2370{
2371 switch (n->kind)
2372 {
2373 case DEBUG_OBJECT_TYPE:
2374 if (! debug_write_type (info, fns, fhandle, n->u.type, n)
2375 || ! (*fns->typdef) (fhandle, n->name))
b34976b6
AM		 2376 return FALSE;
2377 return TRUE;
252b5132
RH		 2378 case DEBUG_OBJECT_TAG:
2379 if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
b34976b6 2380 return FALSE;
252b5132
RH		 2381 return (*fns->tag) (fhandle, n->name);
2382 case DEBUG_OBJECT_VARIABLE:
2383 if (! debug_write_type (info, fns, fhandle, n->u.variable->type,
2384 (struct debug_name *) NULL))
b34976b6 2385 return FALSE;
252b5132
RH		 2386 return (*fns->variable) (fhandle, n->name, n->u.variable->kind,
2387 n->u.variable->val);
2388 case DEBUG_OBJECT_FUNCTION:
2389 return debug_write_function (info, fns, fhandle, n->name,
2390 n->linkage, n->u.function);
2391 case DEBUG_OBJECT_INT_CONSTANT:
2392 return (*fns->int_constant) (fhandle, n->name, n->u.int_constant);
2393 case DEBUG_OBJECT_FLOAT_CONSTANT:
2394 return (*fns->float_constant) (fhandle, n->name, n->u.float_constant);
2395 case DEBUG_OBJECT_TYPED_CONSTANT:
2396 if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type,
2397 (struct debug_name *) NULL))
b34976b6 2398 return FALSE;
252b5132
RH		 2399 return (*fns->typed_constant) (fhandle, n->name,
2400 n->u.typed_constant->val);
2401 default:
2402 abort ();
b34976b6 2403 return FALSE;
252b5132
RH		 2404 }
2405 /*NOTREACHED*/
2406}
2407
2408/* Write out a type. If the type is DEBUG_KIND_NAMED or
2409 DEBUG_KIND_TAGGED, then the name argument is the name for which we
2410 are about to call typedef or tag. If the type is anything else,
2411 then the name argument is a tag from a DEBUG_KIND_TAGGED type which
2412 points to this one. */
2413
b34976b6 2414static bfd_boolean
2da42df6
AJ		 2415debug_write_type (struct debug_handle *info,
2416 const struct debug_write_fns *fns, void *fhandle,
2417 struct debug_type *type, struct debug_name *name)
252b5132
RH		 2418{
2419 unsigned int i;
2420 int is;
b4c96d0d 2421 const char *tag = NULL;
252b5132
RH		 2422
2423 /* If we have a name for this type, just output it. We only output
2424 typedef names after they have been defined. We output type tags
2425 whenever we are not actually defining them. */
2426 if ((type->kind == DEBUG_KIND_NAMED
2427 || type->kind == DEBUG_KIND_TAGGED)
2428 && (type->u.knamed->name->mark == info->mark
2429 || (type->kind == DEBUG_KIND_TAGGED
2430 && type->u.knamed->name != name)))
2431 {
2432 if (type->kind == DEBUG_KIND_NAMED)
2433 return (*fns->typedef_type) (fhandle, type->u.knamed->name->name);
2434 else
2435 {
2436 struct debug_type *real;
2437 unsigned int id;
2438
2da42df6 2439 real = debug_get_real_type ((void *) info, type, NULL);
252b5132
RH		 2440 if (real == NULL)
2441 return (*fns->empty_type) (fhandle);
2442 id = 0;
2443 if ((real->kind == DEBUG_KIND_STRUCT
2444 || real->kind == DEBUG_KIND_UNION
2445 || real->kind == DEBUG_KIND_CLASS
2446 || real->kind == DEBUG_KIND_UNION_CLASS)
2447 && real->u.kclass != NULL)
2448 {
2449 if (real->u.kclass->id <= info->base_id)
2450 {
2451 if (! debug_set_class_id (info,
2452 type->u.knamed->name->name,
2453 real))
b34976b6 2454 return FALSE;
252b5132
RH		 2455 }
2456 id = real->u.kclass->id;
2457 }
2458
2459 return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id,
2460 real->kind);
2461 }
2462 }
2463
2464 /* Mark the name after we have already looked for a known name, so
2465 that we don't just define a type in terms of itself. We need to
2466 mark the name here so that a struct containing a pointer to
2467 itself will work. */
2468 if (name != NULL)
2469 name->mark = info->mark;
2470
252b5132
RH		 2471 if (name != NULL
2472 && type->kind != DEBUG_KIND_NAMED
2473 && type->kind != DEBUG_KIND_TAGGED)
2474 {
2475 assert (name->kind == DEBUG_OBJECT_TAG);
2476 tag = name->name;
2477 }
2478
2479 switch (type->kind)
2480 {
2481 case DEBUG_KIND_ILLEGAL:
2482 debug_error (_("debug_write_type: illegal type encountered"));
b34976b6 2483 return FALSE;
252b5132
RH		 2484 case DEBUG_KIND_INDIRECT:
2485 if (*type->u.kindirect->slot == DEBUG_TYPE_NULL)
2486 return (*fns->empty_type) (fhandle);
2487 return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot,
2488 name);
2489 case DEBUG_KIND_VOID:
2490 return (*fns->void_type) (fhandle);
2491 case DEBUG_KIND_INT:
2492 return (*fns->int_type) (fhandle, type->size, type->u.kint);
2493 case DEBUG_KIND_FLOAT:
2494 return (*fns->float_type) (fhandle, type->size);
2495 case DEBUG_KIND_COMPLEX:
2496 return (*fns->complex_type) (fhandle, type->size);
2497 case DEBUG_KIND_BOOL:
2498 return (*fns->bool_type) (fhandle, type->size);
2499 case DEBUG_KIND_STRUCT:
2500 case DEBUG_KIND_UNION:
2501 if (type->u.kclass != NULL)
2502 {
2503 if (type->u.kclass->id <= info->base_id)
2504 {
2505 if (! debug_set_class_id (info, tag, type))
b34976b6 2506 return FALSE;
252b5132
RH		 2507 }
2508
2509 if (info->mark == type->u.kclass->mark)
2510 {
2511 /* We are currently outputting this struct, or we have
2512 already output it. I don't know if this can happen,
2513 but it can happen for a class. */
2514 assert (type->u.kclass->id > info->base_id);
2515 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2516 type->kind);
2517 }
2518 type->u.kclass->mark = info->mark;
2519 }
2520
2521 if (! (*fns->start_struct_type) (fhandle, tag,
2522 (type->u.kclass != NULL
2523 ? type->u.kclass->id
2524 : 0),
2525 type->kind == DEBUG_KIND_STRUCT,
2526 type->size))
b34976b6 2527 return FALSE;
252b5132
RH		 2528 if (type->u.kclass != NULL
2529 && type->u.kclass->fields != NULL)
2530 {
2531 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2532 {
2533 struct debug_field *f;
2534
2535 f = type->u.kclass->fields[i];
2536 if (! debug_write_type (info, fns, fhandle, f->type,
2537 (struct debug_name *) NULL)
2538 || ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2539 f->u.f.bitsize, f->visibility))
b34976b6 2540 return FALSE;
252b5132
RH		 2541 }
2542 }
2543 return (*fns->end_struct_type) (fhandle);
2544 case DEBUG_KIND_CLASS:
2545 case DEBUG_KIND_UNION_CLASS:
2546 return debug_write_class_type (info, fns, fhandle, type, tag);
2547 case DEBUG_KIND_ENUM:
2548 if (type->u.kenum == NULL)
2549 return (*fns->enum_type) (fhandle, tag, (const char **) NULL,
2550 (bfd_signed_vma *) NULL);
2551 return (*fns->enum_type) (fhandle, tag, type->u.kenum->names,
2552 type->u.kenum->values);
2553 case DEBUG_KIND_POINTER:
2554 if (! debug_write_type (info, fns, fhandle, type->u.kpointer,
2555 (struct debug_name *) NULL))
b34976b6 2556 return FALSE;
252b5132
RH		 2557 return (*fns->pointer_type) (fhandle);
2558 case DEBUG_KIND_FUNCTION:
2559 if (! debug_write_type (info, fns, fhandle,
2560 type->u.kfunction->return_type,
2561 (struct debug_name *) NULL))
b34976b6 2562 return FALSE;
252b5132
RH		 2563 if (type->u.kfunction->arg_types == NULL)
2564 is = -1;
2565 else
2566 {
2567 for (is = 0; type->u.kfunction->arg_types[is] != NULL; is++)
2568 if (! debug_write_type (info, fns, fhandle,
2569 type->u.kfunction->arg_types[is],
2570 (struct debug_name *) NULL))
b34976b6 2571 return FALSE;
252b5132
RH		 2572 }
2573 return (*fns->function_type) (fhandle, is,
2574 type->u.kfunction->varargs);
2575 case DEBUG_KIND_REFERENCE:
2576 if (! debug_write_type (info, fns, fhandle, type->u.kreference,
2577 (struct debug_name *) NULL))
b34976b6 2578 return FALSE;
252b5132
RH		 2579 return (*fns->reference_type) (fhandle);
2580 case DEBUG_KIND_RANGE:
2581 if (! debug_write_type (info, fns, fhandle, type->u.krange->type,
2582 (struct debug_name *) NULL))
b34976b6 2583 return FALSE;
252b5132
RH		 2584 return (*fns->range_type) (fhandle, type->u.krange->lower,
2585 type->u.krange->upper);
2586 case DEBUG_KIND_ARRAY:
2587 if (! debug_write_type (info, fns, fhandle, type->u.karray->element_type,
2588 (struct debug_name *) NULL)
2589 || ! debug_write_type (info, fns, fhandle,
2590 type->u.karray->range_type,
2591 (struct debug_name *) NULL))
b34976b6 2592 return FALSE;
252b5132
RH		 2593 return (*fns->array_type) (fhandle, type->u.karray->lower,
2594 type->u.karray->upper,
2595 type->u.karray->stringp);
2596 case DEBUG_KIND_SET:
2597 if (! debug_write_type (info, fns, fhandle, type->u.kset->type,
2598 (struct debug_name *) NULL))
b34976b6 2599 return FALSE;
252b5132
RH		 2600 return (*fns->set_type) (fhandle, type->u.kset->bitstringp);
2601 case DEBUG_KIND_OFFSET:
2602 if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type,
2603 (struct debug_name *) NULL)
2604 || ! debug_write_type (info, fns, fhandle,
2605 type->u.koffset->target_type,
2606 (struct debug_name *) NULL))
b34976b6 2607 return FALSE;
252b5132
RH		 2608 return (*fns->offset_type) (fhandle);
2609 case DEBUG_KIND_METHOD:
2610 if (! debug_write_type (info, fns, fhandle,
2611 type->u.kmethod->return_type,
2612 (struct debug_name *) NULL))
b34976b6 2613 return FALSE;
252b5132
RH		 2614 if (type->u.kmethod->arg_types == NULL)
2615 is = -1;
2616 else
2617 {
2618 for (is = 0; type->u.kmethod->arg_types[is] != NULL; is++)
2619 if (! debug_write_type (info, fns, fhandle,
2620 type->u.kmethod->arg_types[is],
2621 (struct debug_name *) NULL))
b34976b6 2622 return FALSE;
252b5132
RH		 2623 }
2624 if (type->u.kmethod->domain_type != NULL)
2625 {
2626 if (! debug_write_type (info, fns, fhandle,
2627 type->u.kmethod->domain_type,
2628 (struct debug_name *) NULL))
b34976b6 2629 return FALSE;
252b5132
RH		 2630 }
2631 return (*fns->method_type) (fhandle,
2632 type->u.kmethod->domain_type != NULL,
2633 is,
2634 type->u.kmethod->varargs);
2635 case DEBUG_KIND_CONST:
2636 if (! debug_write_type (info, fns, fhandle, type->u.kconst,
2637 (struct debug_name *) NULL))
b34976b6 2638 return FALSE;
252b5132
RH		 2639 return (*fns->const_type) (fhandle);
2640 case DEBUG_KIND_VOLATILE:
2641 if (! debug_write_type (info, fns, fhandle, type->u.kvolatile,
2642 (struct debug_name *) NULL))
b34976b6 2643 return FALSE;
252b5132
RH		 2644 return (*fns->volatile_type) (fhandle);
2645 case DEBUG_KIND_NAMED:
2646 return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2647 (struct debug_name *) NULL);
2648 case DEBUG_KIND_TAGGED:
2649 return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2650 type->u.knamed->name);
2651 default:
2652 abort ();
b34976b6 2653 return FALSE;
252b5132
RH		 2654 }
2655}
2656
2657/* Write out a class type. */
2658
b34976b6 2659static bfd_boolean
2da42df6
AJ		 2660debug_write_class_type (struct debug_handle *info,
2661 const struct debug_write_fns *fns, void *fhandle,
2662 struct debug_type *type, const char *tag)
252b5132
RH		 2663{
2664 unsigned int i;
2665 unsigned int id;
2666 struct debug_type *vptrbase;
2667
2668 if (type->u.kclass == NULL)
2669 {
2670 id = 0;
2671 vptrbase = NULL;
2672 }
2673 else
2674 {
2675 if (type->u.kclass->id <= info->base_id)
2676 {
2677 if (! debug_set_class_id (info, tag, type))
b34976b6 2678 return FALSE;
252b5132
RH		 2679 }
2680
2681 if (info->mark == type->u.kclass->mark)
2682 {
2683 /* We are currently outputting this class, or we have
2684 already output it. This can happen when there are
2685 methods for an anonymous class. */
2686 assert (type->u.kclass->id > info->base_id);
2687 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2688 type->kind);
2689 }
2690 type->u.kclass->mark = info->mark;
2691 id = type->u.kclass->id;
2692
2693 vptrbase = type->u.kclass->vptrbase;
2694 if (vptrbase != NULL && vptrbase != type)
2695 {
2696 if (! debug_write_type (info, fns, fhandle, vptrbase,
2697 (struct debug_name *) NULL))
b34976b6 2698 return FALSE;
252b5132
RH		 2699 }
2700 }
2701
2702 if (! (*fns->start_class_type) (fhandle, tag, id,
2703 type->kind == DEBUG_KIND_CLASS,
2704 type->size,
2705 vptrbase != NULL,
2706 vptrbase == type))
b34976b6 2707 return FALSE;
252b5132
RH		 2708
2709 if (type->u.kclass != NULL)
2710 {
2711 if (type->u.kclass->fields != NULL)
2712 {
2713 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2714 {
2715 struct debug_field *f;
2716
2717 f = type->u.kclass->fields[i];
2718 if (! debug_write_type (info, fns, fhandle, f->type,
2719 (struct debug_name *) NULL))
b34976b6 2720 return FALSE;
252b5132
RH		 2721 if (f->static_member)
2722 {
2723 if (! (*fns->class_static_member) (fhandle, f->name,
2724 f->u.s.physname,
2725 f->visibility))
b34976b6 2726 return FALSE;
252b5132
RH		 2727 }
2728 else
2729 {
2730 if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2731 f->u.f.bitsize, f->visibility))
b34976b6 2732 return FALSE;
252b5132
RH		 2733 }
2734 }
2735 }
2736
2737 if (type->u.kclass->baseclasses != NULL)
2738 {
2739 for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++)
2740 {
2741 struct debug_baseclass *b;
2742
2743 b = type->u.kclass->baseclasses[i];
2744 if (! debug_write_type (info, fns, fhandle, b->type,
2745 (struct debug_name *) NULL))
b34976b6 2746 return FALSE;
252b5132
RH		 2747 if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->virtual,
2748 b->visibility))
b34976b6 2749 return FALSE;
252b5132
RH		 2750 }
2751 }
2752
2753 if (type->u.kclass->methods != NULL)
2754 {
2755 for (i = 0; type->u.kclass->methods[i] != NULL; i++)
2756 {
2757 struct debug_method *m;
2758 unsigned int j;
2759
2760 m = type->u.kclass->methods[i];
2761 if (! (*fns->class_start_method) (fhandle, m->name))
b34976b6 2762 return FALSE;
252b5132
RH		 2763 for (j = 0; m->variants[j] != NULL; j++)
2764 {
2765 struct debug_method_variant *v;
2766
2767 v = m->variants[j];
2768 if (v->context != NULL)
2769 {
2770 if (! debug_write_type (info, fns, fhandle, v->context,
2771 (struct debug_name *) NULL))
b34976b6 2772 return FALSE;
252b5132
RH		 2773 }
2774 if (! debug_write_type (info, fns, fhandle, v->type,
2775 (struct debug_name *) NULL))
b34976b6 2776 return FALSE;
252b5132
RH		 2777 if (v->voffset != VOFFSET_STATIC_METHOD)
2778 {
2779 if (! (*fns->class_method_variant) (fhandle, v->physname,
2780 v->visibility,
2781 v->constp,
2782 v->volatilep,
2783 v->voffset,
2784 v->context != NULL))
b34976b6 2785 return FALSE;
252b5132
RH		 2786 }
2787 else
2788 {
2789 if (! (*fns->class_static_method_variant) (fhandle,
2790 v->physname,
2791 v->visibility,
2792 v->constp,
2793 v->volatilep))
b34976b6 2794 return FALSE;
252b5132
RH		 2795 }
2796 }
2797 if (! (*fns->class_end_method) (fhandle))
b34976b6 2798 return FALSE;
252b5132
RH		 2799 }
2800 }
2801 }
2802
2803 return (*fns->end_class_type) (fhandle);
2804}
2805
2806/* Write out information for a function. */
2807
b34976b6 2808static bfd_boolean
2da42df6
AJ		 2809debug_write_function (struct debug_handle *info,
2810 const struct debug_write_fns *fns, void *fhandle,
2811 const char *name, enum debug_object_linkage linkage,
2812 struct debug_function *function)
252b5132
RH		 2813{
2814 struct debug_parameter *p;
2815 struct debug_block *b;
2816
2817 if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
b34976b6 2818 return FALSE;
252b5132
RH		 2819
2820 if (! debug_write_type (info, fns, fhandle, function->return_type,
2821 (struct debug_name *) NULL))
b34976b6 2822 return FALSE;
252b5132
RH		 2823
2824 if (! (*fns->start_function) (fhandle, name,
2825 linkage == DEBUG_LINKAGE_GLOBAL))
b34976b6 2826 return FALSE;
252b5132
RH		 2827
2828 for (p = function->parameters; p != NULL; p = p->next)
2829 {
2830 if (! debug_write_type (info, fns, fhandle, p->type,
2831 (struct debug_name *) NULL)
2832 || ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val))
b34976b6 2833 return FALSE;
252b5132
RH		 2834 }
2835
2836 for (b = function->blocks; b != NULL; b = b->next)
2837 {
2838 if (! debug_write_block (info, fns, fhandle, b))
b34976b6 2839 return FALSE;
252b5132
RH		 2840 }
2841
2842 return (*fns->end_function) (fhandle);
2843}
2844
2845/* Write out information for a block. */
2846
b34976b6 2847static bfd_boolean
2da42df6
AJ		 2848debug_write_block (struct debug_handle *info,
2849 const struct debug_write_fns *fns, void *fhandle,
2850 struct debug_block *block)
252b5132
RH		 2851{
2852 struct debug_name *n;
2853 struct debug_block *b;
2854
2855 if (! debug_write_linenos (info, fns, fhandle, block->start))
b34976b6 2856 return FALSE;
252b5132
RH		 2857
2858 /* I can't see any point to writing out a block with no local
2859 variables, so we don't bother, except for the top level block. */
2860 if (block->locals != NULL || block->parent == NULL)
2861 {
2862 if (! (*fns->start_block) (fhandle, block->start))
b34976b6 2863 return FALSE;
252b5132
RH		 2864 }
2865
2866 if (block->locals != NULL)
2867 {
2868 for (n = block->locals->list; n != NULL; n = n->next)
2869 {
2870 if (! debug_write_name (info, fns, fhandle, n))
b34976b6 2871 return FALSE;
252b5132
RH		 2872 }
2873 }
2874
2875 for (b = block->children; b != NULL; b = b->next)
2876 {
2877 if (! debug_write_block (info, fns, fhandle, b))
b34976b6 2878 return FALSE;
252b5132
RH		 2879 }
2880
2881 if (! debug_write_linenos (info, fns, fhandle, block->end))
b34976b6 2882 return FALSE;
252b5132
RH		 2883
2884 if (block->locals != NULL || block->parent == NULL)
2885 {
2886 if (! (*fns->end_block) (fhandle, block->end))
b34976b6 2887 return FALSE;
252b5132
RH		 2888 }
2889
b34976b6 2890 return TRUE;
252b5132
RH		 2891}
2892
2893/* Write out line number information up to ADDRESS. */
2894
b34976b6 2895static bfd_boolean
2da42df6
AJ		 2896debug_write_linenos (struct debug_handle *info,
2897 const struct debug_write_fns *fns, void *fhandle,
2898 bfd_vma address)
252b5132
RH		 2899{
2900 while (info->current_write_lineno != NULL)
2901 {
2902 struct debug_lineno *l;
2903
2904 l = info->current_write_lineno;
2905
2906 while (info->current_write_lineno_index < DEBUG_LINENO_COUNT)
2907 {
2908 if (l->linenos[info->current_write_lineno_index]
2909 == (unsigned long) -1)
2910 break;
2911
2912 if (l->addrs[info->current_write_lineno_index] >= address)
b34976b6 2913 return TRUE;
252b5132
RH		 2914
2915 if (! (*fns->lineno) (fhandle, l->file->filename,
2916 l->linenos[info->current_write_lineno_index],
2917 l->addrs[info->current_write_lineno_index]))
b34976b6 2918 return FALSE;
252b5132
RH		 2919
2920 ++info->current_write_lineno_index;
2921 }
2922
2923 info->current_write_lineno = l->next;
2924 info->current_write_lineno_index = 0;
2925 }
2926
b34976b6 2927 return TRUE;
252b5132
RH		 2928}
2929
2930/* Get the ID number for a class. If during the same call to
2931 debug_write we find a struct with the same definition with the same
2932 name, we use the same ID. This type of things happens because the
2933 same struct will be defined by multiple compilation units. */
2934
b34976b6 2935static bfd_boolean
2da42df6
AJ		 2936debug_set_class_id (struct debug_handle *info, const char *tag,
2937 struct debug_type *type)
252b5132
RH		 2938{
2939 struct debug_class_type *c;
2940 struct debug_class_id *l;
2941
2942 assert (type->kind == DEBUG_KIND_STRUCT
2943 || type->kind == DEBUG_KIND_UNION
2944 || type->kind == DEBUG_KIND_CLASS
2945 || type->kind == DEBUG_KIND_UNION_CLASS);
2946
2947 c = type->u.kclass;
2948
2949 if (c->id > info->base_id)
b34976b6 2950 return TRUE;
252b5132
RH		 2951
2952 for (l = info->id_list; l != NULL; l = l->next)
2953 {
2954 if (l->type->kind != type->kind)
2955 continue;
2956
2957 if (tag == NULL)
2958 {
2959 if (l->tag != NULL)
2960 continue;
2961 }
2962 else
2963 {
2964 if (l->tag == NULL
2965 || l->tag[0] != tag[0]
2966 || strcmp (l->tag, tag) != 0)
2967 continue;
2968 }
2969
2970 if (debug_type_samep (info, l->type, type))
2971 {
2972 c->id = l->type->u.kclass->id;
b34976b6 2973 return TRUE;
252b5132
RH		 2974 }
2975 }
2976
2977 /* There are no identical types. Use a new ID, and add it to the
2978 list. */
2979 ++info->class_id;
2980 c->id = info->class_id;
2981
2982 l = (struct debug_class_id *) xmalloc (sizeof *l);
2983 memset (l, 0, sizeof *l);
2984
2985 l->type = type;
2986 l->tag = tag;
2987
2988 l->next = info->id_list;
2989 info->id_list = l;
2990
b34976b6 2991 return TRUE;
252b5132
RH		 2992}
2993
2994/* See if two types are the same. At this point, we don't care about
2995 tags and the like. */
2996
b34976b6 2997static bfd_boolean
2da42df6
AJ		 2998debug_type_samep (struct debug_handle *info, struct debug_type *t1,
2999 struct debug_type *t2)
252b5132
RH		 3000{
3001 struct debug_type_compare_list *l;
3002 struct debug_type_compare_list top;
b34976b6 3003 bfd_boolean ret;
252b5132
RH		 3004
3005 if (t1 == NULL)
3006 return t2 == NULL;
3007 if (t2 == NULL)
b34976b6 3008 return FALSE;
252b5132
RH		 3009
3010 while (t1->kind == DEBUG_KIND_INDIRECT)
3011 {
3012 t1 = *t1->u.kindirect->slot;
3013 if (t1 == NULL)
b34976b6 3014 return FALSE;
252b5132
RH		 3015 }
3016 while (t2->kind == DEBUG_KIND_INDIRECT)
3017 {
3018 t2 = *t2->u.kindirect->slot;
3019 if (t2 == NULL)
b34976b6 3020 return FALSE;
252b5132
RH		 3021 }
3022
3023 if (t1 == t2)
b34976b6 3024 return TRUE;
252b5132
RH		 3025
3026 /* As a special case, permit a typedef to match a tag, since C++
3027 debugging output will sometimes add a typedef where C debugging
3028 output will not. */
3029 if (t1->kind == DEBUG_KIND_NAMED
3030 && t2->kind == DEBUG_KIND_TAGGED)
3031 return debug_type_samep (info, t1->u.knamed->type, t2);
3032 else if (t1->kind == DEBUG_KIND_TAGGED
3033 && t2->kind == DEBUG_KIND_NAMED)
3034 return debug_type_samep (info, t1, t2->u.knamed->type);
3035
3036 if (t1->kind != t2->kind
3037 || t1->size != t2->size)
b34976b6 3038 return FALSE;
252b5132
RH		 3039
3040 /* Get rid of the trivial cases first. */
3041 switch (t1->kind)
3042 {
3043 default:
3044 break;
3045 case DEBUG_KIND_VOID:
3046 case DEBUG_KIND_FLOAT:
3047 case DEBUG_KIND_COMPLEX:
3048 case DEBUG_KIND_BOOL:
b34976b6 3049 return TRUE;
252b5132
RH		 3050 case DEBUG_KIND_INT:
3051 return t1->u.kint == t2->u.kint;
3052 }
3053
3054 /* We have to avoid an infinite recursion. We do this by keeping a
3055 list of types which we are comparing. We just keep the list on
3056 the stack. If we encounter a pair of types we are currently
3057 comparing, we just assume that they are equal. */
3058 for (l = info->compare_list; l != NULL; l = l->next)
3059 {
3060 if (l->t1 == t1 && l->t2 == t2)
b34976b6 3061 return TRUE;
252b5132
RH		 3062 }
3063
3064 top.t1 = t1;
3065 top.t2 = t2;
3066 top.next = info->compare_list;
3067 info->compare_list = &top;
3068
3069 switch (t1->kind)
3070 {
3071 default:
3072 abort ();
b34976b6 3073 ret = FALSE;
252b5132
RH		 3074 break;
3075
3076 case DEBUG_KIND_STRUCT:
3077 case DEBUG_KIND_UNION:
3078 case DEBUG_KIND_CLASS:
3079 case DEBUG_KIND_UNION_CLASS:
3080 if (t1->u.kclass == NULL)
3081 ret = t2->u.kclass == NULL;
3082 else if (t2->u.kclass == NULL)
b34976b6 3083 ret = FALSE;
252b5132
RH		 3084 else if (t1->u.kclass->id > info->base_id
3085 && t1->u.kclass->id == t2->u.kclass->id)
b34976b6 3086 ret = TRUE;
252b5132
RH		 3087 else
3088 ret = debug_class_type_samep (info, t1, t2);
3089 break;
3090
3091 case DEBUG_KIND_ENUM:
3092 if (t1->u.kenum == NULL)
3093 ret = t2->u.kenum == NULL;
3094 else if (t2->u.kenum == NULL)
b34976b6 3095 ret = FALSE;
252b5132
RH		 3096 else
3097 {
3098 const char **pn1, **pn2;
3099 bfd_signed_vma *pv1, *pv2;
3100
3101 pn1 = t1->u.kenum->names;
3102 pn2 = t2->u.kenum->names;
3103 pv1 = t1->u.kenum->values;
3104 pv2 = t2->u.kenum->values;
3105 while (*pn1 != NULL && *pn2 != NULL)
3106 {
3107 if (**pn1 != **pn2
3108 || *pv1 != *pv2
3109 || strcmp (*pn1, *pn2) != 0)
3110 break;
3111 ++pn1;
3112 ++pn2;
3113 ++pv1;
3114 ++pv2;
3115 }
3116 ret = *pn1 == NULL && *pn2 == NULL;
3117 }
3118 break;
3119
3120 case DEBUG_KIND_POINTER:
3121 ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);
3122 break;
26044998 3123
252b5132
RH		 3124 case DEBUG_KIND_FUNCTION:
3125 if (t1->u.kfunction->varargs != t2->u.kfunction->varargs
3126 || ! debug_type_samep (info, t1->u.kfunction->return_type,
3127 t2->u.kfunction->return_type)
3128 || ((t1->u.kfunction->arg_types == NULL)
3129 != (t2->u.kfunction->arg_types == NULL)))
b34976b6 3130 ret = FALSE;
252b5132 3131 else if (t1->u.kfunction->arg_types == NULL)
b34976b6 3132 ret = TRUE;
252b5132
RH		 3133 else
3134 {
3135 struct debug_type **a1, **a2;
3136
3137 a1 = t1->u.kfunction->arg_types;
3138 a2 = t2->u.kfunction->arg_types;
3139 while (*a1 != NULL && *a2 != NULL)
3140 {
3141 if (! debug_type_samep (info, *a1, *a2))
3142 break;
3143 ++a1;
3144 ++a2;
3145 }
3146 ret = *a1 == NULL && *a2 == NULL;
3147 }
3148 break;
3149
3150 case DEBUG_KIND_REFERENCE:
3151 ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);
3152 break;
3153
3154 case DEBUG_KIND_RANGE:
3155 ret = (t1->u.krange->lower == t2->u.krange->lower
3156 && t1->u.krange->upper == t2->u.krange->upper
3157 && debug_type_samep (info, t1->u.krange->type,
3158 t2->u.krange->type));
3159
3160 case DEBUG_KIND_ARRAY:
3161 ret = (t1->u.karray->lower == t2->u.karray->lower
3162 && t1->u.karray->upper == t2->u.karray->upper
3163 && t1->u.karray->stringp == t2->u.karray->stringp
3164 && debug_type_samep (info, t1->u.karray->element_type,
3165 t2->u.karray->element_type));
3166 break;
3167
3168 case DEBUG_KIND_SET:
3169 ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp
3170 && debug_type_samep (info, t1->u.kset->type, t2->u.kset->type));
3171 break;
3172
3173 case DEBUG_KIND_OFFSET:
3174 ret = (debug_type_samep (info, t1->u.koffset->base_type,
3175 t2->u.koffset->base_type)
3176 && debug_type_samep (info, t1->u.koffset->target_type,
3177 t2->u.koffset->target_type));
3178 break;
3179
3180 case DEBUG_KIND_METHOD:
3181 if (t1->u.kmethod->varargs != t2->u.kmethod->varargs
3182 || ! debug_type_samep (info, t1->u.kmethod->return_type,
3183 t2->u.kmethod->return_type)
3184 || ! debug_type_samep (info, t1->u.kmethod->domain_type,
3185 t2->u.kmethod->domain_type)
3186 || ((t1->u.kmethod->arg_types == NULL)
3187 != (t2->u.kmethod->arg_types == NULL)))
b34976b6 3188 ret = FALSE;
252b5132 3189 else if (t1->u.kmethod->arg_types == NULL)
b34976b6 3190 ret = TRUE;
252b5132
RH		 3191 else
3192 {
3193 struct debug_type **a1, **a2;
3194
3195 a1 = t1->u.kmethod->arg_types;
3196 a2 = t2->u.kmethod->arg_types;
3197 while (*a1 != NULL && *a2 != NULL)
3198 {
3199 if (! debug_type_samep (info, *a1, *a2))
3200 break;
3201 ++a1;
3202 ++a2;
3203 }
3204 ret = *a1 == NULL && *a2 == NULL;
3205 }
3206 break;
3207
3208 case DEBUG_KIND_CONST:
3209 ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);
3210 break;
3211
3212 case DEBUG_KIND_VOLATILE:
3213 ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);
3214 break;
3215
3216 case DEBUG_KIND_NAMED:
3217 case DEBUG_KIND_TAGGED:
3218 ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0
3219 && debug_type_samep (info, t1->u.knamed->type,
3220 t2->u.knamed->type));
3221 break;
3222 }
3223
3224 info->compare_list = top.next;
3225
3226 return ret;
3227}
3228
3229/* See if two classes are the same. This is a subroutine of
3230 debug_type_samep. */
3231
b34976b6 3232static bfd_boolean
2da42df6
AJ		 3233debug_class_type_samep (struct debug_handle *info, struct debug_type *t1,
3234 struct debug_type *t2)
252b5132
RH		 3235{
3236 struct debug_class_type *c1, *c2;
3237
3238 c1 = t1->u.kclass;
3239 c2 = t2->u.kclass;
3240
3241 if ((c1->fields == NULL) != (c2->fields == NULL)
3242 || (c1->baseclasses == NULL) != (c2->baseclasses == NULL)
3243 || (c1->methods == NULL) != (c2->methods == NULL)
3244 || (c1->vptrbase == NULL) != (c2->vptrbase == NULL))
b34976b6 3245 return FALSE;
252b5132
RH		 3246
3247 if (c1->fields != NULL)
3248 {
3249 struct debug_field **pf1, **pf2;
3250
3251 for (pf1 = c1->fields, pf2 = c2->fields;
3252 *pf1 != NULL && *pf2 != NULL;
3253 pf1++, pf2++)
3254 {
3255 struct debug_field *f1, *f2;
3256
3257 f1 = *pf1;
3258 f2 = *pf2;
3259 if (f1->name[0] != f2->name[0]
3260 || f1->visibility != f2->visibility
3261 || f1->static_member != f2->static_member)
b34976b6 3262 return FALSE;
252b5132
RH		 3263 if (f1->static_member)
3264 {
3265 if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
b34976b6 3266 return FALSE;
252b5132
RH		 3267 }
3268 else
3269 {
3270 if (f1->u.f.bitpos != f2->u.f.bitpos
3271 || f1->u.f.bitsize != f2->u.f.bitsize)
b34976b6 3272 return FALSE;
252b5132
RH		 3273 }
3274 /* We do the checks which require function calls last. We
3275 don't require that the types of fields have the same
3276 names, since that sometimes fails in the presence of
3277 typedefs and we really don't care. */
3278 if (strcmp (f1->name, f2->name) != 0
3279 || ! debug_type_samep (info,
2da42df6 3280 debug_get_real_type ((void *) info,
252b5132 3281 f1->type, NULL),
2da42df6 3282 debug_get_real_type ((void *) info,
252b5132 3283 f2->type, NULL)))
b34976b6 3284 return FALSE;
252b5132
RH		 3285 }
3286 if (*pf1 != NULL || *pf2 != NULL)
b34976b6 3287 return FALSE;
252b5132
RH		 3288 }
3289
3290 if (c1->vptrbase != NULL)
3291 {
3292 if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
b34976b6 3293 return FALSE;
252b5132
RH		 3294 }
3295
3296 if (c1->baseclasses != NULL)
3297 {
3298 struct debug_baseclass **pb1, **pb2;
3299
3300 for (pb1 = c1->baseclasses, pb2 = c2->baseclasses;
3301 *pb1 != NULL && *pb2 != NULL;
3302 ++pb1, ++pb2)
3303 {
3304 struct debug_baseclass *b1, *b2;
3305
3306 b1 = *pb1;
3307 b2 = *pb2;
3308 if (b1->bitpos != b2->bitpos
3309 || b1->virtual != b2->virtual
3310 || b1->visibility != b2->visibility
3311 || ! debug_type_samep (info, b1->type, b2->type))
b34976b6 3312 return FALSE;
252b5132
RH		 3313 }
3314 if (*pb1 != NULL || *pb2 != NULL)
b34976b6 3315 return FALSE;
252b5132
RH		 3316 }
3317
3318 if (c1->methods != NULL)
3319 {
3320 struct debug_method **pm1, **pm2;
3321
3322 for (pm1 = c1->methods, pm2 = c2->methods;
3323 *pm1 != NULL && *pm2 != NULL;
3324 ++pm1, ++pm2)
3325 {
3326 struct debug_method *m1, *m2;
3327
3328 m1 = *pm1;
3329 m2 = *pm2;
3330 if (m1->name[0] != m2->name[0]
3331 || strcmp (m1->name, m2->name) != 0
3332 || (m1->variants == NULL) != (m2->variants == NULL))
b34976b6 3333 return FALSE;
252b5132
RH		 3334 if (m1->variants == NULL)
3335 {
3336 struct debug_method_variant **pv1, **pv2;
3337
3338 for (pv1 = m1->variants, pv2 = m2->variants;
3339 *pv1 != NULL && *pv2 != NULL;
3340 ++pv1, ++pv2)
3341 {
3342 struct debug_method_variant *v1, *v2;
3343
3344 v1 = *pv1;
3345 v2 = *pv2;
3346 if (v1->physname[0] != v2->physname[0]
3347 || v1->visibility != v2->visibility
3348 || v1->constp != v2->constp
3349 || v1->volatilep != v2->volatilep
3350 || v1->voffset != v2->voffset
3351 || (v1->context == NULL) != (v2->context == NULL)
3352 || strcmp (v1->physname, v2->physname) != 0
3353 || ! debug_type_samep (info, v1->type, v2->type))
b34976b6 3354 return FALSE;
252b5132
RH		 3355 if (v1->context != NULL)
3356 {
3357 if (! debug_type_samep (info, v1->context,
3358 v2->context))
b34976b6 3359 return FALSE;
252b5132
RH		 3360 }
3361 }
3362 if (*pv1 != NULL || *pv2 != NULL)
b34976b6 3363 return FALSE;
252b5132
RH		 3364 }
3365 }
3366 if (*pm1 != NULL || *pm2 != NULL)
b34976b6 3367 return FALSE;
252b5132
RH		 3368 }
3369
b34976b6 3370 return TRUE;
252b5132 3371}
GDB Binutils - Deliverables
This page took 0.802903 seconds and 4 git commands to generate.