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