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