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