daily update
[binutils.git] / binutils / debug.c
blob07d38acfe4021aac62f154ca4f62e0df11622cc0
1 /* debug.c -- Handle generic debugging information.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of GNU Binutils.
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.
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.
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
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
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
26 this was writing a converter from stabs to HP IEEE-695 debugging
27 format. */
29 #include <stdio.h>
30 #include <assert.h>
32 #include "bfd.h"
33 #include "bucomm.h"
34 #include "libiberty.h"
35 #include "debug.h"
37 /* Global information we keep for debugging. A pointer to this
38 structure is the debugging handle passed to all the routines. */
40 struct debug_handle
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;
70 /* Information we keep for a single compilation unit. */
72 struct debug_unit
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;
86 /* Information kept for a single source file. */
88 struct debug_file
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;
98 /* A type. */
100 struct debug_type
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
111 /* DEBUG_KIND_INDIRECT. */
112 struct debug_indirect_type *kindirect;
113 /* DEBUG_KIND_INT. */
114 /* Whether the integer is unsigned. */
115 bfd_boolean kint;
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;
146 /* Information kept for an indirect type. */
148 struct debug_indirect_type
150 /* Slot where the final type will appear. */
151 debug_type *slot;
152 /* Tag. */
153 const char *tag;
156 /* Information kept for a struct, union, or class. */
158 struct debug_class_type
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;
178 /* Information kept for an enum. */
180 struct debug_enum_type
182 /* NULL terminated array of names. */
183 const char **names;
184 /* Array of corresponding values. */
185 bfd_signed_vma *values;
188 /* Information kept for a function. FIXME: We should be able to
189 record the parameter types. */
191 struct debug_function_type
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. */
198 bfd_boolean varargs;
201 /* Information kept for a range. */
203 struct debug_range_type
205 /* Range base type. */
206 debug_type type;
207 /* Lower bound. */
208 bfd_signed_vma lower;
209 /* Upper bound. */
210 bfd_signed_vma upper;
213 /* Information kept for an array. */
215 struct debug_array_type
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. */
226 bfd_boolean stringp;
229 /* Information kept for a set. */
231 struct debug_set_type
233 /* Base type. */
234 debug_type type;
235 /* Whether this set is really a bitstring. */
236 bfd_boolean bitstringp;
239 /* Information kept for an offset type (a based pointer). */
241 struct debug_offset_type
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;
249 /* Information kept for a method type. */
251 struct debug_method_type
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. */
260 bfd_boolean varargs;
263 /* Information kept for a named type. */
265 struct debug_named_type
267 /* Name. */
268 struct debug_name *name;
269 /* Real type. */
270 debug_type type;
273 /* A field in a struct or union. */
275 struct debug_field
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. */
284 bfd_boolean static_member;
285 union
287 /* If static_member is false. */
288 struct
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
298 const char *physname;
299 } s;
300 } u;
303 /* A base class for an object. */
305 struct debug_baseclass
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. */
312 bfd_boolean virtual;
313 /* Visibility of the base class. */
314 enum debug_visibility visibility;
317 /* A method of an object. */
319 struct debug_method
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;
327 /* The variants of a method function of an object. These indicate
328 which method to run. */
330 struct debug_method_variant
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. */
339 bfd_boolean constp;
340 /* Whether the function is volatile. */
341 bfd_boolean volatilep;
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;
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. */
354 struct debug_variable
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;
364 /* A function. This has no name; a name is associated with a function
365 in a debug_name structure. */
367 struct debug_function
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;
378 /* A function parameter. */
380 struct debug_parameter
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;
394 /* A typed constant. */
396 struct debug_typed_constant
398 /* Type. */
399 debug_type type;
400 /* Value. FIXME: We may eventually need to support non-integral
401 values. */
402 bfd_vma val;
405 /* Information about a block within a function. */
407 struct debug_block
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;
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. */
427 struct debug_lineno
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];
440 /* A namespace. This is a mapping from names to objects. FIXME: This
441 should be implemented as a hash table. */
443 struct debug_namespace
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;
451 /* Kinds of objects that appear in a namespace. */
453 enum debug_object_kind
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
471 /* Linkage of an object that appears in a namespace. */
473 enum debug_object_linkage
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
486 /* A name in a namespace. */
488 struct debug_name
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
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;
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. */
523 struct debug_class_id
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;
533 /* During debug_type_samep, a linked list of these structures is kept
534 on the stack to avoid infinite recursion. */
536 struct debug_type_compare_list
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;
545 /* During debug_get_real_type, a linked list of these structures is
546 kept on the stack to avoid infinite recursion. */
548 struct debug_type_real_list
550 /* Next type on list. */
551 struct debug_type_real_list *next;
552 /* The type we are checking. */
553 struct debug_type *t;
556 /* Local functions. */
558 static void debug_error (const char *);
559 static struct debug_name *debug_add_to_namespace
560 (struct debug_handle *, struct debug_namespace **, const char *,
561 enum debug_object_kind, enum debug_object_linkage);
562 static struct debug_name *debug_add_to_current_namespace
563 (struct debug_handle *, const char *, enum debug_object_kind,
564 enum debug_object_linkage);
565 static struct debug_type *debug_make_type
566 (struct debug_handle *, enum debug_type_kind, unsigned int);
567 static struct debug_type *debug_get_real_type
568 (void *, debug_type, struct debug_type_real_list *);
569 static bfd_boolean debug_write_name
570 (struct debug_handle *, const struct debug_write_fns *, void *,
571 struct debug_name *);
572 static bfd_boolean debug_write_type
573 (struct debug_handle *, const struct debug_write_fns *, void *,
574 struct debug_type *, struct debug_name *);
575 static bfd_boolean debug_write_class_type
576 (struct debug_handle *, const struct debug_write_fns *, void *,
577 struct debug_type *, const char *);
578 static bfd_boolean debug_write_function
579 (struct debug_handle *, const struct debug_write_fns *, void *,
580 const char *, enum debug_object_linkage, struct debug_function *);
581 static bfd_boolean debug_write_block
582 (struct debug_handle *, const struct debug_write_fns *, void *,
583 struct debug_block *);
584 static bfd_boolean debug_write_linenos
585 (struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma);
586 static bfd_boolean debug_set_class_id
587 (struct debug_handle *, const char *, struct debug_type *);
588 static bfd_boolean debug_type_samep
589 (struct debug_handle *, struct debug_type *, struct debug_type *);
590 static bfd_boolean debug_class_type_samep
591 (struct debug_handle *, struct debug_type *, struct debug_type *);
593 /* Issue an error message. */
595 static void
596 debug_error (const char *message)
598 fprintf (stderr, "%s\n", message);
601 /* Add an object to a namespace. */
603 static struct debug_name *
604 debug_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)
609 struct debug_name *n;
610 struct debug_namespace *ns;
612 n = (struct debug_name *) xmalloc (sizeof *n);
613 memset (n, 0, sizeof *n);
615 n->name = name;
616 n->kind = kind;
617 n->linkage = linkage;
619 ns = *nsp;
620 if (ns == NULL)
622 ns = (struct debug_namespace *) xmalloc (sizeof *ns);
623 memset (ns, 0, sizeof *ns);
625 ns->tail = &ns->list;
627 *nsp = ns;
630 *ns->tail = n;
631 ns->tail = &n->next;
633 return n;
636 /* Add an object to the current namespace. */
638 static struct debug_name *
639 debug_add_to_current_namespace (struct debug_handle *info, const char *name,
640 enum debug_object_kind kind,
641 enum debug_object_linkage linkage)
643 struct debug_namespace **nsp;
645 if (info->current_unit == NULL
646 || info->current_file == NULL)
648 debug_error (_("debug_add_to_current_namespace: no current file"));
649 return NULL;
652 if (info->current_block != NULL)
653 nsp = &info->current_block->locals;
654 else
655 nsp = &info->current_file->globals;
657 return debug_add_to_namespace (info, nsp, name, kind, linkage);
660 /* Return a handle for debugging information. */
662 void *
663 debug_init (void)
665 struct debug_handle *ret;
667 ret = (struct debug_handle *) xmalloc (sizeof *ret);
668 memset (ret, 0, sizeof *ret);
669 return (void *) ret;
672 /* Set the source filename. This implicitly starts a new compilation
673 unit. */
675 bfd_boolean
676 debug_set_filename (void *handle, const char *name)
678 struct debug_handle *info = (struct debug_handle *) handle;
679 struct debug_file *nfile;
680 struct debug_unit *nunit;
682 if (name == NULL)
683 name = "";
685 nfile = (struct debug_file *) xmalloc (sizeof *nfile);
686 memset (nfile, 0, sizeof *nfile);
688 nfile->filename = name;
690 nunit = (struct debug_unit *) xmalloc (sizeof *nunit);
691 memset (nunit, 0, sizeof *nunit);
693 nunit->files = nfile;
694 info->current_file = nfile;
696 if (info->current_unit != NULL)
697 info->current_unit->next = nunit;
698 else
700 assert (info->units == NULL);
701 info->units = nunit;
704 info->current_unit = nunit;
706 info->current_function = NULL;
707 info->current_block = NULL;
708 info->current_lineno = NULL;
710 return TRUE;
713 /* Change source files to the given file name. This is used for
714 include files in a single compilation unit. */
716 bfd_boolean
717 debug_start_source (void *handle, const char *name)
719 struct debug_handle *info = (struct debug_handle *) handle;
720 struct debug_file *f, **pf;
722 if (name == NULL)
723 name = "";
725 if (info->current_unit == NULL)
727 debug_error (_("debug_start_source: no debug_set_filename call"));
728 return FALSE;
731 for (f = info->current_unit->files; f != NULL; f = f->next)
733 if (f->filename[0] == name[0]
734 && f->filename[1] == name[1]
735 && strcmp (f->filename, name) == 0)
737 info->current_file = f;
738 return TRUE;
742 f = (struct debug_file *) xmalloc (sizeof *f);
743 memset (f, 0, sizeof *f);
745 f->filename = name;
747 for (pf = &info->current_file->next;
748 *pf != NULL;
749 pf = &(*pf)->next)
751 *pf = f;
753 info->current_file = f;
755 return TRUE;
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. */
766 bfd_boolean
767 debug_record_function (void *handle, const char *name,
768 debug_type return_type, bfd_boolean global,
769 bfd_vma addr)
771 struct debug_handle *info = (struct debug_handle *) handle;
772 struct debug_function *f;
773 struct debug_block *b;
774 struct debug_name *n;
776 if (name == NULL)
777 name = "";
778 if (return_type == NULL)
779 return FALSE;
781 if (info->current_unit == NULL)
783 debug_error (_("debug_record_function: no debug_set_filename call"));
784 return FALSE;
787 f = (struct debug_function *) xmalloc (sizeof *f);
788 memset (f, 0, sizeof *f);
790 f->return_type = return_type;
792 b = (struct debug_block *) xmalloc (sizeof *b);
793 memset (b, 0, sizeof *b);
795 b->start = addr;
796 b->end = (bfd_vma) -1;
798 f->blocks = b;
800 info->current_function = f;
801 info->current_block = b;
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)
813 return FALSE;
815 n->u.function = f;
817 return TRUE;
820 /* Record a parameter for the current function. */
822 bfd_boolean
823 debug_record_parameter (void *handle, const char *name, debug_type type,
824 enum debug_parm_kind kind, bfd_vma val)
826 struct debug_handle *info = (struct debug_handle *) handle;
827 struct debug_parameter *p, **pp;
829 if (name == NULL || type == NULL)
830 return FALSE;
832 if (info->current_unit == NULL
833 || info->current_function == NULL)
835 debug_error (_("debug_record_parameter: no current function"));
836 return FALSE;
839 p = (struct debug_parameter *) xmalloc (sizeof *p);
840 memset (p, 0, sizeof *p);
842 p->name = name;
843 p->type = type;
844 p->kind = kind;
845 p->val = val;
847 for (pp = &info->current_function->parameters;
848 *pp != NULL;
849 pp = &(*pp)->next)
851 *pp = p;
853 return TRUE;
856 /* End a function. FIXME: This should handle function nesting. */
858 bfd_boolean
859 debug_end_function (void *handle, bfd_vma addr)
861 struct debug_handle *info = (struct debug_handle *) handle;
863 if (info->current_unit == NULL
864 || info->current_block == NULL
865 || info->current_function == NULL)
867 debug_error (_("debug_end_function: no current function"));
868 return FALSE;
871 if (info->current_block->parent != NULL)
873 debug_error (_("debug_end_function: some blocks were not closed"));
874 return FALSE;
877 info->current_block->end = addr;
879 info->current_function = NULL;
880 info->current_block = NULL;
882 return TRUE;
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. */
890 bfd_boolean
891 debug_start_block (void *handle, bfd_vma addr)
893 struct debug_handle *info = (struct debug_handle *) handle;
894 struct debug_block *b, **pb;
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)
901 debug_error (_("debug_start_block: no current block"));
902 return FALSE;
905 b = (struct debug_block *) xmalloc (sizeof *b);
906 memset (b, 0, sizeof *b);
908 b->parent = info->current_block;
909 b->start = addr;
910 b->end = (bfd_vma) -1;
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)
917 *pb = b;
919 info->current_block = b;
921 return TRUE;
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. */
928 bfd_boolean
929 debug_end_block (void *handle, bfd_vma addr)
931 struct debug_handle *info = (struct debug_handle *) handle;
932 struct debug_block *parent;
934 if (info->current_unit == NULL
935 || info->current_block == NULL)
937 debug_error (_("debug_end_block: no current block"));
938 return FALSE;
941 parent = info->current_block->parent;
942 if (parent == NULL)
944 debug_error (_("debug_end_block: attempt to close top level block"));
945 return FALSE;
948 info->current_block->end = addr;
950 info->current_block = parent;
952 return TRUE;
955 /* Associate a line number in the current source file and function
956 with a given address. */
958 bfd_boolean
959 debug_record_line (void *handle, unsigned long lineno, bfd_vma addr)
961 struct debug_handle *info = (struct debug_handle *) handle;
962 struct debug_lineno *l;
963 unsigned int i;
965 if (info->current_unit == NULL)
967 debug_error (_("debug_record_line: no current unit"));
968 return FALSE;
971 l = info->current_lineno;
972 if (l != NULL && l->file == info->current_file)
974 for (i = 0; i < DEBUG_LINENO_COUNT; i++)
976 if (l->linenos[i] == (unsigned long) -1)
978 l->linenos[i] = lineno;
979 l->addrs[i] = addr;
980 return TRUE;
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. */
993 l = (struct debug_lineno *) xmalloc (sizeof *l);
994 memset (l, 0, sizeof *l);
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;
1002 if (info->current_lineno != NULL)
1003 info->current_lineno->next = l;
1004 else
1005 info->current_unit->linenos = l;
1007 info->current_lineno = l;
1009 return TRUE;
1012 /* Start a named common block. This is a block of variables that may
1013 move in memory. */
1015 bfd_boolean
1016 debug_start_common_block (void *handle ATTRIBUTE_UNUSED,
1017 const char *name ATTRIBUTE_UNUSED)
1019 /* FIXME */
1020 debug_error (_("debug_start_common_block: not implemented"));
1021 return FALSE;
1024 /* End a named common block. */
1026 bfd_boolean
1027 debug_end_common_block (void *handle ATTRIBUTE_UNUSED,
1028 const char *name ATTRIBUTE_UNUSED)
1030 /* FIXME */
1031 debug_error (_("debug_end_common_block: not implemented"));
1032 return FALSE;
1035 /* Record a named integer constant. */
1037 bfd_boolean
1038 debug_record_int_const (void *handle, const char *name, bfd_vma val)
1040 struct debug_handle *info = (struct debug_handle *) handle;
1041 struct debug_name *n;
1043 if (name == NULL)
1044 return FALSE;
1046 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT,
1047 DEBUG_LINKAGE_NONE);
1048 if (n == NULL)
1049 return FALSE;
1051 n->u.int_constant = val;
1053 return TRUE;
1056 /* Record a named floating point constant. */
1058 bfd_boolean
1059 debug_record_float_const (void *handle, const char *name, double val)
1061 struct debug_handle *info = (struct debug_handle *) handle;
1062 struct debug_name *n;
1064 if (name == NULL)
1065 return FALSE;
1067 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT,
1068 DEBUG_LINKAGE_NONE);
1069 if (n == NULL)
1070 return FALSE;
1072 n->u.float_constant = val;
1074 return TRUE;
1077 /* Record a typed constant with an integral value. */
1079 bfd_boolean
1080 debug_record_typed_const (void *handle, const char *name, debug_type type,
1081 bfd_vma val)
1083 struct debug_handle *info = (struct debug_handle *) handle;
1084 struct debug_name *n;
1085 struct debug_typed_constant *tc;
1087 if (name == NULL || type == NULL)
1088 return FALSE;
1090 n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT,
1091 DEBUG_LINKAGE_NONE);
1092 if (n == NULL)
1093 return FALSE;
1095 tc = (struct debug_typed_constant *) xmalloc (sizeof *tc);
1096 memset (tc, 0, sizeof *tc);
1098 tc->type = type;
1099 tc->val = val;
1101 n->u.typed_constant = tc;
1103 return TRUE;
1106 /* Record a label. */
1108 bfd_boolean
1109 debug_record_label (void *handle ATTRIBUTE_UNUSED,
1110 const char *name ATTRIBUTE_UNUSED,
1111 debug_type type ATTRIBUTE_UNUSED,
1112 bfd_vma addr ATTRIBUTE_UNUSED)
1114 /* FIXME. */
1115 debug_error (_("debug_record_label: not implemented"));
1116 return FALSE;
1119 /* Record a variable. */
1121 bfd_boolean
1122 debug_record_variable (void *handle, const char *name, debug_type type,
1123 enum debug_var_kind kind, bfd_vma val)
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;
1131 if (name == NULL || type == NULL)
1132 return FALSE;
1134 if (info->current_unit == NULL
1135 || info->current_file == NULL)
1137 debug_error (_("debug_record_variable: no current file"));
1138 return FALSE;
1141 if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
1143 nsp = &info->current_file->globals;
1144 if (kind == DEBUG_GLOBAL)
1145 linkage = DEBUG_LINKAGE_GLOBAL;
1146 else
1147 linkage = DEBUG_LINKAGE_STATIC;
1149 else
1151 if (info->current_block == NULL)
1152 nsp = &info->current_file->globals;
1153 else
1154 nsp = &info->current_block->locals;
1155 linkage = DEBUG_LINKAGE_AUTOMATIC;
1158 n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
1159 if (n == NULL)
1160 return FALSE;
1162 v = (struct debug_variable *) xmalloc (sizeof *v);
1163 memset (v, 0, sizeof *v);
1165 v->kind = kind;
1166 v->type = type;
1167 v->val = val;
1169 n->u.variable = v;
1171 return TRUE;
1174 /* Make a type with a given kind and size. */
1176 static struct debug_type *
1177 debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED,
1178 enum debug_type_kind kind, unsigned int size)
1180 struct debug_type *t;
1182 t = (struct debug_type *) xmalloc (sizeof *t);
1183 memset (t, 0, sizeof *t);
1185 t->kind = kind;
1186 t->size = size;
1188 return t;
1191 /* Make an indirect type which may be used as a placeholder for a type
1192 which is referenced before it is defined. */
1194 debug_type
1195 debug_make_indirect_type (void *handle, debug_type *slot, const char *tag)
1197 struct debug_handle *info = (struct debug_handle *) handle;
1198 struct debug_type *t;
1199 struct debug_indirect_type *i;
1201 t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0);
1202 if (t == NULL)
1203 return DEBUG_TYPE_NULL;
1205 i = (struct debug_indirect_type *) xmalloc (sizeof *i);
1206 memset (i, 0, sizeof *i);
1208 i->slot = slot;
1209 i->tag = tag;
1211 t->u.kindirect = i;
1213 return t;
1216 /* Make a void type. There is only one of these. */
1218 debug_type
1219 debug_make_void_type (void *handle)
1221 struct debug_handle *info = (struct debug_handle *) handle;
1223 return debug_make_type (info, DEBUG_KIND_VOID, 0);
1226 /* Make an integer type of a given size. The boolean argument is true
1227 if the integer is unsigned. */
1229 debug_type
1230 debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp)
1232 struct debug_handle *info = (struct debug_handle *) handle;
1233 struct debug_type *t;
1235 t = debug_make_type (info, DEBUG_KIND_INT, size);
1236 if (t == NULL)
1237 return DEBUG_TYPE_NULL;
1239 t->u.kint = unsignedp;
1241 return t;
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. */
1248 debug_type
1249 debug_make_float_type (void *handle, unsigned int size)
1251 struct debug_handle *info = (struct debug_handle *) handle;
1253 return debug_make_type (info, DEBUG_KIND_FLOAT, size);
1256 /* Make a boolean type of a given size. */
1258 debug_type
1259 debug_make_bool_type (void *handle, unsigned int size)
1261 struct debug_handle *info = (struct debug_handle *) handle;
1263 return debug_make_type (info, DEBUG_KIND_BOOL, size);
1266 /* Make a complex type of a given size. */
1268 debug_type
1269 debug_make_complex_type (void *handle, unsigned int size)
1271 struct debug_handle *info = (struct debug_handle *) handle;
1273 return debug_make_type (info, DEBUG_KIND_COMPLEX, size);
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. */
1280 debug_type
1281 debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size,
1282 debug_field *fields)
1284 struct debug_handle *info = (struct debug_handle *) handle;
1285 struct debug_type *t;
1286 struct debug_class_type *c;
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;
1294 c = (struct debug_class_type *) xmalloc (sizeof *c);
1295 memset (c, 0, sizeof *c);
1297 c->fields = fields;
1299 t->u.kclass = c;
1301 return t;
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. */
1311 debug_type
1312 debug_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)
1317 struct debug_handle *info = (struct debug_handle *) handle;
1318 struct debug_type *t;
1319 struct debug_class_type *c;
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;
1327 c = (struct debug_class_type *) xmalloc (sizeof *c);
1328 memset (c, 0, sizeof *c);
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;
1338 t->u.kclass = c;
1340 return t;
1343 /* Make an enumeration type. The arguments are a null terminated
1344 array of strings, and an array of corresponding values. */
1346 debug_type
1347 debug_make_enum_type (void *handle, const char **names,
1348 bfd_signed_vma *values)
1350 struct debug_handle *info = (struct debug_handle *) handle;
1351 struct debug_type *t;
1352 struct debug_enum_type *e;
1354 t = debug_make_type (info, DEBUG_KIND_ENUM, 0);
1355 if (t == NULL)
1356 return DEBUG_TYPE_NULL;
1358 e = (struct debug_enum_type *) xmalloc (sizeof *e);
1359 memset (e, 0, sizeof *e);
1361 e->names = names;
1362 e->values = values;
1364 t->u.kenum = e;
1366 return t;
1369 /* Make a pointer to a given type. */
1371 debug_type
1372 debug_make_pointer_type (void *handle, debug_type type)
1374 struct debug_handle *info = (struct debug_handle *) handle;
1375 struct debug_type *t;
1377 if (type == NULL)
1378 return DEBUG_TYPE_NULL;
1380 if (type->pointer != DEBUG_TYPE_NULL)
1381 return type->pointer;
1383 t = debug_make_type (info, DEBUG_KIND_POINTER, 0);
1384 if (t == NULL)
1385 return DEBUG_TYPE_NULL;
1387 t->u.kpointer = type;
1389 type->pointer = t;
1391 return t;
1394 /* Make a function returning a given type. FIXME: We should be able
1395 to record the parameter types. */
1397 debug_type
1398 debug_make_function_type (void *handle, debug_type type,
1399 debug_type *arg_types, bfd_boolean varargs)
1401 struct debug_handle *info = (struct debug_handle *) handle;
1402 struct debug_type *t;
1403 struct debug_function_type *f;
1405 if (type == NULL)
1406 return DEBUG_TYPE_NULL;
1408 t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0);
1409 if (t == NULL)
1410 return DEBUG_TYPE_NULL;
1412 f = (struct debug_function_type *) xmalloc (sizeof *f);
1413 memset (f, 0, sizeof *f);
1415 f->return_type = type;
1416 f->arg_types = arg_types;
1417 f->varargs = varargs;
1419 t->u.kfunction = f;
1421 return t;
1424 /* Make a reference to a given type. */
1426 debug_type
1427 debug_make_reference_type (void *handle, debug_type type)
1429 struct debug_handle *info = (struct debug_handle *) handle;
1430 struct debug_type *t;
1432 if (type == NULL)
1433 return DEBUG_TYPE_NULL;
1435 t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0);
1436 if (t == NULL)
1437 return DEBUG_TYPE_NULL;
1439 t->u.kreference = type;
1441 return t;
1444 /* Make a range of a given type from a lower to an upper bound. */
1446 debug_type
1447 debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower,
1448 bfd_signed_vma upper)
1450 struct debug_handle *info = (struct debug_handle *) handle;
1451 struct debug_type *t;
1452 struct debug_range_type *r;
1454 if (type == NULL)
1455 return DEBUG_TYPE_NULL;
1457 t = debug_make_type (info, DEBUG_KIND_RANGE, 0);
1458 if (t == NULL)
1459 return DEBUG_TYPE_NULL;
1461 r = (struct debug_range_type *) xmalloc (sizeof *r);
1462 memset (r, 0, sizeof *r);
1464 r->type = type;
1465 r->lower = lower;
1466 r->upper = upper;
1468 t->u.krange = r;
1470 return t;
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. */
1479 debug_type
1480 debug_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)
1484 struct debug_handle *info = (struct debug_handle *) handle;
1485 struct debug_type *t;
1486 struct debug_array_type *a;
1488 if (element_type == NULL || range_type == NULL)
1489 return DEBUG_TYPE_NULL;
1491 t = debug_make_type (info, DEBUG_KIND_ARRAY, 0);
1492 if (t == NULL)
1493 return DEBUG_TYPE_NULL;
1495 a = (struct debug_array_type *) xmalloc (sizeof *a);
1496 memset (a, 0, sizeof *a);
1498 a->element_type = element_type;
1499 a->range_type = range_type;
1500 a->lower = lower;
1501 a->upper = upper;
1502 a->stringp = stringp;
1504 t->u.karray = a;
1506 return t;
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. */
1513 debug_type
1514 debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp)
1516 struct debug_handle *info = (struct debug_handle *) handle;
1517 struct debug_type *t;
1518 struct debug_set_type *s;
1520 if (type == NULL)
1521 return DEBUG_TYPE_NULL;
1523 t = debug_make_type (info, DEBUG_KIND_SET, 0);
1524 if (t == NULL)
1525 return DEBUG_TYPE_NULL;
1527 s = (struct debug_set_type *) xmalloc (sizeof *s);
1528 memset (s, 0, sizeof *s);
1530 s->type = type;
1531 s->bitstringp = bitstringp;
1533 t->u.kset = s;
1535 return t;
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. */
1543 debug_type
1544 debug_make_offset_type (void *handle, debug_type base_type,
1545 debug_type target_type)
1547 struct debug_handle *info = (struct debug_handle *) handle;
1548 struct debug_type *t;
1549 struct debug_offset_type *o;
1551 if (base_type == NULL || target_type == NULL)
1552 return DEBUG_TYPE_NULL;
1554 t = debug_make_type (info, DEBUG_KIND_OFFSET, 0);
1555 if (t == NULL)
1556 return DEBUG_TYPE_NULL;
1558 o = (struct debug_offset_type *) xmalloc (sizeof *o);
1559 memset (o, 0, sizeof *o);
1561 o->base_type = base_type;
1562 o->target_type = target_type;
1564 t->u.koffset = o;
1566 return t;
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. */
1573 debug_type
1574 debug_make_method_type (void *handle, debug_type return_type,
1575 debug_type domain_type, debug_type *arg_types,
1576 bfd_boolean varargs)
1578 struct debug_handle *info = (struct debug_handle *) handle;
1579 struct debug_type *t;
1580 struct debug_method_type *m;
1582 if (return_type == NULL)
1583 return DEBUG_TYPE_NULL;
1585 t = debug_make_type (info, DEBUG_KIND_METHOD, 0);
1586 if (t == NULL)
1587 return DEBUG_TYPE_NULL;
1589 m = (struct debug_method_type *) xmalloc (sizeof *m);
1590 memset (m, 0, sizeof *m);
1592 m->return_type = return_type;
1593 m->domain_type = domain_type;
1594 m->arg_types = arg_types;
1595 m->varargs = varargs;
1597 t->u.kmethod = m;
1599 return t;
1602 /* Make a const qualified version of a given type. */
1604 debug_type
1605 debug_make_const_type (void *handle, debug_type type)
1607 struct debug_handle *info = (struct debug_handle *) handle;
1608 struct debug_type *t;
1610 if (type == NULL)
1611 return DEBUG_TYPE_NULL;
1613 t = debug_make_type (info, DEBUG_KIND_CONST, 0);
1614 if (t == NULL)
1615 return DEBUG_TYPE_NULL;
1617 t->u.kconst = type;
1619 return t;
1622 /* Make a volatile qualified version of a given type. */
1624 debug_type
1625 debug_make_volatile_type (void *handle, debug_type type)
1627 struct debug_handle *info = (struct debug_handle *) handle;
1628 struct debug_type *t;
1630 if (type == NULL)
1631 return DEBUG_TYPE_NULL;
1633 t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0);
1634 if (t == NULL)
1635 return DEBUG_TYPE_NULL;
1637 t->u.kvolatile = type;
1639 return t;
1642 /* Make an undefined tagged type. For example, a struct which has
1643 been mentioned, but not defined. */
1645 debug_type
1646 debug_make_undefined_tagged_type (void *handle, const char *name,
1647 enum debug_type_kind kind)
1649 struct debug_handle *info = (struct debug_handle *) handle;
1650 struct debug_type *t;
1652 if (name == NULL)
1653 return DEBUG_TYPE_NULL;
1655 switch (kind)
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;
1664 default:
1665 debug_error (_("debug_make_undefined_type: unsupported kind"));
1666 return DEBUG_TYPE_NULL;
1669 t = debug_make_type (info, kind, 0);
1670 if (t == NULL)
1671 return DEBUG_TYPE_NULL;
1673 return debug_tag_type (handle, name, t);
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. */
1682 debug_baseclass
1683 debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type,
1684 bfd_vma bitpos, bfd_boolean virtual,
1685 enum debug_visibility visibility)
1687 struct debug_baseclass *b;
1689 b = (struct debug_baseclass *) xmalloc (sizeof *b);
1690 memset (b, 0, sizeof *b);
1692 b->type = type;
1693 b->bitpos = bitpos;
1694 b->virtual = virtual;
1695 b->visibility = visibility;
1697 return b;
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. */
1706 debug_field
1707 debug_make_field (void *handle ATTRIBUTE_UNUSED, const char *name,
1708 debug_type type, bfd_vma bitpos, bfd_vma bitsize,
1709 enum debug_visibility visibility)
1711 struct debug_field *f;
1713 f = (struct debug_field *) xmalloc (sizeof *f);
1714 memset (f, 0, sizeof *f);
1716 f->name = name;
1717 f->type = type;
1718 f->static_member = FALSE;
1719 f->u.f.bitpos = bitpos;
1720 f->u.f.bitsize = bitsize;
1721 f->visibility = visibility;
1723 return f;
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. */
1732 debug_field
1733 debug_make_static_member (void *handle ATTRIBUTE_UNUSED, const char *name,
1734 debug_type type, const char *physname,
1735 enum debug_visibility visibility)
1737 struct debug_field *f;
1739 f = (struct debug_field *) xmalloc (sizeof *f);
1740 memset (f, 0, sizeof *f);
1742 f->name = name;
1743 f->type = type;
1744 f->static_member = TRUE;
1745 f->u.s.physname = physname;
1746 f->visibility = visibility;
1748 return f;
1751 /* Make a method. The second argument is the name, and the third
1752 argument is a NULL terminated array of method variants. */
1754 debug_method
1755 debug_make_method (void *handle ATTRIBUTE_UNUSED, const char *name,
1756 debug_method_variant *variants)
1758 struct debug_method *m;
1760 m = (struct debug_method *) xmalloc (sizeof *m);
1761 memset (m, 0, sizeof *m);
1763 m->name = name;
1764 m->variants = variants;
1766 return m;
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? */
1778 debug_method_variant
1779 debug_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)
1785 struct debug_method_variant *m;
1787 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1788 memset (m, 0, sizeof *m);
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;
1798 return m;
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. */
1805 debug_method_variant
1806 debug_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)
1811 struct debug_method_variant *m;
1813 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1814 memset (m, 0, sizeof *m);
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;
1823 return m;
1826 /* Name a type. */
1828 debug_type
1829 debug_name_type (void *handle, const char *name, debug_type type)
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;
1836 if (name == NULL || type == NULL)
1837 return DEBUG_TYPE_NULL;
1839 if (info->current_unit == NULL
1840 || info->current_file == NULL)
1842 debug_error (_("debug_name_type: no current file"));
1843 return DEBUG_TYPE_NULL;
1846 t = debug_make_type (info, DEBUG_KIND_NAMED, 0);
1847 if (t == NULL)
1848 return DEBUG_TYPE_NULL;
1850 n = (struct debug_named_type *) xmalloc (sizeof *n);
1851 memset (n, 0, sizeof *n);
1853 n->type = type;
1855 t->u.knamed = n;
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. */
1860 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1861 DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE);
1862 if (nm == NULL)
1863 return DEBUG_TYPE_NULL;
1865 nm->u.type = t;
1867 n->name = nm;
1869 return t;
1872 /* Tag a type. */
1874 debug_type
1875 debug_tag_type (void *handle, const char *name, debug_type type)
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;
1882 if (name == NULL || type == NULL)
1883 return DEBUG_TYPE_NULL;
1885 if (info->current_file == NULL)
1887 debug_error (_("debug_tag_type: no current file"));
1888 return DEBUG_TYPE_NULL;
1891 if (type->kind == DEBUG_KIND_TAGGED)
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;
1899 t = debug_make_type (info, DEBUG_KIND_TAGGED, 0);
1900 if (t == NULL)
1901 return DEBUG_TYPE_NULL;
1903 n = (struct debug_named_type *) xmalloc (sizeof *n);
1904 memset (n, 0, sizeof *n);
1906 n->type = type;
1908 t->u.knamed = n;
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. */
1913 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1914 DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE);
1915 if (nm == NULL)
1916 return DEBUG_TYPE_NULL;
1918 nm->u.tag = t;
1920 n->name = nm;
1922 return t;
1925 /* Record the size of a given type. */
1927 bfd_boolean
1928 debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type,
1929 unsigned int size)
1931 if (type->size != 0 && type->size != size)
1932 fprintf (stderr, _("Warning: changing type size from %d to %d\n"),
1933 type->size, size);
1935 type->size = size;
1937 return TRUE;
1940 /* Find a named type. */
1942 debug_type
1943 debug_find_named_type (void *handle, const char *name)
1945 struct debug_handle *info = (struct debug_handle *) handle;
1946 struct debug_block *b;
1947 struct debug_file *f;
1949 /* We only search the current compilation unit. I don't know if
1950 this is right or not. */
1952 if (info->current_unit == NULL)
1954 debug_error (_("debug_find_named_type: no current compilation unit"));
1955 return DEBUG_TYPE_NULL;
1958 for (b = info->current_block; b != NULL; b = b->parent)
1960 if (b->locals != NULL)
1962 struct debug_name *n;
1964 for (n = b->locals->list; n != NULL; n = n->next)
1966 if (n->kind == DEBUG_OBJECT_TYPE
1967 && n->name[0] == name[0]
1968 && strcmp (n->name, name) == 0)
1969 return n->u.type;
1974 for (f = info->current_unit->files; f != NULL; f = f->next)
1976 if (f->globals != NULL)
1978 struct debug_name *n;
1980 for (n = f->globals->list; n != NULL; n = n->next)
1982 if (n->kind == DEBUG_OBJECT_TYPE
1983 && n->name[0] == name[0]
1984 && strcmp (n->name, name) == 0)
1985 return n->u.type;
1990 return DEBUG_TYPE_NULL;
1993 /* Find a tagged type. */
1995 debug_type
1996 debug_find_tagged_type (void *handle, const char *name,
1997 enum debug_type_kind kind)
1999 struct debug_handle *info = (struct debug_handle *) handle;
2000 struct debug_unit *u;
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. */
2005 for (u = info->units; u != NULL; u = u->next)
2007 struct debug_file *f;
2009 for (f = u->files; f != NULL; f = f->next)
2011 struct debug_name *n;
2013 if (f->globals != NULL)
2015 for (n = f->globals->list; n != NULL; n = n->next)
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;
2028 return DEBUG_TYPE_NULL;
2031 /* Get a base type. We build a linked list on the stack to avoid
2032 crashing if the type is defined circularly. */
2034 static struct debug_type *
2035 debug_get_real_type (void *handle, debug_type type,
2036 struct debug_type_real_list *list)
2038 struct debug_type_real_list *l;
2039 struct debug_type_real_list rl;
2041 switch (type->kind)
2043 default:
2044 return type;
2046 case DEBUG_KIND_INDIRECT:
2047 case DEBUG_KIND_NAMED:
2048 case DEBUG_KIND_TAGGED:
2049 break;
2052 for (l = list; l != NULL; l = l->next)
2054 if (l->t == type || l == l->next)
2056 fprintf (stderr,
2057 _("debug_get_real_type: circular debug information for %s\n"),
2058 debug_get_type_name (handle, type));
2059 return NULL;
2063 rl.next = list;
2064 rl.t = type;
2066 switch (type->kind)
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);
2078 /*NOTREACHED*/
2081 /* Get the kind of a type. */
2083 enum debug_type_kind
2084 debug_get_type_kind (void *handle, debug_type type)
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;
2094 /* Get the name of a type. */
2096 const char *
2097 debug_get_type_name (void *handle, debug_type type)
2099 if (type->kind == DEBUG_KIND_INDIRECT)
2101 if (*type->u.kindirect->slot != NULL)
2102 return debug_get_type_name (handle, *type->u.kindirect->slot);
2103 return type->u.kindirect->tag;
2105 if (type->kind == DEBUG_KIND_NAMED
2106 || type->kind == DEBUG_KIND_TAGGED)
2107 return type->u.knamed->name->name;
2108 return NULL;
2111 /* Get the size of a type. */
2113 bfd_vma
2114 debug_get_type_size (void *handle, debug_type type)
2116 if (type == NULL)
2117 return 0;
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. */
2122 if (type->size != 0)
2123 return type->size;
2125 switch (type->kind)
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);
2137 /*NOTREACHED*/
2140 /* Get the return type of a function or method type. */
2142 debug_type
2143 debug_get_return_type (void *handle, debug_type type)
2145 if (type == NULL)
2146 return DEBUG_TYPE_NULL;
2148 type = debug_get_real_type (handle, type, NULL);
2149 if (type == NULL)
2150 return DEBUG_TYPE_NULL;
2152 switch (type->kind)
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;
2161 /*NOTREACHED*/
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). */
2167 const debug_type *
2168 debug_get_parameter_types (void *handle, debug_type type,
2169 bfd_boolean *pvarargs)
2171 if (type == NULL)
2172 return NULL;
2174 type = debug_get_real_type (handle, type, NULL);
2175 if (type == NULL)
2176 return NULL;
2178 switch (type->kind)
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;
2189 /*NOTREACHED*/
2192 /* Get the target type of a type. */
2194 debug_type
2195 debug_get_target_type (void *handle, debug_type type)
2197 if (type == NULL)
2198 return NULL;
2200 type = debug_get_real_type (handle, type, NULL);
2201 if (type == NULL)
2202 return NULL;
2204 switch (type->kind)
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;
2217 /*NOTREACHED*/
2220 /* Get the NULL terminated array of fields for a struct, union, or
2221 class. */
2223 const debug_field *
2224 debug_get_fields (void *handle, debug_type type)
2226 if (type == NULL)
2227 return NULL;
2229 type = debug_get_real_type (handle, type, NULL);
2230 if (type == NULL)
2231 return NULL;
2233 switch (type->kind)
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;
2243 /*NOTREACHED*/
2246 /* Get the type of a field. */
2248 debug_type
2249 debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field)
2251 if (field == NULL)
2252 return NULL;
2253 return field->type;
2256 /* Get the name of a field. */
2258 const char *
2259 debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field)
2261 if (field == NULL)
2262 return NULL;
2263 return field->name;
2266 /* Get the bit position of a field. */
2268 bfd_vma
2269 debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field)
2271 if (field == NULL || field->static_member)
2272 return (bfd_vma) -1;
2273 return field->u.f.bitpos;
2276 /* Get the bit size of a field. */
2278 bfd_vma
2279 debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field)
2281 if (field == NULL || field->static_member)
2282 return (bfd_vma) -1;
2283 return field->u.f.bitsize;
2286 /* Get the visibility of a field. */
2288 enum debug_visibility
2289 debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field)
2291 if (field == NULL)
2292 return DEBUG_VISIBILITY_IGNORE;
2293 return field->visibility;
2296 /* Get the physical name of a field. */
2298 const char *
2299 debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field)
2301 if (field == NULL || ! field->static_member)
2302 return NULL;
2303 return field->u.s.physname;
2306 /* Write out the debugging information. This is given a handle to
2307 debugging information, and a set of function pointers to call. */
2309 bfd_boolean
2310 debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle)
2312 struct debug_handle *info = (struct debug_handle *) handle;
2313 struct debug_unit *u;
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;
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;
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;
2330 for (u = info->units; u != NULL; u = u->next)
2332 struct debug_file *f;
2333 bfd_boolean first_file;
2335 info->current_write_lineno = u->linenos;
2336 info->current_write_lineno_index = 0;
2338 if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
2339 return FALSE;
2341 first_file = TRUE;
2342 for (f = u->files; f != NULL; f = f->next)
2344 struct debug_name *n;
2346 if (first_file)
2347 first_file = FALSE;
2348 else if (! (*fns->start_source) (fhandle, f->filename))
2349 return FALSE;
2351 if (f->globals != NULL)
2352 for (n = f->globals->list; n != NULL; n = n->next)
2353 if (! debug_write_name (info, fns, fhandle, n))
2354 return FALSE;
2357 /* Output any line number information which hasn't already been
2358 handled. */
2359 if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
2360 return FALSE;
2363 return TRUE;
2366 /* Write out an element in a namespace. */
2368 static bfd_boolean
2369 debug_write_name (struct debug_handle *info,
2370 const struct debug_write_fns *fns, void *fhandle,
2371 struct debug_name *n)
2373 switch (n->kind)
2375 case DEBUG_OBJECT_TYPE:
2376 if (! debug_write_type (info, fns, fhandle, n->u.type, n)
2377 || ! (*fns->typdef) (fhandle, n->name))
2378 return FALSE;
2379 return TRUE;
2380 case DEBUG_OBJECT_TAG:
2381 if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
2382 return FALSE;
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))
2387 return FALSE;
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))
2400 return FALSE;
2401 return (*fns->typed_constant) (fhandle, n->name,
2402 n->u.typed_constant->val);
2403 default:
2404 abort ();
2405 return FALSE;
2407 /*NOTREACHED*/
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. */
2416 static bfd_boolean
2417 debug_write_type (struct debug_handle *info,
2418 const struct debug_write_fns *fns, void *fhandle,
2419 struct debug_type *type, struct debug_name *name)
2421 unsigned int i;
2422 int is;
2423 const char *tag = NULL;
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)))
2434 if (type->kind == DEBUG_KIND_NAMED)
2435 return (*fns->typedef_type) (fhandle, type->u.knamed->name->name);
2436 else
2438 struct debug_type *real;
2439 unsigned int id;
2441 real = debug_get_real_type ((void *) info, type, NULL);
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)
2451 if (real->u.kclass->id <= info->base_id)
2453 if (! debug_set_class_id (info,
2454 type->u.knamed->name->name,
2455 real))
2456 return FALSE;
2458 id = real->u.kclass->id;
2461 return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id,
2462 real->kind);
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;
2473 if (name != NULL
2474 && type->kind != DEBUG_KIND_NAMED
2475 && type->kind != DEBUG_KIND_TAGGED)
2477 assert (name->kind == DEBUG_OBJECT_TAG);
2478 tag = name->name;
2481 switch (type->kind)
2483 case DEBUG_KIND_ILLEGAL:
2484 debug_error (_("debug_write_type: illegal type encountered"));
2485 return FALSE;
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)
2505 if (type->u.kclass->id <= info->base_id)
2507 if (! debug_set_class_id (info, tag, type))
2508 return FALSE;
2511 if (info->mark == type->u.kclass->mark)
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);
2520 type->u.kclass->mark = info->mark;
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))
2529 return FALSE;
2530 if (type->u.kclass != NULL
2531 && type->u.kclass->fields != NULL)
2533 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2535 struct debug_field *f;
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))
2542 return FALSE;
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))
2558 return FALSE;
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))
2564 return FALSE;
2565 if (type->u.kfunction->arg_types == NULL)
2566 is = -1;
2567 else
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))
2573 return FALSE;
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))
2580 return FALSE;
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))
2585 return FALSE;
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))
2594 return FALSE;
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))
2601 return FALSE;
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))
2609 return FALSE;
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))
2615 return FALSE;
2616 if (type->u.kmethod->arg_types == NULL)
2617 is = -1;
2618 else
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))
2624 return FALSE;
2626 if (type->u.kmethod->domain_type != NULL)
2628 if (! debug_write_type (info, fns, fhandle,
2629 type->u.kmethod->domain_type,
2630 (struct debug_name *) NULL))
2631 return FALSE;
2633 return (*fns->method_type) (fhandle,
2634 type->u.kmethod->domain_type != NULL,
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))
2640 return FALSE;
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))
2645 return FALSE;
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 ();
2655 return FALSE;
2659 /* Write out a class type. */
2661 static bfd_boolean
2662 debug_write_class_type (struct debug_handle *info,
2663 const struct debug_write_fns *fns, void *fhandle,
2664 struct debug_type *type, const char *tag)
2666 unsigned int i;
2667 unsigned int id;
2668 struct debug_type *vptrbase;
2670 if (type->u.kclass == NULL)
2672 id = 0;
2673 vptrbase = NULL;
2675 else
2677 if (type->u.kclass->id <= info->base_id)
2679 if (! debug_set_class_id (info, tag, type))
2680 return FALSE;
2683 if (info->mark == type->u.kclass->mark)
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);
2692 type->u.kclass->mark = info->mark;
2693 id = type->u.kclass->id;
2695 vptrbase = type->u.kclass->vptrbase;
2696 if (vptrbase != NULL && vptrbase != type)
2698 if (! debug_write_type (info, fns, fhandle, vptrbase,
2699 (struct debug_name *) NULL))
2700 return FALSE;
2704 if (! (*fns->start_class_type) (fhandle, tag, id,
2705 type->kind == DEBUG_KIND_CLASS,
2706 type->size,
2707 vptrbase != NULL,
2708 vptrbase == type))
2709 return FALSE;
2711 if (type->u.kclass != NULL)
2713 if (type->u.kclass->fields != NULL)
2715 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2717 struct debug_field *f;
2719 f = type->u.kclass->fields[i];
2720 if (! debug_write_type (info, fns, fhandle, f->type,
2721 (struct debug_name *) NULL))
2722 return FALSE;
2723 if (f->static_member)
2725 if (! (*fns->class_static_member) (fhandle, f->name,
2726 f->u.s.physname,
2727 f->visibility))
2728 return FALSE;
2730 else
2732 if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2733 f->u.f.bitsize, f->visibility))
2734 return FALSE;
2739 if (type->u.kclass->baseclasses != NULL)
2741 for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++)
2743 struct debug_baseclass *b;
2745 b = type->u.kclass->baseclasses[i];
2746 if (! debug_write_type (info, fns, fhandle, b->type,
2747 (struct debug_name *) NULL))
2748 return FALSE;
2749 if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->virtual,
2750 b->visibility))
2751 return FALSE;
2755 if (type->u.kclass->methods != NULL)
2757 for (i = 0; type->u.kclass->methods[i] != NULL; i++)
2759 struct debug_method *m;
2760 unsigned int j;
2762 m = type->u.kclass->methods[i];
2763 if (! (*fns->class_start_method) (fhandle, m->name))
2764 return FALSE;
2765 for (j = 0; m->variants[j] != NULL; j++)
2767 struct debug_method_variant *v;
2769 v = m->variants[j];
2770 if (v->context != NULL)
2772 if (! debug_write_type (info, fns, fhandle, v->context,
2773 (struct debug_name *) NULL))
2774 return FALSE;
2776 if (! debug_write_type (info, fns, fhandle, v->type,
2777 (struct debug_name *) NULL))
2778 return FALSE;
2779 if (v->voffset != VOFFSET_STATIC_METHOD)
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))
2787 return FALSE;
2789 else
2791 if (! (*fns->class_static_method_variant) (fhandle,
2792 v->physname,
2793 v->visibility,
2794 v->constp,
2795 v->volatilep))
2796 return FALSE;
2799 if (! (*fns->class_end_method) (fhandle))
2800 return FALSE;
2805 return (*fns->end_class_type) (fhandle);
2808 /* Write out information for a function. */
2810 static bfd_boolean
2811 debug_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)
2816 struct debug_parameter *p;
2817 struct debug_block *b;
2819 if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
2820 return FALSE;
2822 if (! debug_write_type (info, fns, fhandle, function->return_type,
2823 (struct debug_name *) NULL))
2824 return FALSE;
2826 if (! (*fns->start_function) (fhandle, name,
2827 linkage == DEBUG_LINKAGE_GLOBAL))
2828 return FALSE;
2830 for (p = function->parameters; p != NULL; p = p->next)
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))
2835 return FALSE;
2838 for (b = function->blocks; b != NULL; b = b->next)
2840 if (! debug_write_block (info, fns, fhandle, b))
2841 return FALSE;
2844 return (*fns->end_function) (fhandle);
2847 /* Write out information for a block. */
2849 static bfd_boolean
2850 debug_write_block (struct debug_handle *info,
2851 const struct debug_write_fns *fns, void *fhandle,
2852 struct debug_block *block)
2854 struct debug_name *n;
2855 struct debug_block *b;
2857 if (! debug_write_linenos (info, fns, fhandle, block->start))
2858 return FALSE;
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)
2864 if (! (*fns->start_block) (fhandle, block->start))
2865 return FALSE;
2868 if (block->locals != NULL)
2870 for (n = block->locals->list; n != NULL; n = n->next)
2872 if (! debug_write_name (info, fns, fhandle, n))
2873 return FALSE;
2877 for (b = block->children; b != NULL; b = b->next)
2879 if (! debug_write_block (info, fns, fhandle, b))
2880 return FALSE;
2883 if (! debug_write_linenos (info, fns, fhandle, block->end))
2884 return FALSE;
2886 if (block->locals != NULL || block->parent == NULL)
2888 if (! (*fns->end_block) (fhandle, block->end))
2889 return FALSE;
2892 return TRUE;
2895 /* Write out line number information up to ADDRESS. */
2897 static bfd_boolean
2898 debug_write_linenos (struct debug_handle *info,
2899 const struct debug_write_fns *fns, void *fhandle,
2900 bfd_vma address)
2902 while (info->current_write_lineno != NULL)
2904 struct debug_lineno *l;
2906 l = info->current_write_lineno;
2908 while (info->current_write_lineno_index < DEBUG_LINENO_COUNT)
2910 if (l->linenos[info->current_write_lineno_index]
2911 == (unsigned long) -1)
2912 break;
2914 if (l->addrs[info->current_write_lineno_index] >= address)
2915 return TRUE;
2917 if (! (*fns->lineno) (fhandle, l->file->filename,
2918 l->linenos[info->current_write_lineno_index],
2919 l->addrs[info->current_write_lineno_index]))
2920 return FALSE;
2922 ++info->current_write_lineno_index;
2925 info->current_write_lineno = l->next;
2926 info->current_write_lineno_index = 0;
2929 return TRUE;
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. */
2937 static bfd_boolean
2938 debug_set_class_id (struct debug_handle *info, const char *tag,
2939 struct debug_type *type)
2941 struct debug_class_type *c;
2942 struct debug_class_id *l;
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);
2949 c = type->u.kclass;
2951 if (c->id > info->base_id)
2952 return TRUE;
2954 for (l = info->id_list; l != NULL; l = l->next)
2956 if (l->type->kind != type->kind)
2957 continue;
2959 if (tag == NULL)
2961 if (l->tag != NULL)
2962 continue;
2964 else
2966 if (l->tag == NULL
2967 || l->tag[0] != tag[0]
2968 || strcmp (l->tag, tag) != 0)
2969 continue;
2972 if (debug_type_samep (info, l->type, type))
2974 c->id = l->type->u.kclass->id;
2975 return TRUE;
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;
2984 l = (struct debug_class_id *) xmalloc (sizeof *l);
2985 memset (l, 0, sizeof *l);
2987 l->type = type;
2988 l->tag = tag;
2990 l->next = info->id_list;
2991 info->id_list = l;
2993 return TRUE;
2996 /* See if two types are the same. At this point, we don't care about
2997 tags and the like. */
2999 static bfd_boolean
3000 debug_type_samep (struct debug_handle *info, struct debug_type *t1,
3001 struct debug_type *t2)
3003 struct debug_type_compare_list *l;
3004 struct debug_type_compare_list top;
3005 bfd_boolean ret;
3007 if (t1 == NULL)
3008 return t2 == NULL;
3009 if (t2 == NULL)
3010 return FALSE;
3012 while (t1->kind == DEBUG_KIND_INDIRECT)
3014 t1 = *t1->u.kindirect->slot;
3015 if (t1 == NULL)
3016 return FALSE;
3018 while (t2->kind == DEBUG_KIND_INDIRECT)
3020 t2 = *t2->u.kindirect->slot;
3021 if (t2 == NULL)
3022 return FALSE;
3025 if (t1 == t2)
3026 return TRUE;
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);
3038 if (t1->kind != t2->kind
3039 || t1->size != t2->size)
3040 return FALSE;
3042 /* Get rid of the trivial cases first. */
3043 switch (t1->kind)
3045 default:
3046 break;
3047 case DEBUG_KIND_VOID:
3048 case DEBUG_KIND_FLOAT:
3049 case DEBUG_KIND_COMPLEX:
3050 case DEBUG_KIND_BOOL:
3051 return TRUE;
3052 case DEBUG_KIND_INT:
3053 return t1->u.kint == t2->u.kint;
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)
3062 if (l->t1 == t1 && l->t2 == t2)
3063 return TRUE;
3066 top.t1 = t1;
3067 top.t2 = t2;
3068 top.next = info->compare_list;
3069 info->compare_list = &top;
3071 switch (t1->kind)
3073 default:
3074 abort ();
3075 ret = FALSE;
3076 break;
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)
3085 ret = FALSE;
3086 else if (t1->u.kclass->id > info->base_id
3087 && t1->u.kclass->id == t2->u.kclass->id)
3088 ret = TRUE;
3089 else
3090 ret = debug_class_type_samep (info, t1, t2);
3091 break;
3093 case DEBUG_KIND_ENUM:
3094 if (t1->u.kenum == NULL)
3095 ret = t2->u.kenum == NULL;
3096 else if (t2->u.kenum == NULL)
3097 ret = FALSE;
3098 else
3100 const char **pn1, **pn2;
3101 bfd_signed_vma *pv1, *pv2;
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)
3109 if (**pn1 != **pn2
3110 || *pv1 != *pv2
3111 || strcmp (*pn1, *pn2) != 0)
3112 break;
3113 ++pn1;
3114 ++pn2;
3115 ++pv1;
3116 ++pv2;
3118 ret = *pn1 == NULL && *pn2 == NULL;
3120 break;
3122 case DEBUG_KIND_POINTER:
3123 ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);
3124 break;
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)))
3132 ret = FALSE;
3133 else if (t1->u.kfunction->arg_types == NULL)
3134 ret = TRUE;
3135 else
3137 struct debug_type **a1, **a2;
3139 a1 = t1->u.kfunction->arg_types;
3140 a2 = t2->u.kfunction->arg_types;
3141 while (*a1 != NULL && *a2 != NULL)
3143 if (! debug_type_samep (info, *a1, *a2))
3144 break;
3145 ++a1;
3146 ++a2;
3148 ret = *a1 == NULL && *a2 == NULL;
3150 break;
3152 case DEBUG_KIND_REFERENCE:
3153 ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);
3154 break;
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));
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;
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;
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;
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)))
3190 ret = FALSE;
3191 else if (t1->u.kmethod->arg_types == NULL)
3192 ret = TRUE;
3193 else
3195 struct debug_type **a1, **a2;
3197 a1 = t1->u.kmethod->arg_types;
3198 a2 = t2->u.kmethod->arg_types;
3199 while (*a1 != NULL && *a2 != NULL)
3201 if (! debug_type_samep (info, *a1, *a2))
3202 break;
3203 ++a1;
3204 ++a2;
3206 ret = *a1 == NULL && *a2 == NULL;
3208 break;
3210 case DEBUG_KIND_CONST:
3211 ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);
3212 break;
3214 case DEBUG_KIND_VOLATILE:
3215 ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);
3216 break;
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;
3226 info->compare_list = top.next;
3228 return ret;
3231 /* See if two classes are the same. This is a subroutine of
3232 debug_type_samep. */
3234 static bfd_boolean
3235 debug_class_type_samep (struct debug_handle *info, struct debug_type *t1,
3236 struct debug_type *t2)
3238 struct debug_class_type *c1, *c2;
3240 c1 = t1->u.kclass;
3241 c2 = t2->u.kclass;
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))
3247 return FALSE;
3249 if (c1->fields != NULL)
3251 struct debug_field **pf1, **pf2;
3253 for (pf1 = c1->fields, pf2 = c2->fields;
3254 *pf1 != NULL && *pf2 != NULL;
3255 pf1++, pf2++)
3257 struct debug_field *f1, *f2;
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)
3264 return FALSE;
3265 if (f1->static_member)
3267 if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
3268 return FALSE;
3270 else
3272 if (f1->u.f.bitpos != f2->u.f.bitpos
3273 || f1->u.f.bitsize != f2->u.f.bitsize)
3274 return FALSE;
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,
3282 debug_get_real_type ((void *) info,
3283 f1->type, NULL),
3284 debug_get_real_type ((void *) info,
3285 f2->type, NULL)))
3286 return FALSE;
3288 if (*pf1 != NULL || *pf2 != NULL)
3289 return FALSE;
3292 if (c1->vptrbase != NULL)
3294 if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
3295 return FALSE;
3298 if (c1->baseclasses != NULL)
3300 struct debug_baseclass **pb1, **pb2;
3302 for (pb1 = c1->baseclasses, pb2 = c2->baseclasses;
3303 *pb1 != NULL && *pb2 != NULL;
3304 ++pb1, ++pb2)
3306 struct debug_baseclass *b1, *b2;
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))
3314 return FALSE;
3316 if (*pb1 != NULL || *pb2 != NULL)
3317 return FALSE;
3320 if (c1->methods != NULL)
3322 struct debug_method **pm1, **pm2;
3324 for (pm1 = c1->methods, pm2 = c2->methods;
3325 *pm1 != NULL && *pm2 != NULL;
3326 ++pm1, ++pm2)
3328 struct debug_method *m1, *m2;
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))
3335 return FALSE;
3336 if (m1->variants == NULL)
3338 struct debug_method_variant **pv1, **pv2;
3340 for (pv1 = m1->variants, pv2 = m2->variants;
3341 *pv1 != NULL && *pv2 != NULL;
3342 ++pv1, ++pv2)
3344 struct debug_method_variant *v1, *v2;
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))
3356 return FALSE;
3357 if (v1->context != NULL)
3359 if (! debug_type_samep (info, v1->context,
3360 v2->context))
3361 return FALSE;
3364 if (*pv1 != NULL || *pv2 != NULL)
3365 return FALSE;
3368 if (*pm1 != NULL || *pm2 != NULL)
3369 return FALSE;
3372 return TRUE;