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