projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2002-12-06 Andrew Cagney <ac131313@redhat.com>
[deliverable/binutils-gdb.git] / binutils / debug.c
CommitLineData
252b5132 1/* debug.c -- Handle generic debugging information.
3a1a2036 2 Copyright 1995, 1996, 1997, 1998, 2000, 2002 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)
1194 {
1195 debug_error (_("debug_record_variable: no current block"));
b34976b6 1196 return FALSE;
252b5132
RH		 1197 }
1198 nsp = &info->current_block->locals;
1199 linkage = DEBUG_LINKAGE_AUTOMATIC;
1200 }
1201
1202 n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
1203 if (n == NULL)
b34976b6 1204 return FALSE;
252b5132
RH		 1205
1206 v = (struct debug_variable *) xmalloc (sizeof *v);
1207 memset (v, 0, sizeof *v);
1208
1209 v->kind = kind;
1210 v->type = type;
1211 v->val = val;
1212
1213 n->u.variable = v;
1214
b34976b6 1215 return TRUE;
252b5132
RH		 1216}
1217
1218/* Make a type with a given kind and size. */
1219
252b5132
RH		 1220static struct debug_type *
1221debug_make_type (info, kind, size)
b4c96d0d 1222 struct debug_handle *info ATTRIBUTE_UNUSED;
252b5132
RH		 1223 enum debug_type_kind kind;
1224 unsigned int size;
1225{
1226 struct debug_type *t;
1227
1228 t = (struct debug_type *) xmalloc (sizeof *t);
1229 memset (t, 0, sizeof *t);
1230
1231 t->kind = kind;
1232 t->size = size;
1233
1234 return t;
1235}
1236
1237/* Make an indirect type which may be used as a placeholder for a type
1238 which is referenced before it is defined. */
1239
1240debug_type
1241debug_make_indirect_type (handle, slot, tag)
1242 PTR handle;
1243 debug_type *slot;
1244 const char *tag;
1245{
1246 struct debug_handle *info = (struct debug_handle *) handle;
1247 struct debug_type *t;
1248 struct debug_indirect_type *i;
1249
1250 t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0);
1251 if (t == NULL)
1252 return DEBUG_TYPE_NULL;
1253
1254 i = (struct debug_indirect_type *) xmalloc (sizeof *i);
1255 memset (i, 0, sizeof *i);
1256
1257 i->slot = slot;
1258 i->tag = tag;
1259
1260 t->u.kindirect = i;
1261
1262 return t;
1263}
1264
1265/* Make a void type. There is only one of these. */
1266
1267debug_type
1268debug_make_void_type (handle)
1269 PTR handle;
1270{
1271 struct debug_handle *info = (struct debug_handle *) handle;
1272
1273 return debug_make_type (info, DEBUG_KIND_VOID, 0);
1274}
1275
1276/* Make an integer type of a given size. The boolean argument is true
1277 if the integer is unsigned. */
1278
1279debug_type
1280debug_make_int_type (handle, size, unsignedp)
1281 PTR handle;
1282 unsigned int size;
b34976b6 1283 bfd_boolean unsignedp;
252b5132
RH		 1284{
1285 struct debug_handle *info = (struct debug_handle *) handle;
1286 struct debug_type *t;
1287
1288 t = debug_make_type (info, DEBUG_KIND_INT, size);
1289 if (t == NULL)
1290 return DEBUG_TYPE_NULL;
1291
1292 t->u.kint = unsignedp;
1293
1294 return t;
1295}
1296
1297/* Make a floating point type of a given size. FIXME: On some
1298 platforms, like an Alpha, you probably need to be able to specify
1299 the format. */
1300
1301debug_type
1302debug_make_float_type (handle, size)
1303 PTR handle;
1304 unsigned int size;
1305{
1306 struct debug_handle *info = (struct debug_handle *) handle;
1307
1308 return debug_make_type (info, DEBUG_KIND_FLOAT, size);
1309}
1310
1311/* Make a boolean type of a given size. */
1312
1313debug_type
1314debug_make_bool_type (handle, size)
1315 PTR handle;
1316 unsigned int size;
1317{
1318 struct debug_handle *info = (struct debug_handle *) handle;
1319
1320 return debug_make_type (info, DEBUG_KIND_BOOL, size);
1321}
1322
1323/* Make a complex type of a given size. */
1324
1325debug_type
1326debug_make_complex_type (handle, size)
1327 PTR handle;
1328 unsigned int size;
1329{
1330 struct debug_handle *info = (struct debug_handle *) handle;
1331
1332 return debug_make_type (info, DEBUG_KIND_COMPLEX, size);
1333}
1334
1335/* Make a structure type. The second argument is true for a struct,
1336 false for a union. The third argument is the size of the struct.
1337 The fourth argument is a NULL terminated array of fields. */
1338
1339debug_type
1340debug_make_struct_type (handle, structp, size, fields)
1341 PTR handle;
b34976b6 1342 bfd_boolean structp;
252b5132
RH		 1343 bfd_vma size;
1344 debug_field *fields;
1345{
1346 struct debug_handle *info = (struct debug_handle *) handle;
1347 struct debug_type *t;
1348 struct debug_class_type *c;
1349
1350 t = debug_make_type (info,
1351 structp ? DEBUG_KIND_STRUCT : DEBUG_KIND_UNION,
1352 size);
1353 if (t == NULL)
1354 return DEBUG_TYPE_NULL;
1355
1356 c = (struct debug_class_type *) xmalloc (sizeof *c);
1357 memset (c, 0, sizeof *c);
1358
1359 c->fields = fields;
1360
1361 t->u.kclass = c;
1362
1363 return t;
1364}
1365
1366/* Make an object type. The first three arguments after the handle
1367 are the same as for debug_make_struct_type. The next arguments are
1368 a NULL terminated array of base classes, a NULL terminated array of
1369 methods, the type of the object holding the virtual function table
1370 if it is not this object, and a boolean which is true if this
1371 object has its own virtual function table. */
1372
1373debug_type
1374debug_make_object_type (handle, structp, size, fields, baseclasses,
1375 methods, vptrbase, ownvptr)
1376 PTR handle;
b34976b6 1377 bfd_boolean structp;
252b5132
RH		 1378 bfd_vma size;
1379 debug_field *fields;
1380 debug_baseclass *baseclasses;
1381 debug_method *methods;
1382 debug_type vptrbase;
b34976b6 1383 bfd_boolean ownvptr;
252b5132
RH		 1384{
1385 struct debug_handle *info = (struct debug_handle *) handle;
1386 struct debug_type *t;
1387 struct debug_class_type *c;
1388
1389 t = debug_make_type (info,
1390 structp ? DEBUG_KIND_CLASS : DEBUG_KIND_UNION_CLASS,
1391 size);
1392 if (t == NULL)
1393 return DEBUG_TYPE_NULL;
1394
1395 c = (struct debug_class_type *) xmalloc (sizeof *c);
1396 memset (c, 0, sizeof *c);
1397
1398 c->fields = fields;
1399 c->baseclasses = baseclasses;
1400 c->methods = methods;
1401 if (ownvptr)
1402 c->vptrbase = t;
1403 else
1404 c->vptrbase = vptrbase;
1405
1406 t->u.kclass = c;
1407
1408 return t;
1409}
1410
1411/* Make an enumeration type. The arguments are a null terminated
1412 array of strings, and an array of corresponding values. */
1413
1414debug_type
1415debug_make_enum_type (handle, names, values)
1416 PTR handle;
1417 const char **names;
1418 bfd_signed_vma *values;
1419{
1420 struct debug_handle *info = (struct debug_handle *) handle;
1421 struct debug_type *t;
1422 struct debug_enum_type *e;
1423
1424 t = debug_make_type (info, DEBUG_KIND_ENUM, 0);
1425 if (t == NULL)
1426 return DEBUG_TYPE_NULL;
1427
1428 e = (struct debug_enum_type *) xmalloc (sizeof *e);
1429 memset (e, 0, sizeof *e);
1430
1431 e->names = names;
1432 e->values = values;
1433
1434 t->u.kenum = e;
1435
1436 return t;
1437}
1438
1439/* Make a pointer to a given type. */
1440
1441debug_type
1442debug_make_pointer_type (handle, type)
1443 PTR handle;
1444 debug_type type;
1445{
1446 struct debug_handle *info = (struct debug_handle *) handle;
1447 struct debug_type *t;
1448
1449 if (type == NULL)
1450 return DEBUG_TYPE_NULL;
1451
1452 if (type->pointer != DEBUG_TYPE_NULL)
1453 return type->pointer;
1454
1455 t = debug_make_type (info, DEBUG_KIND_POINTER, 0);
1456 if (t == NULL)
1457 return DEBUG_TYPE_NULL;
1458
1459 t->u.kpointer = type;
1460
1461 type->pointer = t;
1462
1463 return t;
1464}
1465
1466/* Make a function returning a given type. FIXME: We should be able
1467 to record the parameter types. */
1468
1469debug_type
1470debug_make_function_type (handle, type, arg_types, varargs)
1471 PTR handle;
1472 debug_type type;
1473 debug_type *arg_types;
b34976b6 1474 bfd_boolean varargs;
252b5132
RH		 1475{
1476 struct debug_handle *info = (struct debug_handle *) handle;
1477 struct debug_type *t;
1478 struct debug_function_type *f;
1479
1480 if (type == NULL)
1481 return DEBUG_TYPE_NULL;
1482
1483 t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0);
1484 if (t == NULL)
1485 return DEBUG_TYPE_NULL;
1486
1487 f = (struct debug_function_type *) xmalloc (sizeof *f);
1488 memset (f, 0, sizeof *f);
1489
1490 f->return_type = type;
1491 f->arg_types = arg_types;
1492 f->varargs = varargs;
1493
1494 t->u.kfunction = f;
1495
1496 return t;
1497}
1498
1499/* Make a reference to a given type. */
1500
1501debug_type
1502debug_make_reference_type (handle, type)
1503 PTR handle;
1504 debug_type type;
1505{
1506 struct debug_handle *info = (struct debug_handle *) handle;
1507 struct debug_type *t;
1508
1509 if (type == NULL)
1510 return DEBUG_TYPE_NULL;
1511
1512 t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0);
1513 if (t == NULL)
1514 return DEBUG_TYPE_NULL;
1515
1516 t->u.kreference = type;
1517
1518 return t;
1519}
1520
1521/* Make a range of a given type from a lower to an upper bound. */
1522
1523debug_type
1524debug_make_range_type (handle, type, lower, upper)
1525 PTR handle;
1526 debug_type type;
1527 bfd_signed_vma lower;
1528 bfd_signed_vma upper;
1529{
1530 struct debug_handle *info = (struct debug_handle *) handle;
1531 struct debug_type *t;
1532 struct debug_range_type *r;
1533
1534 if (type == NULL)
1535 return DEBUG_TYPE_NULL;
1536
1537 t = debug_make_type (info, DEBUG_KIND_RANGE, 0);
1538 if (t == NULL)
1539 return DEBUG_TYPE_NULL;
1540
1541 r = (struct debug_range_type *) xmalloc (sizeof *r);
1542 memset (r, 0, sizeof *r);
1543
1544 r->type = type;
1545 r->lower = lower;
1546 r->upper = upper;
1547
1548 t->u.krange = r;
1549
1550 return t;
1551}
1552
1553/* Make an array type. The second argument is the type of an element
1554 of the array. The third argument is the type of a range of the
1555 array. The fourth and fifth argument are the lower and upper
1556 bounds, respectively. The sixth argument is true if this array is
1557 actually a string, as in C. */
1558
1559debug_type
1560debug_make_array_type (handle, element_type, range_type, lower, upper,
1561 stringp)
1562 PTR handle;
1563 debug_type element_type;
1564 debug_type range_type;
1565 bfd_signed_vma lower;
1566 bfd_signed_vma upper;
b34976b6 1567 bfd_boolean stringp;
252b5132
RH		 1568{
1569 struct debug_handle *info = (struct debug_handle *) handle;
1570 struct debug_type *t;
1571 struct debug_array_type *a;
1572
1573 if (element_type == NULL || range_type == NULL)
1574 return DEBUG_TYPE_NULL;
1575
1576 t = debug_make_type (info, DEBUG_KIND_ARRAY, 0);
1577 if (t == NULL)
1578 return DEBUG_TYPE_NULL;
1579
1580 a = (struct debug_array_type *) xmalloc (sizeof *a);
1581 memset (a, 0, sizeof *a);
1582
1583 a->element_type = element_type;
1584 a->range_type = range_type;
1585 a->lower = lower;
1586 a->upper = upper;
1587 a->stringp = stringp;
1588
1589 t->u.karray = a;
1590
1591 return t;
1592}
1593
1594/* Make a set of a given type. For example, a Pascal set type. The
1595 boolean argument is true if this set is actually a bitstring, as in
1596 CHILL. */
1597
1598debug_type
1599debug_make_set_type (handle, type, bitstringp)
1600 PTR handle;
1601 debug_type type;
b34976b6 1602 bfd_boolean bitstringp;
252b5132
RH		 1603{
1604 struct debug_handle *info = (struct debug_handle *) handle;
1605 struct debug_type *t;
1606 struct debug_set_type *s;
1607
1608 if (type == NULL)
1609 return DEBUG_TYPE_NULL;
1610
1611 t = debug_make_type (info, DEBUG_KIND_SET, 0);
1612 if (t == NULL)
1613 return DEBUG_TYPE_NULL;
1614
1615 s = (struct debug_set_type *) xmalloc (sizeof *s);
1616 memset (s, 0, sizeof *s);
1617
1618 s->type = type;
1619 s->bitstringp = bitstringp;
1620
1621 t->u.kset = s;
1622
1623 return t;
1624}
1625
1626/* Make a type for a pointer which is relative to an object. The
1627 second argument is the type of the object to which the pointer is
1628 relative. The third argument is the type that the pointer points
1629 to. */
1630
1631debug_type
1632debug_make_offset_type (handle, base_type, target_type)
1633 PTR handle;
1634 debug_type base_type;
1635 debug_type target_type;
1636{
1637 struct debug_handle *info = (struct debug_handle *) handle;
1638 struct debug_type *t;
1639 struct debug_offset_type *o;
1640
1641 if (base_type == NULL || target_type == NULL)
1642 return DEBUG_TYPE_NULL;
1643
1644 t = debug_make_type (info, DEBUG_KIND_OFFSET, 0);
1645 if (t == NULL)
1646 return DEBUG_TYPE_NULL;
1647
1648 o = (struct debug_offset_type *) xmalloc (sizeof *o);
1649 memset (o, 0, sizeof *o);
1650
1651 o->base_type = base_type;
1652 o->target_type = target_type;
1653
1654 t->u.koffset = o;
1655
1656 return t;
1657}
1658
1659/* Make a type for a method function. The second argument is the
1660 return type, the third argument is the domain, and the fourth
1661 argument is a NULL terminated array of argument types. */
1662
1663debug_type
1664debug_make_method_type (handle, return_type, domain_type, arg_types, varargs)
1665 PTR handle;
1666 debug_type return_type;
1667 debug_type domain_type;
1668 debug_type *arg_types;
b34976b6 1669 bfd_boolean varargs;
252b5132
RH		 1670{
1671 struct debug_handle *info = (struct debug_handle *) handle;
1672 struct debug_type *t;
1673 struct debug_method_type *m;
1674
1675 if (return_type == NULL)
1676 return DEBUG_TYPE_NULL;
1677
1678 t = debug_make_type (info, DEBUG_KIND_METHOD, 0);
1679 if (t == NULL)
1680 return DEBUG_TYPE_NULL;
1681
1682 m = (struct debug_method_type *) xmalloc (sizeof *m);
1683 memset (m, 0, sizeof *m);
1684
1685 m->return_type = return_type;
1686 m->domain_type = domain_type;
1687 m->arg_types = arg_types;
1688 m->varargs = varargs;
1689
1690 t->u.kmethod = m;
1691
1692 return t;
1693}
1694
1695/* Make a const qualified version of a given type. */
1696
1697debug_type
1698debug_make_const_type (handle, type)
1699 PTR handle;
1700 debug_type type;
1701{
1702 struct debug_handle *info = (struct debug_handle *) handle;
1703 struct debug_type *t;
1704
1705 if (type == NULL)
1706 return DEBUG_TYPE_NULL;
1707
1708 t = debug_make_type (info, DEBUG_KIND_CONST, 0);
1709 if (t == NULL)
1710 return DEBUG_TYPE_NULL;
1711
1712 t->u.kconst = type;
1713
1714 return t;
1715}
1716
1717/* Make a volatile qualified version of a given type. */
1718
1719debug_type
1720debug_make_volatile_type (handle, type)
1721 PTR handle;
1722 debug_type type;
1723{
1724 struct debug_handle *info = (struct debug_handle *) handle;
1725 struct debug_type *t;
1726
1727 if (type == NULL)
1728 return DEBUG_TYPE_NULL;
1729
1730 t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0);
1731 if (t == NULL)
1732 return DEBUG_TYPE_NULL;
1733
1734 t->u.kvolatile = type;
1735
1736 return t;
1737}
1738
1739/* Make an undefined tagged type. For example, a struct which has
1740 been mentioned, but not defined. */
1741
1742debug_type
1743debug_make_undefined_tagged_type (handle, name, kind)
1744 PTR handle;
1745 const char *name;
1746 enum debug_type_kind kind;
1747{
1748 struct debug_handle *info = (struct debug_handle *) handle;
1749 struct debug_type *t;
1750
1751 if (name == NULL)
1752 return DEBUG_TYPE_NULL;
1753
1754 switch (kind)
1755 {
1756 case DEBUG_KIND_STRUCT:
1757 case DEBUG_KIND_UNION:
1758 case DEBUG_KIND_CLASS:
1759 case DEBUG_KIND_UNION_CLASS:
1760 case DEBUG_KIND_ENUM:
1761 break;
1762
1763 default:
1764 debug_error (_("debug_make_undefined_type: unsupported kind"));
1765 return DEBUG_TYPE_NULL;
1766 }
1767
1768 t = debug_make_type (info, kind, 0);
1769 if (t == NULL)
1770 return DEBUG_TYPE_NULL;
1771
1772 return debug_tag_type (handle, name, t);
1773}
1774
1775/* Make a base class for an object. The second argument is the base
1776 class type. The third argument is the bit position of this base
1777 class in the object (always 0 unless doing multiple inheritance).
1778 The fourth argument is whether this is a virtual class. The fifth
1779 argument is the visibility of the base class. */
1780
252b5132
RH		 1781debug_baseclass
1782debug_make_baseclass (handle, type, bitpos, virtual, visibility)
b4c96d0d 1783 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1784 debug_type type;
1785 bfd_vma bitpos;
b34976b6 1786 bfd_boolean virtual;
252b5132 1787 enum debug_visibility visibility;
26044998 1788{
252b5132
RH		 1789 struct debug_baseclass *b;
1790
1791 b = (struct debug_baseclass *) xmalloc (sizeof *b);
1792 memset (b, 0, sizeof *b);
1793
1794 b->type = type;
1795 b->bitpos = bitpos;
1796 b->virtual = virtual;
1797 b->visibility = visibility;
1798
1799 return b;
1800}
1801
1802/* Make a field for a struct. The second argument is the name. The
1803 third argument is the type of the field. The fourth argument is
1804 the bit position of the field. The fifth argument is the size of
1805 the field (it may be zero). The sixth argument is the visibility
1806 of the field. */
1807
252b5132
RH		 1808debug_field
1809debug_make_field (handle, name, type, bitpos, bitsize, visibility)
b4c96d0d 1810 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1811 const char *name;
1812 debug_type type;
1813 bfd_vma bitpos;
1814 bfd_vma bitsize;
1815 enum debug_visibility visibility;
1816{
1817 struct debug_field *f;
1818
1819 f = (struct debug_field *) xmalloc (sizeof *f);
1820 memset (f, 0, sizeof *f);
1821
1822 f->name = name;
1823 f->type = type;
b34976b6 1824 f->static_member = FALSE;
252b5132
RH		 1825 f->u.f.bitpos = bitpos;
1826 f->u.f.bitsize = bitsize;
1827 f->visibility = visibility;
1828
1829 return f;
1830}
1831
1832/* Make a static member of an object. The second argument is the
1833 name. The third argument is the type of the member. The fourth
1834 argument is the physical name of the member (i.e., the name as a
1835 global variable). The fifth argument is the visibility of the
1836 member. */
1837
252b5132
RH		 1838debug_field
1839debug_make_static_member (handle, name, type, physname, visibility)
b4c96d0d 1840 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1841 const char *name;
1842 debug_type type;
1843 const char *physname;
1844 enum debug_visibility visibility;
1845{
1846 struct debug_field *f;
1847
1848 f = (struct debug_field *) xmalloc (sizeof *f);
1849 memset (f, 0, sizeof *f);
1850
1851 f->name = name;
1852 f->type = type;
b34976b6 1853 f->static_member = TRUE;
252b5132
RH		 1854 f->u.s.physname = physname;
1855 f->visibility = visibility;
1856
1857 return f;
1858}
1859
1860/* Make a method. The second argument is the name, and the third
1861 argument is a NULL terminated array of method variants. */
1862
252b5132
RH		 1863debug_method
1864debug_make_method (handle, name, variants)
b4c96d0d 1865 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1866 const char *name;
1867 debug_method_variant *variants;
1868{
1869 struct debug_method *m;
1870
1871 m = (struct debug_method *) xmalloc (sizeof *m);
1872 memset (m, 0, sizeof *m);
1873
1874 m->name = name;
1875 m->variants = variants;
1876
1877 return m;
1878}
1879
1880/* Make a method argument. The second argument is the real name of
1881 the function. The third argument is the type of the function. The
1882 fourth argument is the visibility. The fifth argument is whether
1883 this is a const function. The sixth argument is whether this is a
1884 volatile function. The seventh argument is the offset in the
1885 virtual function table, if any. The eighth argument is the virtual
1886 function context. FIXME: Are the const and volatile arguments
1887 necessary? Could we just use debug_make_const_type? */
1888
252b5132
RH		 1889debug_method_variant
1890debug_make_method_variant (handle, physname, type, visibility, constp,
1891 volatilep, voffset, context)
b4c96d0d 1892 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1893 const char *physname;
1894 debug_type type;
1895 enum debug_visibility visibility;
b34976b6
AM		 1896 bfd_boolean constp;
1897 bfd_boolean volatilep;
252b5132
RH		 1898 bfd_vma voffset;
1899 debug_type context;
1900{
1901 struct debug_method_variant *m;
1902
1903 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1904 memset (m, 0, sizeof *m);
1905
1906 m->physname = physname;
1907 m->type = type;
1908 m->visibility = visibility;
1909 m->constp = constp;
1910 m->volatilep = volatilep;
1911 m->voffset = voffset;
1912 m->context = context;
1913
1914 return m;
1915}
1916
1917/* Make a static method argument. The arguments are the same as for
1918 debug_make_method_variant, except that the last two are omitted
1919 since a static method can not also be virtual. */
1920
1921debug_method_variant
1922debug_make_static_method_variant (handle, physname, type, visibility,
1923 constp, volatilep)
b4c96d0d 1924 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 1925 const char *physname;
1926 debug_type type;
1927 enum debug_visibility visibility;
b34976b6
AM		 1928 bfd_boolean constp;
1929 bfd_boolean volatilep;
252b5132
RH		 1930{
1931 struct debug_method_variant *m;
1932
1933 m = (struct debug_method_variant *) xmalloc (sizeof *m);
1934 memset (m, 0, sizeof *m);
1935
1936 m->physname = physname;
1937 m->type = type;
1938 m->visibility = visibility;
1939 m->constp = constp;
1940 m->volatilep = volatilep;
1941 m->voffset = VOFFSET_STATIC_METHOD;
1942
1943 return m;
1944}
1945
1946/* Name a type. */
1947
1948debug_type
1949debug_name_type (handle, name, type)
1950 PTR handle;
1951 const char *name;
1952 debug_type type;
1953{
1954 struct debug_handle *info = (struct debug_handle *) handle;
1955 struct debug_type *t;
1956 struct debug_named_type *n;
1957 struct debug_name *nm;
1958
1959 if (name == NULL || type == NULL)
1960 return DEBUG_TYPE_NULL;
1961
1962 if (info->current_unit == NULL
1963 || info->current_file == NULL)
1964 {
1965 debug_error (_("debug_name_type: no current file"));
1966 return DEBUG_TYPE_NULL;
1967 }
1968
1969 t = debug_make_type (info, DEBUG_KIND_NAMED, 0);
1970 if (t == NULL)
1971 return DEBUG_TYPE_NULL;
1972
1973 n = (struct debug_named_type *) xmalloc (sizeof *n);
1974 memset (n, 0, sizeof *n);
1975
1976 n->type = type;
1977
1978 t->u.knamed = n;
1979
1980 /* We always add the name to the global namespace. This is probably
1981 wrong in some cases, but it seems to be right for stabs. FIXME. */
1982
1983 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1984 DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE);
1985 if (nm == NULL)
3dceb55b 1986 return DEBUG_TYPE_NULL;
252b5132
RH		 1987
1988 nm->u.type = t;
1989
1990 n->name = nm;
1991
1992 return t;
1993}
1994
1995/* Tag a type. */
1996
1997debug_type
1998debug_tag_type (handle, name, type)
1999 PTR handle;
2000 const char *name;
2001 debug_type type;
2002{
2003 struct debug_handle *info = (struct debug_handle *) handle;
2004 struct debug_type *t;
2005 struct debug_named_type *n;
2006 struct debug_name *nm;
2007
2008 if (name == NULL || type == NULL)
2009 return DEBUG_TYPE_NULL;
2010
2011 if (info->current_file == NULL)
2012 {
2013 debug_error (_("debug_tag_type: no current file"));
2014 return DEBUG_TYPE_NULL;
2015 }
2016
2017 if (type->kind == DEBUG_KIND_TAGGED)
2018 {
2019 if (strcmp (type->u.knamed->name->name, name) == 0)
2020 return type;
2021 debug_error (_("debug_tag_type: extra tag attempted"));
2022 return DEBUG_TYPE_NULL;
2023 }
2024
2025 t = debug_make_type (info, DEBUG_KIND_TAGGED, 0);
2026 if (t == NULL)
2027 return DEBUG_TYPE_NULL;
2028
2029 n = (struct debug_named_type *) xmalloc (sizeof *n);
2030 memset (n, 0, sizeof *n);
2031
2032 n->type = type;
2033
2034 t->u.knamed = n;
2035
2036 /* We keep a global namespace of tags for each compilation unit. I
2037 don't know if that is the right thing to do. */
2038
2039 nm = debug_add_to_namespace (info, &info->current_file->globals, name,
2040 DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE);
2041 if (nm == NULL)
3dceb55b 2042 return DEBUG_TYPE_NULL;
252b5132
RH		 2043
2044 nm->u.tag = t;
2045
2046 n->name = nm;
2047
2048 return t;
2049}
2050
2051/* Record the size of a given type. */
2052
b34976b6 2053bfd_boolean
252b5132 2054debug_record_type_size (handle, type, size)
b4c96d0d 2055 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2056 debug_type type;
2057 unsigned int size;
2058{
2059 if (type->size != 0 && type->size != size)
2060 fprintf (stderr, _("Warning: changing type size from %d to %d\n"),
2061 type->size, size);
2062
2063 type->size = size;
2064
b34976b6 2065 return TRUE;
252b5132
RH		 2066}
2067
2068/* Find a named type. */
2069
2070debug_type
2071debug_find_named_type (handle, name)
2072 PTR handle;
2073 const char *name;
2074{
2075 struct debug_handle *info = (struct debug_handle *) handle;
2076 struct debug_block *b;
2077 struct debug_file *f;
2078
2079 /* We only search the current compilation unit. I don't know if
2080 this is right or not. */
2081
2082 if (info->current_unit == NULL)
2083 {
2084 debug_error (_("debug_find_named_type: no current compilation unit"));
2085 return DEBUG_TYPE_NULL;
2086 }
2087
2088 for (b = info->current_block; b != NULL; b = b->parent)
2089 {
2090 if (b->locals != NULL)
2091 {
2092 struct debug_name *n;
2093
2094 for (n = b->locals->list; n != NULL; n = n->next)
2095 {
2096 if (n->kind == DEBUG_OBJECT_TYPE
2097 && n->name[0] == name[0]
2098 && strcmp (n->name, name) == 0)
2099 return n->u.type;
2100 }
2101 }
2102 }
2103
2104 for (f = info->current_unit->files; f != NULL; f = f->next)
2105 {
2106 if (f->globals != NULL)
2107 {
2108 struct debug_name *n;
2109
2110 for (n = f->globals->list; n != NULL; n = n->next)
2111 {
2112 if (n->kind == DEBUG_OBJECT_TYPE
2113 && n->name[0] == name[0]
2114 && strcmp (n->name, name) == 0)
2115 return n->u.type;
2116 }
2117 }
2118 }
2119
26044998 2120 return DEBUG_TYPE_NULL;
252b5132
RH		 2121}
2122
2123/* Find a tagged type. */
2124
2125debug_type
2126debug_find_tagged_type (handle, name, kind)
2127 PTR handle;
2128 const char *name;
2129 enum debug_type_kind kind;
2130{
2131 struct debug_handle *info = (struct debug_handle *) handle;
2132 struct debug_unit *u;
2133
2134 /* We search the globals of all the compilation units. I don't know
2135 if this is correct or not. It would be easy to change. */
2136
2137 for (u = info->units; u != NULL; u = u->next)
2138 {
2139 struct debug_file *f;
2140
2141 for (f = u->files; f != NULL; f = f->next)
2142 {
2143 struct debug_name *n;
2144
2145 if (f->globals != NULL)
2146 {
2147 for (n = f->globals->list; n != NULL; n = n->next)
2148 {
2149 if (n->kind == DEBUG_OBJECT_TAG
2150 && (kind == DEBUG_KIND_ILLEGAL
2151 || n->u.tag->kind == kind)
2152 && n->name[0] == name[0]
2153 && strcmp (n->name, name) == 0)
2154 return n->u.tag;
2155 }
2156 }
2157 }
2158 }
2159
2160 return DEBUG_TYPE_NULL;
2161}
2162
2163/* Get a base type. We build a linked list on the stack to avoid
2164 crashing if the type is defined circularly. */
2165
2166static struct debug_type *
2167debug_get_real_type (handle, type, list)
2168 PTR handle;
2169 debug_type type;
2170 struct debug_type_real_list *list;
2171{
2172 struct debug_type_real_list *l;
2173 struct debug_type_real_list rl;
2174
2175 switch (type->kind)
2176 {
2177 default:
2178 return type;
2179
2180 case DEBUG_KIND_INDIRECT:
2181 case DEBUG_KIND_NAMED:
2182 case DEBUG_KIND_TAGGED:
2183 break;
2184 }
2185
2186 for (l = list; l != NULL; l = l->next)
2187 {
2188 if (l->t == type)
2189 {
2190 fprintf (stderr,
2191 _("debug_get_real_type: circular debug information for %s\n"),
2192 debug_get_type_name (handle, type));
2193 return NULL;
2194 }
2195 }
2196
2197 rl.next = list;
2198 rl.t = type;
2199
2200 switch (type->kind)
2201 {
2202 /* The default case is just here to avoid warnings. */
2203 default:
2204 case DEBUG_KIND_INDIRECT:
2205 if (*type->u.kindirect->slot != NULL)
2206 return debug_get_real_type (handle, *type->u.kindirect->slot, &rl);
2207 return type;
2208 case DEBUG_KIND_NAMED:
2209 case DEBUG_KIND_TAGGED:
2210 return debug_get_real_type (handle, type->u.knamed->type, &rl);
2211 }
2212 /*NOTREACHED*/
2213}
2214
2215/* Get the kind of a type. */
2216
2217enum debug_type_kind
2218debug_get_type_kind (handle, type)
2219 PTR handle;
2220 debug_type type;
2221{
2222 if (type == NULL)
2223 return DEBUG_KIND_ILLEGAL;
2224 type = debug_get_real_type (handle, type, NULL);
2225 if (type == NULL)
2226 return DEBUG_KIND_ILLEGAL;
2227 return type->kind;
2228}
2229
2230/* Get the name of a type. */
2231
2232const char *
2233debug_get_type_name (handle, type)
2234 PTR handle;
2235 debug_type type;
2236{
2237 if (type->kind == DEBUG_KIND_INDIRECT)
2238 {
2239 if (*type->u.kindirect->slot != NULL)
2240 return debug_get_type_name (handle, *type->u.kindirect->slot);
2241 return type->u.kindirect->tag;
2242 }
2243 if (type->kind == DEBUG_KIND_NAMED
2244 || type->kind == DEBUG_KIND_TAGGED)
2245 return type->u.knamed->name->name;
2246 return NULL;
2247}
2248
2249/* Get the size of a type. */
2250
2251bfd_vma
2252debug_get_type_size (handle, type)
2253 PTR handle;
2254 debug_type type;
2255{
2256 if (type == NULL)
2257 return 0;
2258
2259 /* We don't call debug_get_real_type, because somebody might have
2260 called debug_record_type_size on a named or indirect type. */
2261
2262 if (type->size != 0)
2263 return type->size;
2264
2265 switch (type->kind)
2266 {
2267 default:
2268 return 0;
2269 case DEBUG_KIND_INDIRECT:
2270 if (*type->u.kindirect->slot != NULL)
2271 return debug_get_type_size (handle, *type->u.kindirect->slot);
2272 return 0;
2273 case DEBUG_KIND_NAMED:
2274 case DEBUG_KIND_TAGGED:
2275 return debug_get_type_size (handle, type->u.knamed->type);
2276 }
2277 /*NOTREACHED*/
2278}
2279
2280/* Get the return type of a function or method type. */
2281
2282debug_type
2283debug_get_return_type (handle, type)
2284 PTR handle;
2285 debug_type type;
2286{
2287 if (type == NULL)
2288 return DEBUG_TYPE_NULL;
2289 type = debug_get_real_type (handle, type, NULL);
2290 if (type == NULL)
2291 return DEBUG_TYPE_NULL;
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;
2315 type = debug_get_real_type (handle, type, NULL);
2316 if (type == NULL)
2317 return NULL;
2318 switch (type->kind)
2319 {
2320 default:
2321 return NULL;
2322 case DEBUG_KIND_FUNCTION:
2323 *pvarargs = type->u.kfunction->varargs;
2324 return type->u.kfunction->arg_types;
2325 case DEBUG_KIND_METHOD:
2326 *pvarargs = type->u.kmethod->varargs;
2327 return type->u.kmethod->arg_types;
2328 }
2329 /*NOTREACHED*/
2330}
2331
2332/* Get the target type of a type. */
2333
2334debug_type
2335debug_get_target_type (handle, type)
2336 PTR handle;
2337 debug_type type;
2338{
2339 if (type == NULL)
2340 return NULL;
2341 type = debug_get_real_type (handle, type, NULL);
2342 if (type == NULL)
2343 return NULL;
2344 switch (type->kind)
2345 {
2346 default:
2347 return NULL;
2348 case DEBUG_KIND_POINTER:
2349 return type->u.kpointer;
2350 case DEBUG_KIND_REFERENCE:
2351 return type->u.kreference;
2352 case DEBUG_KIND_CONST:
2353 return type->u.kconst;
2354 case DEBUG_KIND_VOLATILE:
2355 return type->u.kvolatile;
2356 }
2357 /*NOTREACHED*/
2358}
2359
2360/* Get the NULL terminated array of fields for a struct, union, or
2361 class. */
2362
2363const debug_field *
2364debug_get_fields (handle, type)
2365 PTR handle;
2366 debug_type type;
2367{
2368 if (type == NULL)
2369 return NULL;
2370 type = debug_get_real_type (handle, type, NULL);
2371 if (type == NULL)
2372 return NULL;
2373 switch (type->kind)
2374 {
2375 default:
2376 return NULL;
2377 case DEBUG_KIND_STRUCT:
2378 case DEBUG_KIND_UNION:
2379 case DEBUG_KIND_CLASS:
2380 case DEBUG_KIND_UNION_CLASS:
2381 return type->u.kclass->fields;
2382 }
2383 /*NOTREACHED*/
2384}
2385
2386/* Get the type of a field. */
2387
252b5132
RH		 2388debug_type
2389debug_get_field_type (handle, field)
b4c96d0d 2390 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2391 debug_field field;
2392{
2393 if (field == NULL)
2394 return NULL;
2395 return field->type;
2396}
2397
2398/* Get the name of a field. */
2399
252b5132
RH		 2400const char *
2401debug_get_field_name (handle, field)
b4c96d0d 2402 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2403 debug_field field;
2404{
2405 if (field == NULL)
2406 return NULL;
2407 return field->name;
2408}
2409
2410/* Get the bit position of a field. */
2411
252b5132
RH		 2412bfd_vma
2413debug_get_field_bitpos (handle, field)
b4c96d0d 2414 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2415 debug_field field;
2416{
2417 if (field == NULL || field->static_member)
2418 return (bfd_vma) -1;
2419 return field->u.f.bitpos;
2420}
2421
2422/* Get the bit size of a field. */
2423
252b5132
RH		 2424bfd_vma
2425debug_get_field_bitsize (handle, field)
b4c96d0d 2426 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2427 debug_field field;
2428{
2429 if (field == NULL || field->static_member)
2430 return (bfd_vma) -1;
2431 return field->u.f.bitsize;
2432}
2433
2434/* Get the visibility of a field. */
2435
252b5132
RH		 2436enum debug_visibility
2437debug_get_field_visibility (handle, field)
b4c96d0d 2438 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2439 debug_field field;
2440{
2441 if (field == NULL)
2442 return DEBUG_VISIBILITY_IGNORE;
2443 return field->visibility;
2444}
2445
2446/* Get the physical name of a field. */
2447
2448const char *
2449debug_get_field_physname (handle, field)
b4c96d0d 2450 PTR handle ATTRIBUTE_UNUSED;
252b5132
RH		 2451 debug_field field;
2452{
2453 if (field == NULL || ! field->static_member)
2454 return NULL;
2455 return field->u.s.physname;
2456}
2457\f
2458/* Write out the debugging information. This is given a handle to
2459 debugging information, and a set of function pointers to call. */
2460
b34976b6 2461bfd_boolean
252b5132
RH		 2462debug_write (handle, fns, fhandle)
2463 PTR handle;
2464 const struct debug_write_fns *fns;
2465 PTR fhandle;
2466{
2467 struct debug_handle *info = (struct debug_handle *) handle;
2468 struct debug_unit *u;
2469
2470 /* We use a mark to tell whether we have already written out a
2471 particular name. We use an integer, so that we don't have to
2472 clear the mark fields if we happen to write out the same
2473 information more than once. */
2474 ++info->mark;
2475
2476 /* The base_id field holds an ID value which will never be used, so
2477 that we can tell whether we have assigned an ID during this call
2478 to debug_write. */
2479 info->base_id = info->class_id;
2480
2481 /* We keep a linked list of classes for which was have assigned ID's
2482 during this call to debug_write. */
2483 info->id_list = NULL;
2484
2485 for (u = info->units; u != NULL; u = u->next)
2486 {
2487 struct debug_file *f;
b34976b6 2488 bfd_boolean first_file;
252b5132
RH		 2489
2490 info->current_write_lineno = u->linenos;
2491 info->current_write_lineno_index = 0;
2492
2493 if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
b34976b6 2494 return FALSE;
252b5132 2495
b34976b6 2496 first_file = TRUE;
252b5132
RH		 2497 for (f = u->files; f != NULL; f = f->next)
2498 {
2499 struct debug_name *n;
2500
2501 if (first_file)
b34976b6 2502 first_file = FALSE;
252b5132
RH		 2503 else
2504 {
2505 if (! (*fns->start_source) (fhandle, f->filename))
b34976b6 2506 return FALSE;
252b5132
RH		 2507 }
2508
2509 if (f->globals != NULL)
2510 {
2511 for (n = f->globals->list; n != NULL; n = n->next)
2512 {
2513 if (! debug_write_name (info, fns, fhandle, n))
b34976b6 2514 return FALSE;
252b5132
RH		 2515 }
2516 }
2517 }
2518
2519 /* Output any line number information which hasn't already been
2520 handled. */
2521 if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
b34976b6 2522 return FALSE;
252b5132
RH		 2523 }
2524
b34976b6 2525 return TRUE;
252b5132
RH		 2526}
2527
2528/* Write out an element in a namespace. */
2529
b34976b6 2530static bfd_boolean
252b5132
RH		 2531debug_write_name (info, fns, fhandle, n)
2532 struct debug_handle *info;
2533 const struct debug_write_fns *fns;
2534 PTR fhandle;
2535 struct debug_name *n;
2536{
2537 switch (n->kind)
2538 {
2539 case DEBUG_OBJECT_TYPE:
2540 if (! debug_write_type (info, fns, fhandle, n->u.type, n)
2541 || ! (*fns->typdef) (fhandle, n->name))
b34976b6
AM		 2542 return FALSE;
2543 return TRUE;
252b5132
RH		 2544 case DEBUG_OBJECT_TAG:
2545 if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
b34976b6 2546 return FALSE;
252b5132
RH		 2547 return (*fns->tag) (fhandle, n->name);
2548 case DEBUG_OBJECT_VARIABLE:
2549 if (! debug_write_type (info, fns, fhandle, n->u.variable->type,
2550 (struct debug_name *) NULL))
b34976b6 2551 return FALSE;
252b5132
RH		 2552 return (*fns->variable) (fhandle, n->name, n->u.variable->kind,
2553 n->u.variable->val);
2554 case DEBUG_OBJECT_FUNCTION:
2555 return debug_write_function (info, fns, fhandle, n->name,
2556 n->linkage, n->u.function);
2557 case DEBUG_OBJECT_INT_CONSTANT:
2558 return (*fns->int_constant) (fhandle, n->name, n->u.int_constant);
2559 case DEBUG_OBJECT_FLOAT_CONSTANT:
2560 return (*fns->float_constant) (fhandle, n->name, n->u.float_constant);
2561 case DEBUG_OBJECT_TYPED_CONSTANT:
2562 if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type,
2563 (struct debug_name *) NULL))
b34976b6 2564 return FALSE;
252b5132
RH		 2565 return (*fns->typed_constant) (fhandle, n->name,
2566 n->u.typed_constant->val);
2567 default:
2568 abort ();
b34976b6 2569 return FALSE;
252b5132
RH		 2570 }
2571 /*NOTREACHED*/
2572}
2573
2574/* Write out a type. If the type is DEBUG_KIND_NAMED or
2575 DEBUG_KIND_TAGGED, then the name argument is the name for which we
2576 are about to call typedef or tag. If the type is anything else,
2577 then the name argument is a tag from a DEBUG_KIND_TAGGED type which
2578 points to this one. */
2579
b34976b6 2580static bfd_boolean
252b5132
RH		 2581debug_write_type (info, fns, fhandle, type, name)
2582 struct debug_handle *info;
2583 const struct debug_write_fns *fns;
2584 PTR fhandle;
2585 struct debug_type *type;
2586 struct debug_name *name;
2587{
2588 unsigned int i;
2589 int is;
b4c96d0d 2590 const char *tag = NULL;
252b5132
RH		 2591
2592 /* If we have a name for this type, just output it. We only output
2593 typedef names after they have been defined. We output type tags
2594 whenever we are not actually defining them. */
2595 if ((type->kind == DEBUG_KIND_NAMED
2596 || type->kind == DEBUG_KIND_TAGGED)
2597 && (type->u.knamed->name->mark == info->mark
2598 || (type->kind == DEBUG_KIND_TAGGED
2599 && type->u.knamed->name != name)))
2600 {
2601 if (type->kind == DEBUG_KIND_NAMED)
2602 return (*fns->typedef_type) (fhandle, type->u.knamed->name->name);
2603 else
2604 {
2605 struct debug_type *real;
2606 unsigned int id;
2607
2608 real = debug_get_real_type ((PTR) info, type, NULL);
2609 if (real == NULL)
2610 return (*fns->empty_type) (fhandle);
2611 id = 0;
2612 if ((real->kind == DEBUG_KIND_STRUCT
2613 || real->kind == DEBUG_KIND_UNION
2614 || real->kind == DEBUG_KIND_CLASS
2615 || real->kind == DEBUG_KIND_UNION_CLASS)
2616 && real->u.kclass != NULL)
2617 {
2618 if (real->u.kclass->id <= info->base_id)
2619 {
2620 if (! debug_set_class_id (info,
2621 type->u.knamed->name->name,
2622 real))
b34976b6 2623 return FALSE;
252b5132
RH		 2624 }
2625 id = real->u.kclass->id;
2626 }
2627
2628 return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id,
2629 real->kind);
2630 }
2631 }
2632
2633 /* Mark the name after we have already looked for a known name, so
2634 that we don't just define a type in terms of itself. We need to
2635 mark the name here so that a struct containing a pointer to
2636 itself will work. */
2637 if (name != NULL)
2638 name->mark = info->mark;
2639
252b5132
RH		 2640 if (name != NULL
2641 && type->kind != DEBUG_KIND_NAMED
2642 && type->kind != DEBUG_KIND_TAGGED)
2643 {
2644 assert (name->kind == DEBUG_OBJECT_TAG);
2645 tag = name->name;
2646 }
2647
2648 switch (type->kind)
2649 {
2650 case DEBUG_KIND_ILLEGAL:
2651 debug_error (_("debug_write_type: illegal type encountered"));
b34976b6 2652 return FALSE;
252b5132
RH		 2653 case DEBUG_KIND_INDIRECT:
2654 if (*type->u.kindirect->slot == DEBUG_TYPE_NULL)
2655 return (*fns->empty_type) (fhandle);
2656 return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot,
2657 name);
2658 case DEBUG_KIND_VOID:
2659 return (*fns->void_type) (fhandle);
2660 case DEBUG_KIND_INT:
2661 return (*fns->int_type) (fhandle, type->size, type->u.kint);
2662 case DEBUG_KIND_FLOAT:
2663 return (*fns->float_type) (fhandle, type->size);
2664 case DEBUG_KIND_COMPLEX:
2665 return (*fns->complex_type) (fhandle, type->size);
2666 case DEBUG_KIND_BOOL:
2667 return (*fns->bool_type) (fhandle, type->size);
2668 case DEBUG_KIND_STRUCT:
2669 case DEBUG_KIND_UNION:
2670 if (type->u.kclass != NULL)
2671 {
2672 if (type->u.kclass->id <= info->base_id)
2673 {
2674 if (! debug_set_class_id (info, tag, type))
b34976b6 2675 return FALSE;
252b5132
RH		 2676 }
2677
2678 if (info->mark == type->u.kclass->mark)
2679 {
2680 /* We are currently outputting this struct, or we have
2681 already output it. I don't know if this can happen,
2682 but it can happen for a class. */
2683 assert (type->u.kclass->id > info->base_id);
2684 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2685 type->kind);
2686 }
2687 type->u.kclass->mark = info->mark;
2688 }
2689
2690 if (! (*fns->start_struct_type) (fhandle, tag,
2691 (type->u.kclass != NULL
2692 ? type->u.kclass->id
2693 : 0),
2694 type->kind == DEBUG_KIND_STRUCT,
2695 type->size))
b34976b6 2696 return FALSE;
252b5132
RH		 2697 if (type->u.kclass != NULL
2698 && type->u.kclass->fields != NULL)
2699 {
2700 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2701 {
2702 struct debug_field *f;
2703
2704 f = type->u.kclass->fields[i];
2705 if (! debug_write_type (info, fns, fhandle, f->type,
2706 (struct debug_name *) NULL)
2707 || ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2708 f->u.f.bitsize, f->visibility))
b34976b6 2709 return FALSE;
252b5132
RH		 2710 }
2711 }
2712 return (*fns->end_struct_type) (fhandle);
2713 case DEBUG_KIND_CLASS:
2714 case DEBUG_KIND_UNION_CLASS:
2715 return debug_write_class_type (info, fns, fhandle, type, tag);
2716 case DEBUG_KIND_ENUM:
2717 if (type->u.kenum == NULL)
2718 return (*fns->enum_type) (fhandle, tag, (const char **) NULL,
2719 (bfd_signed_vma *) NULL);
2720 return (*fns->enum_type) (fhandle, tag, type->u.kenum->names,
2721 type->u.kenum->values);
2722 case DEBUG_KIND_POINTER:
2723 if (! debug_write_type (info, fns, fhandle, type->u.kpointer,
2724 (struct debug_name *) NULL))
b34976b6 2725 return FALSE;
252b5132
RH		 2726 return (*fns->pointer_type) (fhandle);
2727 case DEBUG_KIND_FUNCTION:
2728 if (! debug_write_type (info, fns, fhandle,
2729 type->u.kfunction->return_type,
2730 (struct debug_name *) NULL))
b34976b6 2731 return FALSE;
252b5132
RH		 2732 if (type->u.kfunction->arg_types == NULL)
2733 is = -1;
2734 else
2735 {
2736 for (is = 0; type->u.kfunction->arg_types[is] != NULL; is++)
2737 if (! debug_write_type (info, fns, fhandle,
2738 type->u.kfunction->arg_types[is],
2739 (struct debug_name *) NULL))
b34976b6 2740 return FALSE;
252b5132
RH		 2741 }
2742 return (*fns->function_type) (fhandle, is,
2743 type->u.kfunction->varargs);
2744 case DEBUG_KIND_REFERENCE:
2745 if (! debug_write_type (info, fns, fhandle, type->u.kreference,
2746 (struct debug_name *) NULL))
b34976b6 2747 return FALSE;
252b5132
RH		 2748 return (*fns->reference_type) (fhandle);
2749 case DEBUG_KIND_RANGE:
2750 if (! debug_write_type (info, fns, fhandle, type->u.krange->type,
2751 (struct debug_name *) NULL))
b34976b6 2752 return FALSE;
252b5132
RH		 2753 return (*fns->range_type) (fhandle, type->u.krange->lower,
2754 type->u.krange->upper);
2755 case DEBUG_KIND_ARRAY:
2756 if (! debug_write_type (info, fns, fhandle, type->u.karray->element_type,
2757 (struct debug_name *) NULL)
2758 || ! debug_write_type (info, fns, fhandle,
2759 type->u.karray->range_type,
2760 (struct debug_name *) NULL))
b34976b6 2761 return FALSE;
252b5132
RH		 2762 return (*fns->array_type) (fhandle, type->u.karray->lower,
2763 type->u.karray->upper,
2764 type->u.karray->stringp);
2765 case DEBUG_KIND_SET:
2766 if (! debug_write_type (info, fns, fhandle, type->u.kset->type,
2767 (struct debug_name *) NULL))
b34976b6 2768 return FALSE;
252b5132
RH		 2769 return (*fns->set_type) (fhandle, type->u.kset->bitstringp);
2770 case DEBUG_KIND_OFFSET:
2771 if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type,
2772 (struct debug_name *) NULL)
2773 || ! debug_write_type (info, fns, fhandle,
2774 type->u.koffset->target_type,
2775 (struct debug_name *) NULL))
b34976b6 2776 return FALSE;
252b5132
RH		 2777 return (*fns->offset_type) (fhandle);
2778 case DEBUG_KIND_METHOD:
2779 if (! debug_write_type (info, fns, fhandle,
2780 type->u.kmethod->return_type,
2781 (struct debug_name *) NULL))
b34976b6 2782 return FALSE;
252b5132
RH		 2783 if (type->u.kmethod->arg_types == NULL)
2784 is = -1;
2785 else
2786 {
2787 for (is = 0; type->u.kmethod->arg_types[is] != NULL; is++)
2788 if (! debug_write_type (info, fns, fhandle,
2789 type->u.kmethod->arg_types[is],
2790 (struct debug_name *) NULL))
b34976b6 2791 return FALSE;
252b5132
RH		 2792 }
2793 if (type->u.kmethod->domain_type != NULL)
2794 {
2795 if (! debug_write_type (info, fns, fhandle,
2796 type->u.kmethod->domain_type,
2797 (struct debug_name *) NULL))
b34976b6 2798 return FALSE;
252b5132
RH		 2799 }
2800 return (*fns->method_type) (fhandle,
2801 type->u.kmethod->domain_type != NULL,
2802 is,
2803 type->u.kmethod->varargs);
2804 case DEBUG_KIND_CONST:
2805 if (! debug_write_type (info, fns, fhandle, type->u.kconst,
2806 (struct debug_name *) NULL))
b34976b6 2807 return FALSE;
252b5132
RH		 2808 return (*fns->const_type) (fhandle);
2809 case DEBUG_KIND_VOLATILE:
2810 if (! debug_write_type (info, fns, fhandle, type->u.kvolatile,
2811 (struct debug_name *) NULL))
b34976b6 2812 return FALSE;
252b5132
RH		 2813 return (*fns->volatile_type) (fhandle);
2814 case DEBUG_KIND_NAMED:
2815 return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2816 (struct debug_name *) NULL);
2817 case DEBUG_KIND_TAGGED:
2818 return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2819 type->u.knamed->name);
2820 default:
2821 abort ();
b34976b6 2822 return FALSE;
252b5132
RH		 2823 }
2824}
2825
2826/* Write out a class type. */
2827
b34976b6 2828static bfd_boolean
252b5132
RH		 2829debug_write_class_type (info, fns, fhandle, type, tag)
2830 struct debug_handle *info;
2831 const struct debug_write_fns *fns;
2832 PTR fhandle;
2833 struct debug_type *type;
2834 const char *tag;
2835{
2836 unsigned int i;
2837 unsigned int id;
2838 struct debug_type *vptrbase;
2839
2840 if (type->u.kclass == NULL)
2841 {
2842 id = 0;
2843 vptrbase = NULL;
2844 }
2845 else
2846 {
2847 if (type->u.kclass->id <= info->base_id)
2848 {
2849 if (! debug_set_class_id (info, tag, type))
b34976b6 2850 return FALSE;
252b5132
RH		 2851 }
2852
2853 if (info->mark == type->u.kclass->mark)
2854 {
2855 /* We are currently outputting this class, or we have
2856 already output it. This can happen when there are
2857 methods for an anonymous class. */
2858 assert (type->u.kclass->id > info->base_id);
2859 return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2860 type->kind);
2861 }
2862 type->u.kclass->mark = info->mark;
2863 id = type->u.kclass->id;
2864
2865 vptrbase = type->u.kclass->vptrbase;
2866 if (vptrbase != NULL && vptrbase != type)
2867 {
2868 if (! debug_write_type (info, fns, fhandle, vptrbase,
2869 (struct debug_name *) NULL))
b34976b6 2870 return FALSE;
252b5132
RH		 2871 }
2872 }
2873
2874 if (! (*fns->start_class_type) (fhandle, tag, id,
2875 type->kind == DEBUG_KIND_CLASS,
2876 type->size,
2877 vptrbase != NULL,
2878 vptrbase == type))
b34976b6 2879 return FALSE;
252b5132
RH		 2880
2881 if (type->u.kclass != NULL)
2882 {
2883 if (type->u.kclass->fields != NULL)
2884 {
2885 for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2886 {
2887 struct debug_field *f;
2888
2889 f = type->u.kclass->fields[i];
2890 if (! debug_write_type (info, fns, fhandle, f->type,
2891 (struct debug_name *) NULL))
b34976b6 2892 return FALSE;
252b5132
RH		 2893 if (f->static_member)
2894 {
2895 if (! (*fns->class_static_member) (fhandle, f->name,
2896 f->u.s.physname,
2897 f->visibility))
b34976b6 2898 return FALSE;
252b5132
RH		 2899 }
2900 else
2901 {
2902 if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2903 f->u.f.bitsize, f->visibility))
b34976b6 2904 return FALSE;
252b5132
RH		 2905 }
2906 }
2907 }
2908
2909 if (type->u.kclass->baseclasses != NULL)
2910 {
2911 for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++)
2912 {
2913 struct debug_baseclass *b;
2914
2915 b = type->u.kclass->baseclasses[i];
2916 if (! debug_write_type (info, fns, fhandle, b->type,
2917 (struct debug_name *) NULL))
b34976b6 2918 return FALSE;
252b5132
RH		 2919 if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->virtual,
2920 b->visibility))
b34976b6 2921 return FALSE;
252b5132
RH		 2922 }
2923 }
2924
2925 if (type->u.kclass->methods != NULL)
2926 {
2927 for (i = 0; type->u.kclass->methods[i] != NULL; i++)
2928 {
2929 struct debug_method *m;
2930 unsigned int j;
2931
2932 m = type->u.kclass->methods[i];
2933 if (! (*fns->class_start_method) (fhandle, m->name))
b34976b6 2934 return FALSE;
252b5132
RH		 2935 for (j = 0; m->variants[j] != NULL; j++)
2936 {
2937 struct debug_method_variant *v;
2938
2939 v = m->variants[j];
2940 if (v->context != NULL)
2941 {
2942 if (! debug_write_type (info, fns, fhandle, v->context,
2943 (struct debug_name *) NULL))
b34976b6 2944 return FALSE;
252b5132
RH		 2945 }
2946 if (! debug_write_type (info, fns, fhandle, v->type,
2947 (struct debug_name *) NULL))
b34976b6 2948 return FALSE;
252b5132
RH		 2949 if (v->voffset != VOFFSET_STATIC_METHOD)
2950 {
2951 if (! (*fns->class_method_variant) (fhandle, v->physname,
2952 v->visibility,
2953 v->constp,
2954 v->volatilep,
2955 v->voffset,
2956 v->context != NULL))
b34976b6 2957 return FALSE;
252b5132
RH		 2958 }
2959 else
2960 {
2961 if (! (*fns->class_static_method_variant) (fhandle,
2962 v->physname,
2963 v->visibility,
2964 v->constp,
2965 v->volatilep))
b34976b6 2966 return FALSE;
252b5132
RH		 2967 }
2968 }
2969 if (! (*fns->class_end_method) (fhandle))
b34976b6 2970 return FALSE;
252b5132
RH		 2971 }
2972 }
2973 }
2974
2975 return (*fns->end_class_type) (fhandle);
2976}
2977
2978/* Write out information for a function. */
2979
b34976b6 2980static bfd_boolean
252b5132
RH		 2981debug_write_function (info, fns, fhandle, name, linkage, function)
2982 struct debug_handle *info;
2983 const struct debug_write_fns *fns;
2984 PTR fhandle;
2985 const char *name;
2986 enum debug_object_linkage linkage;
2987 struct debug_function *function;
2988{
2989 struct debug_parameter *p;
2990 struct debug_block *b;
2991
2992 if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
b34976b6 2993 return FALSE;
252b5132
RH		 2994
2995 if (! debug_write_type (info, fns, fhandle, function->return_type,
2996 (struct debug_name *) NULL))
b34976b6 2997 return FALSE;
252b5132
RH		 2998
2999 if (! (*fns->start_function) (fhandle, name,
3000 linkage == DEBUG_LINKAGE_GLOBAL))
b34976b6 3001 return FALSE;
252b5132
RH		 3002
3003 for (p = function->parameters; p != NULL; p = p->next)
3004 {
3005 if (! debug_write_type (info, fns, fhandle, p->type,
3006 (struct debug_name *) NULL)
3007 || ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val))
b34976b6 3008 return FALSE;
252b5132
RH		 3009 }
3010
3011 for (b = function->blocks; b != NULL; b = b->next)
3012 {
3013 if (! debug_write_block (info, fns, fhandle, b))
b34976b6 3014 return FALSE;
252b5132
RH		 3015 }
3016
3017 return (*fns->end_function) (fhandle);
3018}
3019
3020/* Write out information for a block. */
3021
b34976b6 3022static bfd_boolean
252b5132
RH		 3023debug_write_block (info, fns, fhandle, block)
3024 struct debug_handle *info;
3025 const struct debug_write_fns *fns;
3026 PTR fhandle;
3027 struct debug_block *block;
3028{
3029 struct debug_name *n;
3030 struct debug_block *b;
3031
3032 if (! debug_write_linenos (info, fns, fhandle, block->start))
b34976b6 3033 return FALSE;
252b5132
RH		 3034
3035 /* I can't see any point to writing out a block with no local
3036 variables, so we don't bother, except for the top level block. */
3037 if (block->locals != NULL || block->parent == NULL)
3038 {
3039 if (! (*fns->start_block) (fhandle, block->start))
b34976b6 3040 return FALSE;
252b5132
RH		 3041 }
3042
3043 if (block->locals != NULL)
3044 {
3045 for (n = block->locals->list; n != NULL; n = n->next)
3046 {
3047 if (! debug_write_name (info, fns, fhandle, n))
b34976b6 3048 return FALSE;
252b5132
RH		 3049 }
3050 }
3051
3052 for (b = block->children; b != NULL; b = b->next)
3053 {
3054 if (! debug_write_block (info, fns, fhandle, b))
b34976b6 3055 return FALSE;
252b5132
RH		 3056 }
3057
3058 if (! debug_write_linenos (info, fns, fhandle, block->end))
b34976b6 3059 return FALSE;
252b5132
RH		 3060
3061 if (block->locals != NULL || block->parent == NULL)
3062 {
3063 if (! (*fns->end_block) (fhandle, block->end))
b34976b6 3064 return FALSE;
252b5132
RH		 3065 }
3066
b34976b6 3067 return TRUE;
252b5132
RH		 3068}
3069
3070/* Write out line number information up to ADDRESS. */
3071
b34976b6 3072static bfd_boolean
252b5132
RH		 3073debug_write_linenos (info, fns, fhandle, address)
3074 struct debug_handle *info;
3075 const struct debug_write_fns *fns;
3076 PTR fhandle;
3077 bfd_vma address;
3078{
3079 while (info->current_write_lineno != NULL)
3080 {
3081 struct debug_lineno *l;
3082
3083 l = info->current_write_lineno;
3084
3085 while (info->current_write_lineno_index < DEBUG_LINENO_COUNT)
3086 {
3087 if (l->linenos[info->current_write_lineno_index]
3088 == (unsigned long) -1)
3089 break;
3090
3091 if (l->addrs[info->current_write_lineno_index] >= address)
b34976b6 3092 return TRUE;
252b5132
RH		 3093
3094 if (! (*fns->lineno) (fhandle, l->file->filename,
3095 l->linenos[info->current_write_lineno_index],
3096 l->addrs[info->current_write_lineno_index]))
b34976b6 3097 return FALSE;
252b5132
RH		 3098
3099 ++info->current_write_lineno_index;
3100 }
3101
3102 info->current_write_lineno = l->next;
3103 info->current_write_lineno_index = 0;
3104 }
3105
b34976b6 3106 return TRUE;
252b5132
RH		 3107}
3108
3109/* Get the ID number for a class. If during the same call to
3110 debug_write we find a struct with the same definition with the same
3111 name, we use the same ID. This type of things happens because the
3112 same struct will be defined by multiple compilation units. */
3113
b34976b6 3114static bfd_boolean
252b5132
RH		 3115debug_set_class_id (info, tag, type)
3116 struct debug_handle *info;
3117 const char *tag;
3118 struct debug_type *type;
3119{
3120 struct debug_class_type *c;
3121 struct debug_class_id *l;
3122
3123 assert (type->kind == DEBUG_KIND_STRUCT
3124 || type->kind == DEBUG_KIND_UNION
3125 || type->kind == DEBUG_KIND_CLASS
3126 || type->kind == DEBUG_KIND_UNION_CLASS);
3127
3128 c = type->u.kclass;
3129
3130 if (c->id > info->base_id)
b34976b6 3131 return TRUE;
252b5132
RH		 3132
3133 for (l = info->id_list; l != NULL; l = l->next)
3134 {
3135 if (l->type->kind != type->kind)
3136 continue;
3137
3138 if (tag == NULL)
3139 {
3140 if (l->tag != NULL)
3141 continue;
3142 }
3143 else
3144 {
3145 if (l->tag == NULL
3146 || l->tag[0] != tag[0]
3147 || strcmp (l->tag, tag) != 0)
3148 continue;
3149 }
3150
3151 if (debug_type_samep (info, l->type, type))
3152 {
3153 c->id = l->type->u.kclass->id;
b34976b6 3154 return TRUE;
252b5132
RH		 3155 }
3156 }
3157
3158 /* There are no identical types. Use a new ID, and add it to the
3159 list. */
3160 ++info->class_id;
3161 c->id = info->class_id;
3162
3163 l = (struct debug_class_id *) xmalloc (sizeof *l);
3164 memset (l, 0, sizeof *l);
3165
3166 l->type = type;
3167 l->tag = tag;
3168
3169 l->next = info->id_list;
3170 info->id_list = l;
3171
b34976b6 3172 return TRUE;
252b5132
RH		 3173}
3174
3175/* See if two types are the same. At this point, we don't care about
3176 tags and the like. */
3177
b34976b6 3178static bfd_boolean
252b5132
RH		 3179debug_type_samep (info, t1, t2)
3180 struct debug_handle *info;
3181 struct debug_type *t1;
3182 struct debug_type *t2;
3183{
3184 struct debug_type_compare_list *l;
3185 struct debug_type_compare_list top;
b34976b6 3186 bfd_boolean ret;
252b5132
RH		 3187
3188 if (t1 == NULL)
3189 return t2 == NULL;
3190 if (t2 == NULL)
b34976b6 3191 return FALSE;
252b5132
RH		 3192
3193 while (t1->kind == DEBUG_KIND_INDIRECT)
3194 {
3195 t1 = *t1->u.kindirect->slot;
3196 if (t1 == NULL)
b34976b6 3197 return FALSE;
252b5132
RH		 3198 }
3199 while (t2->kind == DEBUG_KIND_INDIRECT)
3200 {
3201 t2 = *t2->u.kindirect->slot;
3202 if (t2 == NULL)
b34976b6 3203 return FALSE;
252b5132
RH		 3204 }
3205
3206 if (t1 == t2)
b34976b6 3207 return TRUE;
252b5132
RH		 3208
3209 /* As a special case, permit a typedef to match a tag, since C++
3210 debugging output will sometimes add a typedef where C debugging
3211 output will not. */
3212 if (t1->kind == DEBUG_KIND_NAMED
3213 && t2->kind == DEBUG_KIND_TAGGED)
3214 return debug_type_samep (info, t1->u.knamed->type, t2);
3215 else if (t1->kind == DEBUG_KIND_TAGGED
3216 && t2->kind == DEBUG_KIND_NAMED)
3217 return debug_type_samep (info, t1, t2->u.knamed->type);
3218
3219 if (t1->kind != t2->kind
3220 || t1->size != t2->size)
b34976b6 3221 return FALSE;
252b5132
RH		 3222
3223 /* Get rid of the trivial cases first. */
3224 switch (t1->kind)
3225 {
3226 default:
3227 break;
3228 case DEBUG_KIND_VOID:
3229 case DEBUG_KIND_FLOAT:
3230 case DEBUG_KIND_COMPLEX:
3231 case DEBUG_KIND_BOOL:
b34976b6 3232 return TRUE;
252b5132
RH		 3233 case DEBUG_KIND_INT:
3234 return t1->u.kint == t2->u.kint;
3235 }
3236
3237 /* We have to avoid an infinite recursion. We do this by keeping a
3238 list of types which we are comparing. We just keep the list on
3239 the stack. If we encounter a pair of types we are currently
3240 comparing, we just assume that they are equal. */
3241 for (l = info->compare_list; l != NULL; l = l->next)
3242 {
3243 if (l->t1 == t1 && l->t2 == t2)
b34976b6 3244 return TRUE;
252b5132
RH		 3245 }
3246
3247 top.t1 = t1;
3248 top.t2 = t2;
3249 top.next = info->compare_list;
3250 info->compare_list = &top;
3251
3252 switch (t1->kind)
3253 {
3254 default:
3255 abort ();
b34976b6 3256 ret = FALSE;
252b5132
RH		 3257 break;
3258
3259 case DEBUG_KIND_STRUCT:
3260 case DEBUG_KIND_UNION:
3261 case DEBUG_KIND_CLASS:
3262 case DEBUG_KIND_UNION_CLASS:
3263 if (t1->u.kclass == NULL)
3264 ret = t2->u.kclass == NULL;
3265 else if (t2->u.kclass == NULL)
b34976b6 3266 ret = FALSE;
252b5132
RH		 3267 else if (t1->u.kclass->id > info->base_id
3268 && t1->u.kclass->id == t2->u.kclass->id)
b34976b6 3269 ret = TRUE;
252b5132
RH		 3270 else
3271 ret = debug_class_type_samep (info, t1, t2);
3272 break;
3273
3274 case DEBUG_KIND_ENUM:
3275 if (t1->u.kenum == NULL)
3276 ret = t2->u.kenum == NULL;
3277 else if (t2->u.kenum == NULL)
b34976b6 3278 ret = FALSE;
252b5132
RH		 3279 else
3280 {
3281 const char **pn1, **pn2;
3282 bfd_signed_vma *pv1, *pv2;
3283
3284 pn1 = t1->u.kenum->names;
3285 pn2 = t2->u.kenum->names;
3286 pv1 = t1->u.kenum->values;
3287 pv2 = t2->u.kenum->values;
3288 while (*pn1 != NULL && *pn2 != NULL)
3289 {
3290 if (**pn1 != **pn2
3291 || *pv1 != *pv2
3292 || strcmp (*pn1, *pn2) != 0)
3293 break;
3294 ++pn1;
3295 ++pn2;
3296 ++pv1;
3297 ++pv2;
3298 }
3299 ret = *pn1 == NULL && *pn2 == NULL;
3300 }
3301 break;
3302
3303 case DEBUG_KIND_POINTER:
3304 ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);
3305 break;
26044998 3306
252b5132
RH		 3307 case DEBUG_KIND_FUNCTION:
3308 if (t1->u.kfunction->varargs != t2->u.kfunction->varargs
3309 || ! debug_type_samep (info, t1->u.kfunction->return_type,
3310 t2->u.kfunction->return_type)
3311 || ((t1->u.kfunction->arg_types == NULL)
3312 != (t2->u.kfunction->arg_types == NULL)))
b34976b6 3313 ret = FALSE;
252b5132 3314 else if (t1->u.kfunction->arg_types == NULL)
b34976b6 3315 ret = TRUE;
252b5132
RH		 3316 else
3317 {
3318 struct debug_type **a1, **a2;
3319
3320 a1 = t1->u.kfunction->arg_types;
3321 a2 = t2->u.kfunction->arg_types;
3322 while (*a1 != NULL && *a2 != NULL)
3323 {
3324 if (! debug_type_samep (info, *a1, *a2))
3325 break;
3326 ++a1;
3327 ++a2;
3328 }
3329 ret = *a1 == NULL && *a2 == NULL;
3330 }
3331 break;
3332
3333 case DEBUG_KIND_REFERENCE:
3334 ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);
3335 break;
3336
3337 case DEBUG_KIND_RANGE:
3338 ret = (t1->u.krange->lower == t2->u.krange->lower
3339 && t1->u.krange->upper == t2->u.krange->upper
3340 && debug_type_samep (info, t1->u.krange->type,
3341 t2->u.krange->type));
3342
3343 case DEBUG_KIND_ARRAY:
3344 ret = (t1->u.karray->lower == t2->u.karray->lower
3345 && t1->u.karray->upper == t2->u.karray->upper
3346 && t1->u.karray->stringp == t2->u.karray->stringp
3347 && debug_type_samep (info, t1->u.karray->element_type,
3348 t2->u.karray->element_type));
3349 break;
3350
3351 case DEBUG_KIND_SET:
3352 ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp
3353 && debug_type_samep (info, t1->u.kset->type, t2->u.kset->type));
3354 break;
3355
3356 case DEBUG_KIND_OFFSET:
3357 ret = (debug_type_samep (info, t1->u.koffset->base_type,
3358 t2->u.koffset->base_type)
3359 && debug_type_samep (info, t1->u.koffset->target_type,
3360 t2->u.koffset->target_type));
3361 break;
3362
3363 case DEBUG_KIND_METHOD:
3364 if (t1->u.kmethod->varargs != t2->u.kmethod->varargs
3365 || ! debug_type_samep (info, t1->u.kmethod->return_type,
3366 t2->u.kmethod->return_type)
3367 || ! debug_type_samep (info, t1->u.kmethod->domain_type,
3368 t2->u.kmethod->domain_type)
3369 || ((t1->u.kmethod->arg_types == NULL)
3370 != (t2->u.kmethod->arg_types == NULL)))
b34976b6 3371 ret = FALSE;
252b5132 3372 else if (t1->u.kmethod->arg_types == NULL)
b34976b6 3373 ret = TRUE;
252b5132
RH		 3374 else
3375 {
3376 struct debug_type **a1, **a2;
3377
3378 a1 = t1->u.kmethod->arg_types;
3379 a2 = t2->u.kmethod->arg_types;
3380 while (*a1 != NULL && *a2 != NULL)
3381 {
3382 if (! debug_type_samep (info, *a1, *a2))
3383 break;
3384 ++a1;
3385 ++a2;
3386 }
3387 ret = *a1 == NULL && *a2 == NULL;
3388 }
3389 break;
3390
3391 case DEBUG_KIND_CONST:
3392 ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);
3393 break;
3394
3395 case DEBUG_KIND_VOLATILE:
3396 ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);
3397 break;
3398
3399 case DEBUG_KIND_NAMED:
3400 case DEBUG_KIND_TAGGED:
3401 ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0
3402 && debug_type_samep (info, t1->u.knamed->type,
3403 t2->u.knamed->type));
3404 break;
3405 }
3406
3407 info->compare_list = top.next;
3408
3409 return ret;
3410}
3411
3412/* See if two classes are the same. This is a subroutine of
3413 debug_type_samep. */
3414
b34976b6 3415static bfd_boolean
252b5132
RH		 3416debug_class_type_samep (info, t1, t2)
3417 struct debug_handle *info;
3418 struct debug_type *t1;
3419 struct debug_type *t2;
3420{
3421 struct debug_class_type *c1, *c2;
3422
3423 c1 = t1->u.kclass;
3424 c2 = t2->u.kclass;
3425
3426 if ((c1->fields == NULL) != (c2->fields == NULL)
3427 || (c1->baseclasses == NULL) != (c2->baseclasses == NULL)
3428 || (c1->methods == NULL) != (c2->methods == NULL)
3429 || (c1->vptrbase == NULL) != (c2->vptrbase == NULL))
b34976b6 3430 return FALSE;
252b5132
RH		 3431
3432 if (c1->fields != NULL)
3433 {
3434 struct debug_field **pf1, **pf2;
3435
3436 for (pf1 = c1->fields, pf2 = c2->fields;
3437 *pf1 != NULL && *pf2 != NULL;
3438 pf1++, pf2++)
3439 {
3440 struct debug_field *f1, *f2;
3441
3442 f1 = *pf1;
3443 f2 = *pf2;
3444 if (f1->name[0] != f2->name[0]
3445 || f1->visibility != f2->visibility
3446 || f1->static_member != f2->static_member)
b34976b6 3447 return FALSE;
252b5132
RH		 3448 if (f1->static_member)
3449 {
3450 if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
b34976b6 3451 return FALSE;
252b5132
RH		 3452 }
3453 else
3454 {
3455 if (f1->u.f.bitpos != f2->u.f.bitpos
3456 || f1->u.f.bitsize != f2->u.f.bitsize)
b34976b6 3457 return FALSE;
252b5132
RH		 3458 }
3459 /* We do the checks which require function calls last. We
3460 don't require that the types of fields have the same
3461 names, since that sometimes fails in the presence of
3462 typedefs and we really don't care. */
3463 if (strcmp (f1->name, f2->name) != 0
3464 || ! debug_type_samep (info,
3465 debug_get_real_type ((PTR) info,
3466 f1->type, NULL),
3467 debug_get_real_type ((PTR) info,
3468 f2->type, NULL)))
b34976b6 3469 return FALSE;
252b5132
RH		 3470 }
3471 if (*pf1 != NULL || *pf2 != NULL)
b34976b6 3472 return FALSE;
252b5132
RH		 3473 }
3474
3475 if (c1->vptrbase != NULL)
3476 {
3477 if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
b34976b6 3478 return FALSE;
252b5132
RH		 3479 }
3480
3481 if (c1->baseclasses != NULL)
3482 {
3483 struct debug_baseclass **pb1, **pb2;
3484
3485 for (pb1 = c1->baseclasses, pb2 = c2->baseclasses;
3486 *pb1 != NULL && *pb2 != NULL;
3487 ++pb1, ++pb2)
3488 {
3489 struct debug_baseclass *b1, *b2;
3490
3491 b1 = *pb1;
3492 b2 = *pb2;
3493 if (b1->bitpos != b2->bitpos
3494 || b1->virtual != b2->virtual
3495 || b1->visibility != b2->visibility
3496 || ! debug_type_samep (info, b1->type, b2->type))
b34976b6 3497 return FALSE;
252b5132
RH		 3498 }
3499 if (*pb1 != NULL || *pb2 != NULL)
b34976b6 3500 return FALSE;
252b5132
RH		 3501 }
3502
3503 if (c1->methods != NULL)
3504 {
3505 struct debug_method **pm1, **pm2;
3506
3507 for (pm1 = c1->methods, pm2 = c2->methods;
3508 *pm1 != NULL && *pm2 != NULL;
3509 ++pm1, ++pm2)
3510 {
3511 struct debug_method *m1, *m2;
3512
3513 m1 = *pm1;
3514 m2 = *pm2;
3515 if (m1->name[0] != m2->name[0]
3516 || strcmp (m1->name, m2->name) != 0
3517 || (m1->variants == NULL) != (m2->variants == NULL))
b34976b6 3518 return FALSE;
252b5132
RH		 3519 if (m1->variants == NULL)
3520 {
3521 struct debug_method_variant **pv1, **pv2;
3522
3523 for (pv1 = m1->variants, pv2 = m2->variants;
3524 *pv1 != NULL && *pv2 != NULL;
3525 ++pv1, ++pv2)
3526 {
3527 struct debug_method_variant *v1, *v2;
3528
3529 v1 = *pv1;
3530 v2 = *pv2;
3531 if (v1->physname[0] != v2->physname[0]
3532 || v1->visibility != v2->visibility
3533 || v1->constp != v2->constp
3534 || v1->volatilep != v2->volatilep
3535 || v1->voffset != v2->voffset
3536 || (v1->context == NULL) != (v2->context == NULL)
3537 || strcmp (v1->physname, v2->physname) != 0
3538 || ! debug_type_samep (info, v1->type, v2->type))
b34976b6 3539 return FALSE;
252b5132
RH		 3540 if (v1->context != NULL)
3541 {
3542 if (! debug_type_samep (info, v1->context,
3543 v2->context))
b34976b6 3544 return FALSE;
252b5132
RH		 3545 }
3546 }
3547 if (*pv1 != NULL || *pv2 != NULL)
b34976b6 3548 return FALSE;
252b5132
RH		 3549 }
3550 }
3551 if (*pm1 != NULL || *pm2 != NULL)
b34976b6 3552 return FALSE;
252b5132
RH		 3553 }
3554
b34976b6 3555 return TRUE;
252b5132 3556}
GDB Binutils - Deliverables
This page took 0.311923 seconds and 4 git commands to generate.