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