projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-06-15 H.J. Lu <hjl@gnu.org>
[deliverable/binutils-gdb.git] / binutils / ieee.c
CommitLineData
252b5132 1/* ieee.c -- Read and write IEEE-695 debugging information.
5af11cab 2 Copyright (C) 1996, 1998, 1999, 2000 Free Software Foundation, Inc.
252b5132
RH		 3 Written by Ian Lance Taylor <ian@cygnus.com>.
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22/* This file reads and writes IEEE-695 debugging information. */
23
24#include <stdio.h>
25#include <assert.h>
26
27#include "bfd.h"
28#include "ieee.h"
29#include "bucomm.h"
30#include "libiberty.h"
31#include "debug.h"
32#include "budbg.h"
5af11cab 33#include "filenames.h"
252b5132
RH		 34
35/* This structure holds an entry on the block stack. */
36
37struct ieee_block
38{
39 /* The kind of block. */
40 int kind;
41 /* The source file name, for a BB5 block. */
42 const char *filename;
43 /* The index of the function type, for a BB4 or BB6 block. */
44 unsigned int fnindx;
45 /* True if this function is being skipped. */
46 boolean skip;
47};
48
49/* This structure is the block stack. */
50
51#define BLOCKSTACK_SIZE (16)
52
53struct ieee_blockstack
54{
55 /* The stack pointer. */
56 struct ieee_block *bsp;
57 /* The stack. */
58 struct ieee_block stack[BLOCKSTACK_SIZE];
59};
60
61/* This structure holds information for a variable. */
62
63struct ieee_var
64{
65 /* Start of name. */
66 const char *name;
67 /* Length of name. */
68 unsigned long namlen;
69 /* Type. */
70 debug_type type;
71 /* Slot if we make an indirect type. */
72 debug_type *pslot;
73 /* Kind of variable or function. */
74 enum
75 {
76 IEEE_UNKNOWN,
77 IEEE_EXTERNAL,
78 IEEE_GLOBAL,
79 IEEE_STATIC,
80 IEEE_LOCAL,
81 IEEE_FUNCTION
82 } kind;
83};
84
85/* This structure holds all the variables. */
86
87struct ieee_vars
88{
89 /* Number of slots allocated. */
90 unsigned int alloc;
91 /* Variables. */
92 struct ieee_var *vars;
93};
94
95/* This structure holds information for a type. We need this because
96 we don't want to represent bitfields as real types. */
97
98struct ieee_type
99{
100 /* Type. */
101 debug_type type;
102 /* Slot if this is type is referenced before it is defined. */
103 debug_type *pslot;
104 /* Slots for arguments if we make indirect types for them. */
105 debug_type *arg_slots;
106 /* If this is a bitfield, this is the size in bits. If this is not
107 a bitfield, this is zero. */
108 unsigned long bitsize;
109};
110
111/* This structure holds all the type information. */
112
113struct ieee_types
114{
115 /* Number of slots allocated. */
116 unsigned int alloc;
117 /* Types. */
118 struct ieee_type *types;
119 /* Builtin types. */
120#define BUILTIN_TYPE_COUNT (60)
121 debug_type builtins[BUILTIN_TYPE_COUNT];
122};
123
124/* This structure holds a linked last of structs with their tag names,
125 so that we can convert them to C++ classes if necessary. */
126
127struct ieee_tag
128{
129 /* Next tag. */
130 struct ieee_tag *next;
131 /* This tag name. */
132 const char *name;
133 /* The type of the tag. */
134 debug_type type;
135 /* The tagged type is an indirect type pointing at this slot. */
136 debug_type slot;
137 /* This is an array of slots used when a field type is converted
138 into a indirect type, in case it needs to be later converted into
139 a reference type. */
140 debug_type *fslots;
141};
142
143/* This structure holds the information we pass around to the parsing
144 functions. */
145
146struct ieee_info
147{
148 /* The debugging handle. */
149 PTR dhandle;
150 /* The BFD. */
151 bfd *abfd;
152 /* The start of the bytes to be parsed. */
153 const bfd_byte *bytes;
154 /* The end of the bytes to be parsed. */
155 const bfd_byte *pend;
156 /* The block stack. */
157 struct ieee_blockstack blockstack;
158 /* Whether we have seen a BB1 or BB2. */
159 boolean saw_filename;
160 /* The variables. */
161 struct ieee_vars vars;
162 /* The global variables, after a global typedef block. */
163 struct ieee_vars *global_vars;
164 /* The types. */
165 struct ieee_types types;
166 /* The global types, after a global typedef block. */
167 struct ieee_types *global_types;
168 /* The list of tagged structs. */
169 struct ieee_tag *tags;
170};
171
172/* Basic builtin types, not including the pointers. */
173
174enum builtin_types
175{
176 builtin_unknown = 0,
177 builtin_void = 1,
178 builtin_signed_char = 2,
179 builtin_unsigned_char = 3,
180 builtin_signed_short_int = 4,
181 builtin_unsigned_short_int = 5,
182 builtin_signed_long = 6,
183 builtin_unsigned_long = 7,
184 builtin_signed_long_long = 8,
185 builtin_unsigned_long_long = 9,
186 builtin_float = 10,
187 builtin_double = 11,
188 builtin_long_double = 12,
189 builtin_long_long_double = 13,
190 builtin_quoted_string = 14,
191 builtin_instruction_address = 15,
192 builtin_int = 16,
193 builtin_unsigned = 17,
194 builtin_unsigned_int = 18,
195 builtin_char = 19,
196 builtin_long = 20,
197 builtin_short = 21,
198 builtin_unsigned_short = 22,
199 builtin_short_int = 23,
200 builtin_signed_short = 24,
201 builtin_bcd_float = 25
202};
203
204/* These are the values found in the derivation flags of a 'b'
205 component record of a 'T' type extension record in a C++ pmisc
206 record. These are bitmasks. */
207
208/* Set for a private base class, clear for a public base class.
209 Protected base classes are not supported. */
210#define BASEFLAGS_PRIVATE (0x1)
211/* Set for a virtual base class. */
212#define BASEFLAGS_VIRTUAL (0x2)
213/* Set for a friend class, clear for a base class. */
214#define BASEFLAGS_FRIEND (0x10)
215
216/* These are the values found in the specs flags of a 'd', 'm', or 'v'
217 component record of a 'T' type extension record in a C++ pmisc
218 record. The same flags are used for a 'M' record in a C++ pmisc
219 record. */
220
221/* The lower two bits hold visibility information. */
222#define CXXFLAGS_VISIBILITY (0x3)
223/* This value in the lower two bits indicates a public member. */
224#define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
225/* This value in the lower two bits indicates a private member. */
226#define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
227/* This value in the lower two bits indicates a protected member. */
228#define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
229/* Set for a static member. */
230#define CXXFLAGS_STATIC (0x4)
231/* Set for a virtual override. */
232#define CXXFLAGS_OVERRIDE (0x8)
233/* Set for a friend function. */
234#define CXXFLAGS_FRIEND (0x10)
235/* Set for a const function. */
236#define CXXFLAGS_CONST (0x20)
237/* Set for a volatile function. */
238#define CXXFLAGS_VOLATILE (0x40)
239/* Set for an overloaded function. */
240#define CXXFLAGS_OVERLOADED (0x80)
241/* Set for an operator function. */
242#define CXXFLAGS_OPERATOR (0x100)
243/* Set for a constructor or destructor. */
244#define CXXFLAGS_CTORDTOR (0x400)
245/* Set for a constructor. */
246#define CXXFLAGS_CTOR (0x200)
247/* Set for an inline function. */
248#define CXXFLAGS_INLINE (0x800)
249
250/* Local functions. */
251
252static void ieee_error
253 PARAMS ((struct ieee_info *, const bfd_byte *, const char *));
254static void ieee_eof PARAMS ((struct ieee_info *));
255static char *savestring PARAMS ((const char *, unsigned long));
256static boolean ieee_read_number
257 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
258static boolean ieee_read_optional_number
259 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *, boolean *));
260static boolean ieee_read_id
261 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
262 unsigned long *));
263static boolean ieee_read_optional_id
264 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
265 unsigned long *, boolean *));
266static boolean ieee_read_expression
267 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
268static debug_type ieee_builtin_type
269 PARAMS ((struct ieee_info *, const bfd_byte *, unsigned int));
270static boolean ieee_alloc_type
271 PARAMS ((struct ieee_info *, unsigned int, boolean));
272static boolean ieee_read_type_index
273 PARAMS ((struct ieee_info *, const bfd_byte **, debug_type *));
274static int ieee_regno_to_genreg PARAMS ((bfd *, int));
275static int ieee_genreg_to_regno PARAMS ((bfd *, int));
276static boolean parse_ieee_bb PARAMS ((struct ieee_info *, const bfd_byte **));
277static boolean parse_ieee_be PARAMS ((struct ieee_info *, const bfd_byte **));
278static boolean parse_ieee_nn PARAMS ((struct ieee_info *, const bfd_byte **));
279static boolean parse_ieee_ty PARAMS ((struct ieee_info *, const bfd_byte **));
280static boolean parse_ieee_atn PARAMS ((struct ieee_info *, const bfd_byte **));
281static boolean ieee_read_cxx_misc
282 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
283static boolean ieee_read_cxx_class
284 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
285static boolean ieee_read_cxx_defaults
286 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
287static boolean ieee_read_reference
288 PARAMS ((struct ieee_info *, const bfd_byte **));
289static boolean ieee_require_asn
290 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
291static boolean ieee_require_atn65
292 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
293 unsigned long *));
294
295/* Report an error in the IEEE debugging information. */
296
297static void
298ieee_error (info, p, s)
299 struct ieee_info *info;
300 const bfd_byte *p;
301 const char *s;
302{
303 if (p != NULL)
304 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
305 (unsigned long) (p - info->bytes), s, *p);
306 else
307 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
308}
309
310/* Report an unexpected EOF in the IEEE debugging information. */
311
312static void
313ieee_eof (info)
314 struct ieee_info *info;
315{
316 ieee_error (info, (const bfd_byte *) NULL,
317 _("unexpected end of debugging information"));
318}
319
320/* Save a string in memory. */
321
322static char *
323savestring (start, len)
324 const char *start;
325 unsigned long len;
326{
327 char *ret;
328
329 ret = (char *) xmalloc (len + 1);
330 memcpy (ret, start, len);
331 ret[len] = '\0';
332 return ret;
333}
334
335/* Read a number which must be present in an IEEE file. */
336
337static boolean
338ieee_read_number (info, pp, pv)
339 struct ieee_info *info;
340 const bfd_byte **pp;
341 bfd_vma *pv;
342{
343 return ieee_read_optional_number (info, pp, pv, (boolean *) NULL);
344}
345
346/* Read a number in an IEEE file. If ppresent is not NULL, the number
347 need not be there. */
348
349static boolean
350ieee_read_optional_number (info, pp, pv, ppresent)
351 struct ieee_info *info;
352 const bfd_byte **pp;
353 bfd_vma *pv;
354 boolean *ppresent;
355{
356 ieee_record_enum_type b;
357
358 if (*pp >= info->pend)
359 {
360 if (ppresent != NULL)
361 {
362 *ppresent = false;
363 return true;
364 }
365 ieee_eof (info);
366 return false;
367 }
368
369 b = (ieee_record_enum_type) **pp;
370 ++*pp;
371
372 if (b <= ieee_number_end_enum)
373 {
374 *pv = (bfd_vma) b;
375 if (ppresent != NULL)
376 *ppresent = true;
377 return true;
378 }
379
380 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
381 {
382 unsigned int i;
383
384 i = (int) b - (int) ieee_number_repeat_start_enum;
385 if (*pp + i - 1 >= info->pend)
386 {
387 ieee_eof (info);
388 return false;
389 }
390
391 *pv = 0;
392 for (; i > 0; i--)
393 {
394 *pv <<= 8;
395 *pv += **pp;
396 ++*pp;
397 }
398
399 if (ppresent != NULL)
400 *ppresent = true;
401
402 return true;
403 }
404
405 if (ppresent != NULL)
406 {
407 --*pp;
408 *ppresent = false;
409 return true;
410 }
411
412 ieee_error (info, *pp - 1, _("invalid number"));
413 return false;
414}
415
416/* Read a required string from an IEEE file. */
417
418static boolean
419ieee_read_id (info, pp, pname, pnamlen)
420 struct ieee_info *info;
421 const bfd_byte **pp;
422 const char **pname;
423 unsigned long *pnamlen;
424{
425 return ieee_read_optional_id (info, pp, pname, pnamlen, (boolean *) NULL);
426}
427
428/* Read a string from an IEEE file. If ppresent is not NULL, the
429 string is optional. */
430
431static boolean
432ieee_read_optional_id (info, pp, pname, pnamlen, ppresent)
433 struct ieee_info *info;
434 const bfd_byte **pp;
435 const char **pname;
436 unsigned long *pnamlen;
437 boolean *ppresent;
438{
439 bfd_byte b;
440 unsigned long len;
441
442 if (*pp >= info->pend)
443 {
444 ieee_eof (info);
445 return false;
446 }
447
448 b = **pp;
449 ++*pp;
450
451 if (b <= 0x7f)
452 len = b;
453 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
454 {
455 len = **pp;
456 ++*pp;
457 }
458 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
459 {
460 len = (**pp << 8) + (*pp)[1];
461 *pp += 2;
462 }
463 else
464 {
465 if (ppresent != NULL)
466 {
467 --*pp;
468 *ppresent = false;
469 return true;
470 }
471 ieee_error (info, *pp - 1, _("invalid string length"));
472 return false;
473 }
474
475 if ((unsigned long) (info->pend - *pp) < len)
476 {
477 ieee_eof (info);
478 return false;
479 }
480
481 *pname = (const char *) *pp;
482 *pnamlen = len;
483 *pp += len;
484
485 if (ppresent != NULL)
486 *ppresent = true;
487
488 return true;
489}
490
491/* Read an expression from an IEEE file. Since this code is only used
492 to parse debugging information, I haven't bothered to write a full
493 blown IEEE expression parser. I've only thrown in the things I've
494 seen in debugging information. This can be easily extended if
495 necessary. */
496
497static boolean
498ieee_read_expression (info, pp, pv)
499 struct ieee_info *info;
500 const bfd_byte **pp;
501 bfd_vma *pv;
502{
503 const bfd_byte *expr_start;
504#define EXPR_STACK_SIZE (10)
505 bfd_vma expr_stack[EXPR_STACK_SIZE];
506 bfd_vma *esp;
507
508 expr_start = *pp;
509
510 esp = expr_stack;
511
512 while (1)
513 {
514 const bfd_byte *start;
515 bfd_vma val;
516 boolean present;
517 ieee_record_enum_type c;
518
519 start = *pp;
520
521 if (! ieee_read_optional_number (info, pp, &val, &present))
522 return false;
523
524 if (present)
525 {
526 if (esp - expr_stack >= EXPR_STACK_SIZE)
527 {
528 ieee_error (info, start, _("expression stack overflow"));
529 return false;
530 }
531 *esp++ = val;
532 continue;
533 }
534
535 c = (ieee_record_enum_type) **pp;
536
537 if (c >= ieee_module_beginning_enum)
538 break;
539
540 ++*pp;
541
542 if (c == ieee_comma)
543 break;
544
545 switch (c)
546 {
547 default:
548 ieee_error (info, start, _("unsupported IEEE expression operator"));
549 break;
550
551 case ieee_variable_R_enum:
552 {
553 bfd_vma indx;
554 asection *s;
555
556 if (! ieee_read_number (info, pp, &indx))
557 return false;
558 for (s = info->abfd->sections; s != NULL; s = s->next)
559 if ((bfd_vma) s->target_index == indx)
560 break;
561 if (s == NULL)
562 {
563 ieee_error (info, start, _("unknown section"));
564 return false;
565 }
566
567 if (esp - expr_stack >= EXPR_STACK_SIZE)
568 {
569 ieee_error (info, start, _("expression stack overflow"));
570 return false;
571 }
572
573 *esp++ = bfd_get_section_vma (info->abfd, s);
574 }
575 break;
576
577 case ieee_function_plus_enum:
578 case ieee_function_minus_enum:
579 {
580 bfd_vma v1, v2;
581
582 if (esp - expr_stack < 2)
583 {
584 ieee_error (info, start, _("expression stack underflow"));
585 return false;
586 }
587
588 v1 = *--esp;
589 v2 = *--esp;
590 *esp++ = v1 + v2;
591 }
592 break;
593 }
594 }
595
596 if (esp - 1 != expr_stack)
597 {
598 ieee_error (info, expr_start, _("expression stack mismatch"));
599 return false;
600 }
601
602 *pv = *--esp;
603
604 return true;
605}
606
607/* Return an IEEE builtin type. */
608
609static debug_type
610ieee_builtin_type (info, p, indx)
611 struct ieee_info *info;
612 const bfd_byte *p;
613 unsigned int indx;
614{
615 PTR dhandle;
616 debug_type type;
617 const char *name;
618
619 if (indx < BUILTIN_TYPE_COUNT
620 && info->types.builtins[indx] != DEBUG_TYPE_NULL)
621 return info->types.builtins[indx];
622
623 dhandle = info->dhandle;
624
625 if (indx >= 32 && indx < 64)
626 {
627 type = debug_make_pointer_type (dhandle,
628 ieee_builtin_type (info, p, indx - 32));
629 assert (indx < BUILTIN_TYPE_COUNT);
630 info->types.builtins[indx] = type;
631 return type;
632 }
633
634 switch ((enum builtin_types) indx)
635 {
636 default:
637 ieee_error (info, p, _("unknown builtin type"));
638 return NULL;
639
640 case builtin_unknown:
641 type = debug_make_void_type (dhandle);
642 name = NULL;
643 break;
644
645 case builtin_void:
646 type = debug_make_void_type (dhandle);
647 name = "void";
648 break;
649
650 case builtin_signed_char:
651 type = debug_make_int_type (dhandle, 1, false);
652 name = "signed char";
653 break;
654
655 case builtin_unsigned_char:
656 type = debug_make_int_type (dhandle, 1, true);
657 name = "unsigned char";
658 break;
659
660 case builtin_signed_short_int:
661 type = debug_make_int_type (dhandle, 2, false);
662 name = "signed short int";
663 break;
664
665 case builtin_unsigned_short_int:
666 type = debug_make_int_type (dhandle, 2, true);
667 name = "unsigned short int";
668 break;
669
670 case builtin_signed_long:
671 type = debug_make_int_type (dhandle, 4, false);
672 name = "signed long";
673 break;
674
675 case builtin_unsigned_long:
676 type = debug_make_int_type (dhandle, 4, true);
677 name = "unsigned long";
678 break;
679
680 case builtin_signed_long_long:
681 type = debug_make_int_type (dhandle, 8, false);
682 name = "signed long long";
683 break;
684
685 case builtin_unsigned_long_long:
686 type = debug_make_int_type (dhandle, 8, true);
687 name = "unsigned long long";
688 break;
689
690 case builtin_float:
691 type = debug_make_float_type (dhandle, 4);
692 name = "float";
693 break;
694
695 case builtin_double:
696 type = debug_make_float_type (dhandle, 8);
697 name = "double";
698 break;
699
700 case builtin_long_double:
701 /* FIXME: The size for this type should depend upon the
702 processor. */
703 type = debug_make_float_type (dhandle, 12);
704 name = "long double";
705 break;
706
707 case builtin_long_long_double:
708 type = debug_make_float_type (dhandle, 16);
709 name = "long long double";
710 break;
711
712 case builtin_quoted_string:
713 type = debug_make_array_type (dhandle,
714 ieee_builtin_type (info, p,
715 ((unsigned int)
716 builtin_char)),
717 ieee_builtin_type (info, p,
718 ((unsigned int)
719 builtin_int)),
720 0, -1, true);
721 name = "QUOTED STRING";
722 break;
723
724 case builtin_instruction_address:
725 /* FIXME: This should be a code address. */
726 type = debug_make_int_type (dhandle, 4, true);
727 name = "instruction address";
728 break;
729
730 case builtin_int:
731 /* FIXME: The size for this type should depend upon the
732 processor. */
733 type = debug_make_int_type (dhandle, 4, false);
734 name = "int";
735 break;
736
737 case builtin_unsigned:
738 /* FIXME: The size for this type should depend upon the
739 processor. */
740 type = debug_make_int_type (dhandle, 4, true);
741 name = "unsigned";
742 break;
743
744 case builtin_unsigned_int:
745 /* FIXME: The size for this type should depend upon the
746 processor. */
747 type = debug_make_int_type (dhandle, 4, true);
748 name = "unsigned int";
749 break;
750
751 case builtin_char:
752 type = debug_make_int_type (dhandle, 1, false);
753 name = "char";
754 break;
755
756 case builtin_long:
757 type = debug_make_int_type (dhandle, 4, false);
758 name = "long";
759 break;
760
761 case builtin_short:
762 type = debug_make_int_type (dhandle, 2, false);
763 name = "short";
764 break;
765
766 case builtin_unsigned_short:
767 type = debug_make_int_type (dhandle, 2, true);
768 name = "unsigned short";
769 break;
770
771 case builtin_short_int:
772 type = debug_make_int_type (dhandle, 2, false);
773 name = "short int";
774 break;
775
776 case builtin_signed_short:
777 type = debug_make_int_type (dhandle, 2, false);
778 name = "signed short";
779 break;
780
781 case builtin_bcd_float:
782 ieee_error (info, p, _("BCD float type not supported"));
3dceb55b 783 return DEBUG_TYPE_NULL;
252b5132
RH		 784 }
785
786 if (name != NULL)
787 type = debug_name_type (dhandle, name, type);
788
789 assert (indx < BUILTIN_TYPE_COUNT);
790
791 info->types.builtins[indx] = type;
792
793 return type;
794}
795
796/* Allocate more space in the type table. If ref is true, this is a
797 reference to the type; if it is not already defined, we should set
798 up an indirect type. */
799
800static boolean
801ieee_alloc_type (info, indx, ref)
802 struct ieee_info *info;
803 unsigned int indx;
804 boolean ref;
805{
806 unsigned int nalloc;
807 register struct ieee_type *t;
808 struct ieee_type *tend;
809
810 if (indx >= info->types.alloc)
811 {
812 nalloc = info->types.alloc;
813 if (nalloc == 0)
814 nalloc = 4;
815 while (indx >= nalloc)
816 nalloc *= 2;
817
818 info->types.types = ((struct ieee_type *)
819 xrealloc (info->types.types,
820 nalloc * sizeof *info->types.types));
821
822 memset (info->types.types + info->types.alloc, 0,
823 (nalloc - info->types.alloc) * sizeof *info->types.types);
824
825 tend = info->types.types + nalloc;
826 for (t = info->types.types + info->types.alloc; t < tend; t++)
827 t->type = DEBUG_TYPE_NULL;
828
829 info->types.alloc = nalloc;
830 }
831
832 if (ref)
833 {
834 t = info->types.types + indx;
835 if (t->type == NULL)
836 {
837 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
838 *t->pslot = DEBUG_TYPE_NULL;
839 t->type = debug_make_indirect_type (info->dhandle, t->pslot,
840 (const char *) NULL);
841 if (t->type == NULL)
842 return false;
843 }
844 }
845
846 return true;
847}
848
849/* Read a type index and return the corresponding type. */
850
851static boolean
852ieee_read_type_index (info, pp, ptype)
853 struct ieee_info *info;
854 const bfd_byte **pp;
855 debug_type *ptype;
856{
857 const bfd_byte *start;
858 bfd_vma indx;
859
860 start = *pp;
861
862 if (! ieee_read_number (info, pp, &indx))
863 return false;
864
865 if (indx < 256)
866 {
867 *ptype = ieee_builtin_type (info, start, indx);
868 if (*ptype == NULL)
869 return false;
870 return true;
871 }
872
873 indx -= 256;
874 if (! ieee_alloc_type (info, indx, true))
875 return false;
876
877 *ptype = info->types.types[indx].type;
878
879 return true;
880}
881
882/* Parse IEEE debugging information for a file. This is passed the
883 bytes which compose the Debug Information Part of an IEEE file. */
884
885boolean
886parse_ieee (dhandle, abfd, bytes, len)
887 PTR dhandle;
888 bfd *abfd;
889 const bfd_byte *bytes;
890 bfd_size_type len;
891{
892 struct ieee_info info;
893 unsigned int i;
894 const bfd_byte *p, *pend;
895
896 info.dhandle = dhandle;
897 info.abfd = abfd;
898 info.bytes = bytes;
899 info.pend = bytes + len;
900 info.blockstack.bsp = info.blockstack.stack;
901 info.saw_filename = false;
902 info.vars.alloc = 0;
903 info.vars.vars = NULL;
904 info.global_vars = NULL;
905 info.types.alloc = 0;
906 info.types.types = NULL;
907 info.global_types = NULL;
908 info.tags = NULL;
909 for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
910 info.types.builtins[i] = DEBUG_TYPE_NULL;
911
912 p = bytes;
913 pend = info.pend;
914 while (p < pend)
915 {
916 const bfd_byte *record_start;
917 ieee_record_enum_type c;
918
919 record_start = p;
920
921 c = (ieee_record_enum_type) *p++;
922
923 if (c == ieee_at_record_enum)
924 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
925
926 if (c <= ieee_number_repeat_end_enum)
927 {
928 ieee_error (&info, record_start, _("unexpected number"));
929 return false;
930 }
931
932 switch (c)
933 {
934 default:
935 ieee_error (&info, record_start, _("unexpected record type"));
936 return false;
937
938 case ieee_bb_record_enum:
939 if (! parse_ieee_bb (&info, &p))
940 return false;
941 break;
942
943 case ieee_be_record_enum:
944 if (! parse_ieee_be (&info, &p))
945 return false;
946 break;
947
948 case ieee_nn_record:
949 if (! parse_ieee_nn (&info, &p))
950 return false;
951 break;
952
953 case ieee_ty_record_enum:
954 if (! parse_ieee_ty (&info, &p))
955 return false;
956 break;
957
958 case ieee_atn_record_enum:
959 if (! parse_ieee_atn (&info, &p))
960 return false;
961 break;
962 }
963 }
964
965 if (info.blockstack.bsp != info.blockstack.stack)
966 {
967 ieee_error (&info, (const bfd_byte *) NULL,
968 _("blocks left on stack at end"));
969 return false;
970 }
971
972 return true;
973}
974
975/* Handle an IEEE BB record. */
976
977static boolean
978parse_ieee_bb (info, pp)
979 struct ieee_info *info;
980 const bfd_byte **pp;
981{
982 const bfd_byte *block_start;
983 bfd_byte b;
984 bfd_vma size;
985 const char *name;
986 unsigned long namlen;
987 char *namcopy = NULL;
988 unsigned int fnindx;
989 boolean skip;
990
991 block_start = *pp;
992
993 b = **pp;
994 ++*pp;
995
996 if (! ieee_read_number (info, pp, &size)
997 || ! ieee_read_id (info, pp, &name, &namlen))
998 return false;
999
1000 fnindx = (unsigned int) -1;
1001 skip = false;
1002
1003 switch (b)
1004 {
1005 case 1:
1006 /* BB1: Type definitions local to a module. */
1007 namcopy = savestring (name, namlen);
1008 if (namcopy == NULL)
1009 return false;
1010 if (! debug_set_filename (info->dhandle, namcopy))
1011 return false;
1012 info->saw_filename = true;
1013
1014 /* Discard any variables or types we may have seen before. */
1015 if (info->vars.vars != NULL)
1016 free (info->vars.vars);
1017 info->vars.vars = NULL;
1018 info->vars.alloc = 0;
1019 if (info->types.types != NULL)
1020 free (info->types.types);
1021 info->types.types = NULL;
1022 info->types.alloc = 0;
1023
1024 /* Initialize the types to the global types. */
1025 if (info->global_types != NULL)
1026 {
1027 info->types.alloc = info->global_types->alloc;
1028 info->types.types = ((struct ieee_type *)
1029 xmalloc (info->types.alloc
1030 * sizeof (*info->types.types)));
1031 memcpy (info->types.types, info->global_types->types,
1032 info->types.alloc * sizeof (*info->types.types));
1033 }
1034
1035 break;
1036
1037 case 2:
1038 /* BB2: Global type definitions. The name is supposed to be
1039 empty, but we don't check. */
1040 if (! debug_set_filename (info->dhandle, "*global*"))
1041 return false;
1042 info->saw_filename = true;
1043 break;
1044
1045 case 3:
1046 /* BB3: High level module block begin. We don't have to do
1047 anything here. The name is supposed to be the same as for
1048 the BB1, but we don't check. */
1049 break;
1050
1051 case 4:
1052 /* BB4: Global function. */
1053 {
1054 bfd_vma stackspace, typindx, offset;
1055 debug_type return_type;
1056
1057 if (! ieee_read_number (info, pp, &stackspace)
1058 || ! ieee_read_number (info, pp, &typindx)
1059 || ! ieee_read_expression (info, pp, &offset))
1060 return false;
1061
1062 /* We have no way to record the stack space. FIXME. */
1063
1064 if (typindx < 256)
1065 {
1066 return_type = ieee_builtin_type (info, block_start, typindx);
1067 if (return_type == DEBUG_TYPE_NULL)
1068 return false;
1069 }
1070 else
1071 {
1072 typindx -= 256;
1073 if (! ieee_alloc_type (info, typindx, true))
1074 return false;
1075 fnindx = typindx;
1076 return_type = info->types.types[typindx].type;
1077 if (debug_get_type_kind (info->dhandle, return_type)
1078 == DEBUG_KIND_FUNCTION)
1079 return_type = debug_get_return_type (info->dhandle,
1080 return_type);
1081 }
1082
1083 namcopy = savestring (name, namlen);
1084 if (namcopy == NULL)
1085 return false;
1086 if (! debug_record_function (info->dhandle, namcopy, return_type,
1087 true, offset))
1088 return false;
1089 }
1090 break;
1091
1092 case 5:
1093 /* BB5: File name for source line numbers. */
1094 {
1095 unsigned int i;
1096
1097 /* We ignore the date and time. FIXME. */
1098 for (i = 0; i < 6; i++)
1099 {
1100 bfd_vma ignore;
1101 boolean present;
1102
1103 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1104 return false;
1105 if (! present)
1106 break;
1107 }
1108
1109 namcopy = savestring (name, namlen);
1110 if (namcopy == NULL)
1111 return false;
1112 if (! debug_start_source (info->dhandle, namcopy))
1113 return false;
1114 }
1115 break;
1116
1117 case 6:
1118 /* BB6: Local function or block. */
1119 {
1120 bfd_vma stackspace, typindx, offset;
1121
1122 if (! ieee_read_number (info, pp, &stackspace)
1123 || ! ieee_read_number (info, pp, &typindx)
1124 || ! ieee_read_expression (info, pp, &offset))
1125 return false;
1126
1127 /* We have no way to record the stack space. FIXME. */
1128
1129 if (namlen == 0)
1130 {
1131 if (! debug_start_block (info->dhandle, offset))
1132 return false;
1133 /* Change b to indicate that this is a block
1134 rather than a function. */
1135 b = 0x86;
1136 }
1137 else
1138 {
1139 /* The MRI C++ compiler will output a fake function named
1140 __XRYCPP to hold C++ debugging information. We skip
1141 that function. This is not crucial, but it makes
1142 converting from IEEE to other debug formats work
1143 better. */
1144 if (strncmp (name, "__XRYCPP", namlen) == 0)
1145 skip = true;
1146 else
1147 {
1148 debug_type return_type;
1149
1150 if (typindx < 256)
1151 {
1152 return_type = ieee_builtin_type (info, block_start,
1153 typindx);
1154 if (return_type == NULL)
1155 return false;
1156 }
1157 else
1158 {
1159 typindx -= 256;
1160 if (! ieee_alloc_type (info, typindx, true))
1161 return false;
1162 fnindx = typindx;
1163 return_type = info->types.types[typindx].type;
1164 if (debug_get_type_kind (info->dhandle, return_type)
1165 == DEBUG_KIND_FUNCTION)
1166 return_type = debug_get_return_type (info->dhandle,
1167 return_type);
1168 }
1169
1170 namcopy = savestring (name, namlen);
1171 if (namcopy == NULL)
1172 return false;
1173 if (! debug_record_function (info->dhandle, namcopy,
1174 return_type, false, offset))
1175 return false;
1176 }
1177 }
1178 }
1179 break;
1180
1181 case 10:
1182 /* BB10: Assembler module scope. In the normal case, we
1183 completely ignore all this information. FIXME. */
1184 {
1185 const char *inam, *vstr;
1186 unsigned long inamlen, vstrlen;
1187 bfd_vma tool_type;
1188 boolean present;
1189 unsigned int i;
1190
1191 if (! info->saw_filename)
1192 {
1193 namcopy = savestring (name, namlen);
1194 if (namcopy == NULL)
1195 return false;
1196 if (! debug_set_filename (info->dhandle, namcopy))
1197 return false;
1198 info->saw_filename = true;
1199 }
1200
1201 if (! ieee_read_id (info, pp, &inam, &inamlen)
1202 || ! ieee_read_number (info, pp, &tool_type)
1203 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1204 return false;
1205 for (i = 0; i < 6; i++)
1206 {
1207 bfd_vma ignore;
1208
1209 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1210 return false;
1211 if (! present)
1212 break;
1213 }
1214 }
1215 break;
1216
1217 case 11:
1218 /* BB11: Module section. We completely ignore all this
1219 information. FIXME. */
1220 {
1221 bfd_vma sectype, secindx, offset, map;
1222 boolean present;
1223
1224 if (! ieee_read_number (info, pp, &sectype)
1225 || ! ieee_read_number (info, pp, &secindx)
1226 || ! ieee_read_expression (info, pp, &offset)
1227 || ! ieee_read_optional_number (info, pp, &map, &present))
1228 return false;
1229 }
1230 break;
1231
1232 default:
1233 ieee_error (info, block_start, _("unknown BB type"));
1234 return false;
1235 }
1236
1237
1238 /* Push this block on the block stack. */
1239
1240 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1241 {
1242 ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
1243 return false;
1244 }
1245
1246 info->blockstack.bsp->kind = b;
1247 if (b == 5)
1248 info->blockstack.bsp->filename = namcopy;
1249 info->blockstack.bsp->fnindx = fnindx;
1250 info->blockstack.bsp->skip = skip;
1251 ++info->blockstack.bsp;
1252
1253 return true;
1254}
1255
1256/* Handle an IEEE BE record. */
1257
1258static boolean
1259parse_ieee_be (info, pp)
1260 struct ieee_info *info;
1261 const bfd_byte **pp;
1262{
1263 bfd_vma offset;
1264
1265 if (info->blockstack.bsp <= info->blockstack.stack)
1266 {
1267 ieee_error (info, *pp, _("stack underflow"));
1268 return false;
1269 }
1270 --info->blockstack.bsp;
1271
1272 switch (info->blockstack.bsp->kind)
1273 {
1274 case 2:
1275 /* When we end the global typedefs block, we copy out the the
1276 contents of info->vars. This is because the variable indices
1277 may be reused in the local blocks. However, we need to
1278 preserve them so that we can locate a function returning a
1279 reference variable whose type is named in the global typedef
1280 block. */
1281 info->global_vars = ((struct ieee_vars *)
1282 xmalloc (sizeof *info->global_vars));
1283 info->global_vars->alloc = info->vars.alloc;
1284 info->global_vars->vars = ((struct ieee_var *)
1285 xmalloc (info->vars.alloc
1286 * sizeof (*info->vars.vars)));
1287 memcpy (info->global_vars->vars, info->vars.vars,
1288 info->vars.alloc * sizeof (*info->vars.vars));
1289
1290 /* We also copy out the non builtin parts of info->types, since
1291 the types are discarded when we start a new block. */
1292 info->global_types = ((struct ieee_types *)
1293 xmalloc (sizeof *info->global_types));
1294 info->global_types->alloc = info->types.alloc;
1295 info->global_types->types = ((struct ieee_type *)
1296 xmalloc (info->types.alloc
1297 * sizeof (*info->types.types)));
1298 memcpy (info->global_types->types, info->types.types,
1299 info->types.alloc * sizeof (*info->types.types));
1300 memset (info->global_types->builtins, 0,
1301 sizeof (info->global_types->builtins));
1302
1303 break;
1304
1305 case 4:
1306 case 6:
1307 if (! ieee_read_expression (info, pp, &offset))
1308 return false;
1309 if (! info->blockstack.bsp->skip)
1310 {
1311 if (! debug_end_function (info->dhandle, offset + 1))
1312 return false;
1313 }
1314 break;
1315
1316 case 0x86:
1317 /* This is BE6 when BB6 started a block rather than a local
1318 function. */
1319 if (! ieee_read_expression (info, pp, &offset))
1320 return false;
1321 if (! debug_end_block (info->dhandle, offset + 1))
1322 return false;
1323 break;
1324
1325 case 5:
1326 /* When we end a BB5, we look up the stack for the last BB5, if
1327 there is one, so that we can call debug_start_source. */
1328 if (info->blockstack.bsp > info->blockstack.stack)
1329 {
1330 struct ieee_block *bl;
1331
1332 bl = info->blockstack.bsp;
1333 do
1334 {
1335 --bl;
1336 if (bl->kind == 5)
1337 {
1338 if (! debug_start_source (info->dhandle, bl->filename))
1339 return false;
1340 break;
1341 }
1342 }
1343 while (bl != info->blockstack.stack);
1344 }
1345 break;
1346
1347 case 11:
1348 if (! ieee_read_expression (info, pp, &offset))
1349 return false;
1350 /* We just ignore the module size. FIXME. */
1351 break;
1352
1353 default:
1354 /* Other block types do not have any trailing information. */
1355 break;
1356 }
1357
1358 return true;
1359}
1360
1361/* Parse an NN record. */
1362
1363static boolean
1364parse_ieee_nn (info, pp)
1365 struct ieee_info *info;
1366 const bfd_byte **pp;
1367{
1368 const bfd_byte *nn_start;
1369 bfd_vma varindx;
1370 const char *name;
1371 unsigned long namlen;
1372
1373 nn_start = *pp;
1374
1375 if (! ieee_read_number (info, pp, &varindx)
1376 || ! ieee_read_id (info, pp, &name, &namlen))
1377 return false;
1378
1379 if (varindx < 32)
1380 {
1381 ieee_error (info, nn_start, _("illegal variable index"));
1382 return false;
1383 }
1384 varindx -= 32;
1385
1386 if (varindx >= info->vars.alloc)
1387 {
1388 unsigned int alloc;
1389
1390 alloc = info->vars.alloc;
1391 if (alloc == 0)
1392 alloc = 4;
1393 while (varindx >= alloc)
1394 alloc *= 2;
1395 info->vars.vars = ((struct ieee_var *)
1396 xrealloc (info->vars.vars,
1397 alloc * sizeof *info->vars.vars));
1398 memset (info->vars.vars + info->vars.alloc, 0,
1399 (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1400 info->vars.alloc = alloc;
1401 }
1402
1403 info->vars.vars[varindx].name = name;
1404 info->vars.vars[varindx].namlen = namlen;
1405
1406 return true;
1407}
1408
1409/* Parse a TY record. */
1410
1411static boolean
1412parse_ieee_ty (info, pp)
1413 struct ieee_info *info;
1414 const bfd_byte **pp;
1415{
1416 const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1417 bfd_vma typeindx, varindx, tc;
1418 PTR dhandle;
1419 boolean tag, typdef;
1420 debug_type *arg_slots;
1421 unsigned long type_bitsize;
1422 debug_type type;
1423
1424 ty_start = *pp;
1425
1426 if (! ieee_read_number (info, pp, &typeindx))
1427 return false;
1428
1429 if (typeindx < 256)
1430 {
1431 ieee_error (info, ty_start, _("illegal type index"));
1432 return false;
1433 }
1434
1435 typeindx -= 256;
1436 if (! ieee_alloc_type (info, typeindx, false))
1437 return false;
1438
1439 if (**pp != 0xce)
1440 {
1441 ieee_error (info, *pp, _("unknown TY code"));
1442 return false;
1443 }
1444 ++*pp;
1445
1446 ty_var_start = *pp;
1447
1448 if (! ieee_read_number (info, pp, &varindx))
1449 return false;
1450
1451 if (varindx < 32)
1452 {
1453 ieee_error (info, ty_var_start, _("illegal variable index"));
1454 return false;
1455 }
1456 varindx -= 32;
1457
1458 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1459 {
1460 ieee_error (info, ty_var_start, _("undefined variable in TY"));
1461 return false;
1462 }
1463
1464 ty_code_start = *pp;
1465
1466 if (! ieee_read_number (info, pp, &tc))
1467 return false;
1468
1469 dhandle = info->dhandle;
1470
1471 tag = false;
1472 typdef = false;
1473 arg_slots = NULL;
1474 type_bitsize = 0;
1475 switch (tc)
1476 {
1477 default:
1478 ieee_error (info, ty_code_start, _("unknown TY code"));
1479 return false;
1480
1481 case '!':
1482 /* Unknown type, with size. We treat it as int. FIXME. */
1483 {
1484 bfd_vma size;
1485
1486 if (! ieee_read_number (info, pp, &size))
1487 return false;
1488 type = debug_make_int_type (dhandle, size, false);
1489 }
1490 break;
1491
1492 case 'A': /* Array. */
1493 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1494 distinguished from normal array. */
1495 {
1496 debug_type ele_type;
1497 bfd_vma lower, upper;
1498
1499 if (! ieee_read_type_index (info, pp, &ele_type)
1500 || ! ieee_read_number (info, pp, &lower)
1501 || ! ieee_read_number (info, pp, &upper))
1502 return false;
1503 type = debug_make_array_type (dhandle, ele_type,
1504 ieee_builtin_type (info, ty_code_start,
1505 ((unsigned int)
1506 builtin_int)),
1507 (bfd_signed_vma) lower,
1508 (bfd_signed_vma) upper,
1509 false);
1510 }
1511 break;
1512
1513 case 'E':
1514 /* Simple enumeration. */
1515 {
1516 bfd_vma size;
1517 unsigned int alloc;
1518 const char **names;
1519 unsigned int c;
1520 bfd_signed_vma *vals;
1521 unsigned int i;
1522
1523 if (! ieee_read_number (info, pp, &size))
1524 return false;
1525 /* FIXME: we ignore the enumeration size. */
1526
1527 alloc = 10;
1528 names = (const char **) xmalloc (alloc * sizeof *names);
1529 memset (names, 0, alloc * sizeof *names);
1530 c = 0;
1531 while (1)
1532 {
1533 const char *name;
1534 unsigned long namlen;
1535 boolean present;
1536
1537 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1538 return false;
1539 if (! present)
1540 break;
1541
1542 if (c + 1 >= alloc)
1543 {
1544 alloc += 10;
1545 names = ((const char **)
1546 xrealloc (names, alloc * sizeof *names));
1547 }
1548
1549 names[c] = savestring (name, namlen);
1550 if (names[c] == NULL)
1551 return false;
1552 ++c;
1553 }
1554
1555 names[c] = NULL;
1556
1557 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1558 for (i = 0; i < c; i++)
1559 vals[i] = i;
1560
1561 type = debug_make_enum_type (dhandle, names, vals);
1562 tag = true;
1563 }
1564 break;
1565
1566 case 'G':
1567 /* Struct with bit fields. */
1568 {
1569 bfd_vma size;
1570 unsigned int alloc;
1571 debug_field *fields;
1572 unsigned int c;
1573
1574 if (! ieee_read_number (info, pp, &size))
1575 return false;
1576
1577 alloc = 10;
1578 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1579 c = 0;
1580 while (1)
1581 {
1582 const char *name;
1583 unsigned long namlen;
1584 boolean present;
1585 debug_type ftype;
1586 bfd_vma bitpos, bitsize;
1587
1588 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1589 return false;
1590 if (! present)
1591 break;
1592 if (! ieee_read_type_index (info, pp, &ftype)
1593 || ! ieee_read_number (info, pp, &bitpos)
1594 || ! ieee_read_number (info, pp, &bitsize))
1595 return false;
1596
1597 if (c + 1 >= alloc)
1598 {
1599 alloc += 10;
1600 fields = ((debug_field *)
1601 xrealloc (fields, alloc * sizeof *fields));
1602 }
1603
1604 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1605 ftype, bitpos, bitsize,
1606 DEBUG_VISIBILITY_PUBLIC);
1607 if (fields[c] == NULL)
1608 return false;
1609 ++c;
1610 }
1611
1612 fields[c] = NULL;
1613
1614 type = debug_make_struct_type (dhandle, true, size, fields);
1615 tag = true;
1616 }
1617 break;
1618
1619 case 'N':
1620 /* Enumeration. */
1621 {
1622 unsigned int alloc;
1623 const char **names;
1624 bfd_signed_vma *vals;
1625 unsigned int c;
1626
1627 alloc = 10;
1628 names = (const char **) xmalloc (alloc * sizeof *names);
1629 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1630 c = 0;
1631 while (1)
1632 {
1633 const char *name;
1634 unsigned long namlen;
1635 boolean present;
1636 bfd_vma val;
1637
1638 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1639 return false;
1640 if (! present)
1641 break;
1642 if (! ieee_read_number (info, pp, &val))
1643 return false;
1644
1645 /* If the length of the name is zero, then the value is
1646 actually the size of the enum. We ignore this
1647 information. FIXME. */
1648 if (namlen == 0)
1649 continue;
1650
1651 if (c + 1 >= alloc)
1652 {
1653 alloc += 10;
1654 names = ((const char **)
1655 xrealloc (names, alloc * sizeof *names));
1656 vals = ((bfd_signed_vma *)
1657 xrealloc (vals, alloc * sizeof *vals));
1658 }
1659
1660 names[c] = savestring (name, namlen);
1661 if (names[c] == NULL)
1662 return false;
1663 vals[c] = (bfd_signed_vma) val;
1664 ++c;
1665 }
1666
1667 names[c] = NULL;
1668
1669 type = debug_make_enum_type (dhandle, names, vals);
1670 tag = true;
1671 }
1672 break;
1673
1674 case 'O': /* Small pointer. We don't distinguish small and large
1675 pointers. FIXME. */
1676 case 'P': /* Large pointer. */
1677 {
1678 debug_type t;
1679
1680 if (! ieee_read_type_index (info, pp, &t))
1681 return false;
1682 type = debug_make_pointer_type (dhandle, t);
1683 }
1684 break;
1685
1686 case 'R':
1687 /* Range. */
1688 {
1689 bfd_vma low, high, signedp, size;
1690
1691 if (! ieee_read_number (info, pp, &low)
1692 || ! ieee_read_number (info, pp, &high)
1693 || ! ieee_read_number (info, pp, &signedp)
1694 || ! ieee_read_number (info, pp, &size))
1695 return false;
1696
1697 type = debug_make_range_type (dhandle,
1698 debug_make_int_type (dhandle, size,
1699 ! signedp),
1700 (bfd_signed_vma) low,
1701 (bfd_signed_vma) high);
1702 }
1703 break;
1704
1705 case 'S': /* Struct. */
1706 case 'U': /* Union. */
1707 {
1708 bfd_vma size;
1709 unsigned int alloc;
1710 debug_field *fields;
1711 unsigned int c;
1712
1713 if (! ieee_read_number (info, pp, &size))
1714 return false;
1715
1716 alloc = 10;
1717 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1718 c = 0;
1719 while (1)
1720 {
1721 const char *name;
1722 unsigned long namlen;
1723 boolean present;
1724 bfd_vma tindx;
1725 bfd_vma offset;
1726 debug_type ftype;
1727 bfd_vma bitsize;
1728
1729 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1730 return false;
1731 if (! present)
1732 break;
1733 if (! ieee_read_number (info, pp, &tindx)
1734 || ! ieee_read_number (info, pp, &offset))
1735 return false;
1736
1737 if (tindx < 256)
1738 {
1739 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1740 bitsize = 0;
1741 offset *= 8;
1742 }
1743 else
1744 {
1745 struct ieee_type *t;
1746
1747 tindx -= 256;
1748 if (! ieee_alloc_type (info, tindx, true))
1749 return false;
1750 t = info->types.types + tindx;
1751 ftype = t->type;
1752 bitsize = t->bitsize;
1753 if (bitsize == 0)
1754 offset *= 8;
1755 }
1756
1757 if (c + 1 >= alloc)
1758 {
1759 alloc += 10;
1760 fields = ((debug_field *)
1761 xrealloc (fields, alloc * sizeof *fields));
1762 }
1763
1764 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1765 ftype, offset, bitsize,
1766 DEBUG_VISIBILITY_PUBLIC);
1767 if (fields[c] == NULL)
1768 return false;
1769 ++c;
1770 }
1771
1772 fields[c] = NULL;
1773
1774 type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1775 tag = true;
1776 }
1777 break;
1778
1779 case 'T':
1780 /* Typedef. */
1781 if (! ieee_read_type_index (info, pp, &type))
1782 return false;
1783 typdef = true;
1784 break;
1785
1786 case 'X':
1787 /* Procedure. FIXME: This is an extern declaration, which we
1788 have no way of representing. */
1789 {
1790 bfd_vma attr;
1791 debug_type rtype;
1792 bfd_vma nargs;
1793 boolean present;
1794 struct ieee_var *pv;
1795
1796 /* FIXME: We ignore the attribute and the argument names. */
1797
1798 if (! ieee_read_number (info, pp, &attr)
1799 || ! ieee_read_type_index (info, pp, &rtype)
1800 || ! ieee_read_number (info, pp, &nargs))
1801 return false;
1802 do
1803 {
1804 const char *name;
1805 unsigned long namlen;
1806
1807 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1808 return false;
1809 }
1810 while (present);
1811
1812 pv = info->vars.vars + varindx;
1813 pv->kind = IEEE_EXTERNAL;
1814 if (pv->namlen > 0
1815 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1816 {
1817 /* Set up the return type as an indirect type pointing to
1818 the variable slot, so that we can change it to a
1819 reference later if appropriate. */
1820 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1821 *pv->pslot = rtype;
1822 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1823 (const char *) NULL);
1824 }
1825
1826 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1827 false);
1828 }
1829 break;
1830
1831 case 'V':
1832 /* Void. This is not documented, but the MRI compiler emits it. */
1833 type = debug_make_void_type (dhandle);
1834 break;
1835
1836 case 'Z':
1837 /* Array with 0 lower bound. */
1838 {
1839 debug_type etype;
1840 bfd_vma high;
1841
1842 if (! ieee_read_type_index (info, pp, &etype)
1843 || ! ieee_read_number (info, pp, &high))
1844 return false;
1845
1846 type = debug_make_array_type (dhandle, etype,
1847 ieee_builtin_type (info, ty_code_start,
1848 ((unsigned int)
1849 builtin_int)),
1850 0, (bfd_signed_vma) high, false);
1851 }
1852 break;
1853
1854 case 'c': /* Complex. */
1855 case 'd': /* Double complex. */
1856 {
1857 const char *name;
1858 unsigned long namlen;
1859
1860 /* FIXME: I don't know what the name means. */
1861
1862 if (! ieee_read_id (info, pp, &name, &namlen))
1863 return false;
1864
1865 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1866 }
1867 break;
1868
1869 case 'f':
1870 /* Pascal file name. FIXME. */
1871 ieee_error (info, ty_code_start, _("Pascal file name not supported"));
1872 return false;
1873
1874 case 'g':
1875 /* Bitfield type. */
1876 {
1877 bfd_vma signedp, bitsize, dummy;
1878 const bfd_byte *hold;
1879 boolean present;
1880
1881 if (! ieee_read_number (info, pp, &signedp)
1882 || ! ieee_read_number (info, pp, &bitsize))
1883 return false;
1884
1885 /* I think the documentation says that there is a type index,
1886 but some actual files do not have one. */
1887 hold = *pp;
1888 if (! ieee_read_optional_number (info, pp, &dummy, &present))
1889 return false;
1890 if (! present)
1891 {
1892 /* FIXME: This is just a guess. */
1893 type = debug_make_int_type (dhandle, 4,
1894 signedp ? false : true);
1895 }
1896 else
1897 {
1898 *pp = hold;
1899 if (! ieee_read_type_index (info, pp, &type))
1900 return false;
1901 }
1902 type_bitsize = bitsize;
1903 }
1904 break;
1905
1906 case 'n':
1907 /* Qualifier. */
1908 {
1909 bfd_vma kind;
1910 debug_type t;
1911
1912 if (! ieee_read_number (info, pp, &kind)
1913 || ! ieee_read_type_index (info, pp, &t))
1914 return false;
1915
1916 switch (kind)
1917 {
1918 default:
1919 ieee_error (info, ty_start, _("unsupported qualifer"));
1920 return false;
1921
1922 case 1:
1923 type = debug_make_const_type (dhandle, t);
1924 break;
1925
1926 case 2:
1927 type = debug_make_volatile_type (dhandle, t);
1928 break;
1929 }
1930 }
1931 break;
1932
1933 case 's':
1934 /* Set. */
1935 {
1936 bfd_vma size;
1937 debug_type etype;
1938
1939 if (! ieee_read_number (info, pp, &size)
1940 || ! ieee_read_type_index (info, pp, &etype))
1941 return false;
1942
1943 /* FIXME: We ignore the size. */
1944
1945 type = debug_make_set_type (dhandle, etype, false);
1946 }
1947 break;
1948
1949 case 'x':
1950 /* Procedure with compiler dependencies. */
1951 {
1952 struct ieee_var *pv;
1953 bfd_vma attr, frame_type, push_mask, nargs, level, father;
1954 debug_type rtype;
1955 debug_type *arg_types;
1956 boolean varargs;
1957 boolean present;
1958
1959 /* FIXME: We ignore some of this information. */
1960
1961 pv = info->vars.vars + varindx;
1962
1963 if (! ieee_read_number (info, pp, &attr)
1964 || ! ieee_read_number (info, pp, &frame_type)
1965 || ! ieee_read_number (info, pp, &push_mask)
1966 || ! ieee_read_type_index (info, pp, &rtype)
1967 || ! ieee_read_number (info, pp, &nargs))
1968 return false;
1969 if (nargs == (bfd_vma) -1)
1970 {
1971 arg_types = NULL;
1972 varargs = false;
1973 }
1974 else
1975 {
1976 unsigned int i;
1977
1978 arg_types = ((debug_type *)
1979 xmalloc ((nargs + 1) * sizeof *arg_types));
1980 for (i = 0; i < nargs; i++)
1981 if (! ieee_read_type_index (info, pp, arg_types + i))
1982 return false;
1983
1984 /* If the last type is pointer to void, this is really a
1985 varargs function. */
1986 varargs = false;
1987 if (nargs > 0)
1988 {
1989 debug_type last;
1990
1991 last = arg_types[nargs - 1];
1992 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1993 && (debug_get_type_kind (dhandle,
1994 debug_get_target_type (dhandle,
1995 last))
1996 == DEBUG_KIND_VOID))
1997 {
1998 --nargs;
1999 varargs = true;
2000 }
2001 }
2002
2003 /* If there are any pointer arguments, turn them into
2004 indirect types in case we later need to convert them to
2005 reference types. */
2006 for (i = 0; i < nargs; i++)
2007 {
2008 if (debug_get_type_kind (dhandle, arg_types[i])
2009 == DEBUG_KIND_POINTER)
2010 {
2011 if (arg_slots == NULL)
2012 {
2013 arg_slots = ((debug_type *)
2014 xmalloc (nargs * sizeof *arg_slots));
2015 memset (arg_slots, 0, nargs * sizeof *arg_slots);
2016 }
2017 arg_slots[i] = arg_types[i];
2018 arg_types[i] =
2019 debug_make_indirect_type (dhandle,
2020 arg_slots + i,
2021 (const char *) NULL);
2022 }
2023 }
2024
2025 arg_types[nargs] = DEBUG_TYPE_NULL;
2026 }
2027 if (! ieee_read_number (info, pp, &level)
2028 || ! ieee_read_optional_number (info, pp, &father, &present))
2029 return false;
2030
2031 /* We can't distinguish between a global function and a static
2032 function. */
2033 pv->kind = IEEE_FUNCTION;
2034
2035 if (pv->namlen > 0
2036 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
2037 {
2038 /* Set up the return type as an indirect type pointing to
2039 the variable slot, so that we can change it to a
2040 reference later if appropriate. */
2041 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
2042 *pv->pslot = rtype;
2043 rtype = debug_make_indirect_type (dhandle, pv->pslot,
2044 (const char *) NULL);
2045 }
2046
2047 type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
2048 }
2049 break;
2050 }
2051
2052 /* Record the type in the table. */
2053
2054 if (type == DEBUG_TYPE_NULL)
2055 return false;
2056
2057 info->vars.vars[varindx].type = type;
2058
2059 if ((tag || typdef)
2060 && info->vars.vars[varindx].namlen > 0)
2061 {
2062 const char *name;
2063
2064 name = savestring (info->vars.vars[varindx].name,
2065 info->vars.vars[varindx].namlen);
2066 if (typdef)
2067 type = debug_name_type (dhandle, name, type);
2068 else if (tc == 'E' || tc == 'N')
2069 type = debug_tag_type (dhandle, name, type);
2070 else
2071 {
2072 struct ieee_tag *it;
2073
2074 /* We must allocate all struct tags as indirect types, so
2075 that if we later see a definition of the tag as a C++
2076 record we can update the indirect slot and automatically
2077 change all the existing references. */
2078 it = (struct ieee_tag *) xmalloc (sizeof *it);
2079 memset (it, 0, sizeof *it);
2080 it->next = info->tags;
2081 info->tags = it;
2082 it->name = name;
2083 it->slot = type;
2084
2085 type = debug_make_indirect_type (dhandle, &it->slot, name);
2086 type = debug_tag_type (dhandle, name, type);
2087
2088 it->type = type;
2089 }
2090 if (type == NULL)
2091 return false;
2092 }
2093
2094 info->types.types[typeindx].type = type;
2095 info->types.types[typeindx].arg_slots = arg_slots;
2096 info->types.types[typeindx].bitsize = type_bitsize;
2097
2098 /* We may have already allocated type as an indirect type pointing
2099 to slot. It does no harm to replace the indirect type with the
2100 real type. Filling in slot as well handles the indirect types
2101 which are already hanging around. */
2102 if (info->types.types[typeindx].pslot != NULL)
2103 *info->types.types[typeindx].pslot = type;
2104
2105 return true;
2106}
2107
2108/* Parse an ATN record. */
2109
2110static boolean
2111parse_ieee_atn (info, pp)
2112 struct ieee_info *info;
2113 const bfd_byte **pp;
2114{
2115 const bfd_byte *atn_start, *atn_code_start;
2116 bfd_vma varindx;
2117 struct ieee_var *pvar;
2118 debug_type type;
2119 bfd_vma atn_code;
2120 PTR dhandle;
2121 bfd_vma v, v2, v3, v4, v5;
2122 const char *name;
2123 unsigned long namlen;
2124 char *namcopy;
2125 boolean present;
2126 int blocktype;
2127
2128 atn_start = *pp;
2129
2130 if (! ieee_read_number (info, pp, &varindx)
2131 || ! ieee_read_type_index (info, pp, &type))
2132 return false;
2133
2134 atn_code_start = *pp;
2135
2136 if (! ieee_read_number (info, pp, &atn_code))
2137 return false;
2138
2139 if (varindx == 0)
2140 {
2141 pvar = NULL;
2142 name = "";
2143 namlen = 0;
2144 }
2145 else if (varindx < 32)
2146 {
2147 /* The MRI compiler reportedly sometimes emits variable lifetime
2148 information for a register. We just ignore it. */
2149 if (atn_code == 9)
2150 return ieee_read_number (info, pp, &v);
2151
2152 ieee_error (info, atn_start, _("illegal variable index"));
2153 return false;
2154 }
2155 else
2156 {
2157 varindx -= 32;
2158 if (varindx >= info->vars.alloc
2159 || info->vars.vars[varindx].name == NULL)
2160 {
2161 /* The MRI compiler or linker sometimes omits the NN record
2162 for a pmisc record. */
2163 if (atn_code == 62)
2164 {
2165 if (varindx >= info->vars.alloc)
2166 {
2167 unsigned int alloc;
2168
2169 alloc = info->vars.alloc;
2170 if (alloc == 0)
2171 alloc = 4;
2172 while (varindx >= alloc)
2173 alloc *= 2;
2174 info->vars.vars = ((struct ieee_var *)
2175 xrealloc (info->vars.vars,
2176 (alloc
2177 * sizeof *info->vars.vars)));
2178 memset (info->vars.vars + info->vars.alloc, 0,
2179 ((alloc - info->vars.alloc)
2180 * sizeof *info->vars.vars));
2181 info->vars.alloc = alloc;
2182 }
2183
2184 pvar = info->vars.vars + varindx;
2185 pvar->name = "";
2186 pvar->namlen = 0;
2187 }
2188 else
2189 {
2190 ieee_error (info, atn_start, _("undefined variable in ATN"));
2191 return false;
2192 }
2193 }
2194
2195 pvar = info->vars.vars + varindx;
2196
2197 pvar->type = type;
2198
2199 name = pvar->name;
2200 namlen = pvar->namlen;
2201 }
2202
2203 dhandle = info->dhandle;
2204
2205 /* If we are going to call debug_record_variable with a pointer
2206 type, change the type to an indirect type so that we can later
2207 change it to a reference type if we encounter a C++ pmisc 'R'
2208 record. */
2209 if (pvar != NULL
2210 && type != DEBUG_TYPE_NULL
2211 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2212 {
2213 switch (atn_code)
2214 {
2215 case 1:
2216 case 2:
2217 case 3:
2218 case 5:
2219 case 8:
2220 case 10:
2221 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2222 *pvar->pslot = type;
2223 type = debug_make_indirect_type (dhandle, pvar->pslot,
2224 (const char *) NULL);
2225 pvar->type = type;
2226 break;
2227 }
2228 }
2229
2230 switch (atn_code)
2231 {
2232 default:
2233 ieee_error (info, atn_code_start, _("unknown ATN type"));
2234 return false;
2235
2236 case 1:
2237 /* Automatic variable. */
2238 if (! ieee_read_number (info, pp, &v))
2239 return false;
2240 namcopy = savestring (name, namlen);
2241 if (type == NULL)
2242 type = debug_make_void_type (dhandle);
2243 if (pvar != NULL)
2244 pvar->kind = IEEE_LOCAL;
2245 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2246
2247 case 2:
2248 /* Register variable. */
2249 if (! ieee_read_number (info, pp, &v))
2250 return false;
2251 namcopy = savestring (name, namlen);
2252 if (type == NULL)
2253 type = debug_make_void_type (dhandle);
2254 if (pvar != NULL)
2255 pvar->kind = IEEE_LOCAL;
2256 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2257 ieee_regno_to_genreg (info->abfd, v));
2258
2259 case 3:
2260 /* Static variable. */
2261 if (! ieee_require_asn (info, pp, &v))
2262 return false;
2263 namcopy = savestring (name, namlen);
2264 if (type == NULL)
2265 type = debug_make_void_type (dhandle);
2266 if (info->blockstack.bsp <= info->blockstack.stack)
2267 blocktype = 0;
2268 else
2269 blocktype = info->blockstack.bsp[-1].kind;
2270 if (pvar != NULL)
2271 {
2272 if (blocktype == 4 || blocktype == 6)
2273 pvar->kind = IEEE_LOCAL;
2274 else
2275 pvar->kind = IEEE_STATIC;
2276 }
2277 return debug_record_variable (dhandle, namcopy, type,
2278 (blocktype == 4 || blocktype == 6
2279 ? DEBUG_LOCAL_STATIC
2280 : DEBUG_STATIC),
2281 v);
2282
2283 case 4:
2284 /* External function. We don't currently record these. FIXME. */
2285 if (pvar != NULL)
2286 pvar->kind = IEEE_EXTERNAL;
2287 return true;
2288
2289 case 5:
2290 /* External variable. We don't currently record these. FIXME. */
2291 if (pvar != NULL)
2292 pvar->kind = IEEE_EXTERNAL;
2293 return true;
2294
2295 case 7:
2296 if (! ieee_read_number (info, pp, &v)
2297 || ! ieee_read_number (info, pp, &v2)
2298 || ! ieee_read_optional_number (info, pp, &v3, &present))
2299 return false;
2300 if (present)
2301 {
2302 if (! ieee_read_optional_number (info, pp, &v4, &present))
2303 return false;
2304 }
2305
2306 /* We just ignore the two optional fields in v3 and v4, since
2307 they are not defined. */
2308
2309 if (! ieee_require_asn (info, pp, &v3))
2310 return false;
2311
2312 /* We have no way to record the column number. FIXME. */
2313
2314 return debug_record_line (dhandle, v, v3);
2315
2316 case 8:
2317 /* Global variable. */
2318 if (! ieee_require_asn (info, pp, &v))
2319 return false;
2320 namcopy = savestring (name, namlen);
2321 if (type == NULL)
2322 type = debug_make_void_type (dhandle);
2323 if (pvar != NULL)
2324 pvar->kind = IEEE_GLOBAL;
2325 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2326
2327 case 9:
2328 /* Variable lifetime information. */
2329 if (! ieee_read_number (info, pp, &v))
2330 return false;
2331
2332 /* We have no way to record this information. FIXME. */
2333 return true;
2334
2335 case 10:
2336 /* Locked register. The spec says that there are two required
2337 fields, but at least on occasion the MRI compiler only emits
2338 one. */
2339 if (! ieee_read_number (info, pp, &v)
2340 || ! ieee_read_optional_number (info, pp, &v2, &present))
2341 return false;
2342
2343 /* I think this means a variable that is both in a register and
2344 a frame slot. We ignore the frame slot. FIXME. */
2345
2346 namcopy = savestring (name, namlen);
2347 if (type == NULL)
2348 type = debug_make_void_type (dhandle);
2349 if (pvar != NULL)
2350 pvar->kind = IEEE_LOCAL;
2351 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2352
2353 case 11:
2354 /* Reserved for FORTRAN common. */
2355 ieee_error (info, atn_code_start, _("unsupported ATN11"));
2356
2357 /* Return true to keep going. */
2358 return true;
2359
2360 case 12:
2361 /* Based variable. */
2362 v3 = 0;
2363 v4 = 0x80;
2364 v5 = 0;
2365 if (! ieee_read_number (info, pp, &v)
2366 || ! ieee_read_number (info, pp, &v2)
2367 || ! ieee_read_optional_number (info, pp, &v3, &present))
2368 return false;
2369 if (present)
2370 {
2371 if (! ieee_read_optional_number (info, pp, &v4, &present))
2372 return false;
2373 if (present)
2374 {
2375 if (! ieee_read_optional_number (info, pp, &v5, &present))
2376 return false;
2377 }
2378 }
2379
2380 /* We have no way to record this information. FIXME. */
2381
2382 ieee_error (info, atn_code_start, _("unsupported ATN12"));
2383
2384 /* Return true to keep going. */
2385 return true;
2386
2387 case 16:
2388 /* Constant. The description of this that I have is ambiguous,
2389 so I'm not going to try to implement it. */
2390 if (! ieee_read_number (info, pp, &v)
2391 || ! ieee_read_optional_number (info, pp, &v2, &present))
2392 return false;
2393 if (present)
2394 {
2395 if (! ieee_read_optional_number (info, pp, &v2, &present))
2396 return false;
2397 if (present)
2398 {
2399 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2400 return false;
2401 }
2402 }
2403
2404 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2405 {
2406 if (! ieee_require_asn (info, pp, &v3))
2407 return false;
2408 }
2409
2410 return true;
2411
2412 case 19:
2413 /* Static variable from assembler. */
2414 v2 = 0;
2415 if (! ieee_read_number (info, pp, &v)
2416 || ! ieee_read_optional_number (info, pp, &v2, &present)
2417 || ! ieee_require_asn (info, pp, &v3))
2418 return false;
2419 namcopy = savestring (name, namlen);
2420 /* We don't really handle this correctly. FIXME. */
2421 return debug_record_variable (dhandle, namcopy,
2422 debug_make_void_type (dhandle),
2423 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2424 v3);
2425
2426 case 62:
2427 /* Procedure miscellaneous information. */
2428 case 63:
2429 /* Variable miscellaneous information. */
2430 case 64:
2431 /* Module miscellaneous information. */
2432 if (! ieee_read_number (info, pp, &v)
2433 || ! ieee_read_number (info, pp, &v2)
2434 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2435 return false;
2436
2437 if (atn_code == 62 && v == 80)
2438 {
2439 if (present)
2440 {
2441 ieee_error (info, atn_code_start,
2442 _("unexpected string in C++ misc"));
2443 return false;
2444 }
2445 return ieee_read_cxx_misc (info, pp, v2);
2446 }
2447
2448 /* We just ignore all of this stuff. FIXME. */
2449
2450 for (; v2 > 0; --v2)
2451 {
2452 switch ((ieee_record_enum_type) **pp)
2453 {
2454 default:
2455 ieee_error (info, *pp, _("bad misc record"));
2456 return false;
2457
2458 case ieee_at_record_enum:
2459 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2460 return false;
2461 break;
2462
2463 case ieee_e2_first_byte_enum:
2464 if (! ieee_require_asn (info, pp, &v3))
2465 return false;
2466 break;
2467 }
2468 }
2469
2470 return true;
2471 }
2472
2473 /*NOTREACHED*/
2474}
2475
2476/* Handle C++ debugging miscellaneous records. This is called for
2477 procedure miscellaneous records of type 80. */
2478
2479static boolean
2480ieee_read_cxx_misc (info, pp, count)
2481 struct ieee_info *info;
2482 const bfd_byte **pp;
2483 unsigned long count;
2484{
2485 const bfd_byte *start;
2486 bfd_vma category;
2487
2488 start = *pp;
2489
2490 /* Get the category of C++ misc record. */
2491 if (! ieee_require_asn (info, pp, &category))
2492 return false;
2493 --count;
2494
2495 switch (category)
2496 {
2497 default:
2498 ieee_error (info, start, _("unrecognized C++ misc record"));
2499 return false;
2500
2501 case 'T':
2502 if (! ieee_read_cxx_class (info, pp, count))
2503 return false;
2504 break;
2505
2506 case 'M':
2507 {
2508 bfd_vma flags;
2509 const char *name;
2510 unsigned long namlen;
2511
2512 /* The IEEE spec indicates that the 'M' record only has a
2513 flags field. The MRI compiler also emits the name of the
2514 function. */
2515
2516 if (! ieee_require_asn (info, pp, &flags))
2517 return false;
2518 if (*pp < info->pend
2519 && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2520 {
2521 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2522 return false;
2523 }
2524
2525 /* This is emitted for method functions, but I don't think we
2526 care very much. It might help if it told us useful
2527 information like the class with which this function is
2528 associated, but it doesn't, so it isn't helpful. */
2529 }
2530 break;
2531
2532 case 'B':
2533 if (! ieee_read_cxx_defaults (info, pp, count))
2534 return false;
2535 break;
2536
2537 case 'z':
2538 {
2539 const char *name, *mangled, *class;
2540 unsigned long namlen, mangledlen, classlen;
2541 bfd_vma control;
2542
2543 /* Pointer to member. */
2544
2545 if (! ieee_require_atn65 (info, pp, &name, &namlen)
2546 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2547 || ! ieee_require_atn65 (info, pp, &class, &classlen)
2548 || ! ieee_require_asn (info, pp, &control))
2549 return false;
2550
2551 /* FIXME: We should now track down name and change its type. */
2552 }
2553 break;
2554
2555 case 'R':
2556 if (! ieee_read_reference (info, pp))
2557 return false;
2558 break;
2559 }
2560
2561 return true;
2562}
2563
2564/* Read a C++ class definition. This is a pmisc type 80 record of
2565 category 'T'. */
2566
2567static boolean
2568ieee_read_cxx_class (info, pp, count)
2569 struct ieee_info *info;
2570 const bfd_byte **pp;
2571 unsigned long count;
2572{
2573 const bfd_byte *start;
2574 bfd_vma class;
2575 const char *tag;
2576 unsigned long taglen;
2577 struct ieee_tag *it;
2578 PTR dhandle;
2579 debug_field *fields;
2580 unsigned int field_count, field_alloc;
2581 debug_baseclass *baseclasses;
2582 unsigned int baseclasses_count, baseclasses_alloc;
2583 const debug_field *structfields;
2584 struct ieee_method
2585 {
2586 const char *name;
2587 unsigned long namlen;
2588 debug_method_variant *variants;
2589 unsigned count;
2590 unsigned int alloc;
2591 } *methods;
2592 unsigned int methods_count, methods_alloc;
2593 debug_type vptrbase;
2594 boolean ownvptr;
2595 debug_method *dmethods;
2596
2597 start = *pp;
2598
2599 if (! ieee_require_asn (info, pp, &class))
2600 return false;
2601 --count;
2602
2603 if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2604 return false;
2605 --count;
2606
2607 /* Find the C struct with this name. */
2608 for (it = info->tags; it != NULL; it = it->next)
2609 if (it->name[0] == tag[0]
2610 && strncmp (it->name, tag, taglen) == 0
2611 && strlen (it->name) == taglen)
2612 break;
2613 if (it == NULL)
2614 {
2615 ieee_error (info, start, _("undefined C++ object"));
2616 return false;
2617 }
2618
2619 dhandle = info->dhandle;
2620
2621 fields = NULL;
2622 field_count = 0;
2623 field_alloc = 0;
2624 baseclasses = NULL;
2625 baseclasses_count = 0;
2626 baseclasses_alloc = 0;
2627 methods = NULL;
2628 methods_count = 0;
2629 methods_alloc = 0;
2630 vptrbase = DEBUG_TYPE_NULL;
2631 ownvptr = false;
2632
2633 structfields = debug_get_fields (dhandle, it->type);
2634
2635 while (count > 0)
2636 {
2637 bfd_vma id;
2638 const bfd_byte *spec_start;
2639
2640 spec_start = *pp;
2641
2642 if (! ieee_require_asn (info, pp, &id))
2643 return false;
2644 --count;
2645
2646 switch (id)
2647 {
2648 default:
2649 ieee_error (info, spec_start, _("unrecognized C++ object spec"));
2650 return false;
2651
2652 case 'b':
2653 {
2654 bfd_vma flags, cinline;
2655 const char *basename, *fieldname;
2656 unsigned long baselen, fieldlen;
2657 char *basecopy;
2658 debug_type basetype;
2659 bfd_vma bitpos;
2660 boolean virtualp;
2661 enum debug_visibility visibility;
2662 debug_baseclass baseclass;
2663
2664 /* This represents a base or friend class. */
2665
2666 if (! ieee_require_asn (info, pp, &flags)
2667 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
2668 || ! ieee_require_asn (info, pp, &cinline)
2669 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2670 return false;
2671 count -= 4;
2672
2673 /* We have no way of recording friend information, so we
2674 just ignore it. */
2675 if ((flags & BASEFLAGS_FRIEND) != 0)
2676 break;
2677
2678 /* I assume that either all of the members of the
2679 baseclass are included in the object, starting at the
2680 beginning of the object, or that none of them are
2681 included. */
2682
2683 if ((fieldlen == 0) == (cinline == 0))
2684 {
2685 ieee_error (info, start, _("unsupported C++ object type"));
2686 return false;
2687 }
2688
2689 basecopy = savestring (basename, baselen);
2690 basetype = debug_find_tagged_type (dhandle, basecopy,
2691 DEBUG_KIND_ILLEGAL);
2692 free (basecopy);
2693 if (basetype == DEBUG_TYPE_NULL)
2694 {
2695 ieee_error (info, start, _("C++ base class not defined"));
2696 return false;
2697 }
2698
2699 if (fieldlen == 0)
2700 bitpos = 0;
2701 else
2702 {
2703 const debug_field *pf;
2704
2705 if (structfields == NULL)
2706 {
2707 ieee_error (info, start, _("C++ object has no fields"));
2708 return false;
2709 }
2710
2711 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2712 {
2713 const char *fname;
2714
2715 fname = debug_get_field_name (dhandle, *pf);
2716 if (fname == NULL)
2717 return false;
2718 if (fname[0] == fieldname[0]
2719 && strncmp (fname, fieldname, fieldlen) == 0
2720 && strlen (fname) == fieldlen)
2721 break;
2722 }
2723 if (*pf == DEBUG_FIELD_NULL)
2724 {
2725 ieee_error (info, start,
2726 _("C++ base class not found in container"));
2727 return false;
2728 }
2729
2730 bitpos = debug_get_field_bitpos (dhandle, *pf);
2731 }
2732
2733 if ((flags & BASEFLAGS_VIRTUAL) != 0)
2734 virtualp = true;
2735 else
2736 virtualp = false;
2737 if ((flags & BASEFLAGS_PRIVATE) != 0)
2738 visibility = DEBUG_VISIBILITY_PRIVATE;
2739 else
2740 visibility = DEBUG_VISIBILITY_PUBLIC;
2741
2742 baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2743 virtualp, visibility);
2744 if (baseclass == DEBUG_BASECLASS_NULL)
2745 return false;
2746
2747 if (baseclasses_count + 1 >= baseclasses_alloc)
2748 {
2749 baseclasses_alloc += 10;
2750 baseclasses = ((debug_baseclass *)
2751 xrealloc (baseclasses,
2752 (baseclasses_alloc
2753 * sizeof *baseclasses)));
2754 }
2755
2756 baseclasses[baseclasses_count] = baseclass;
2757 ++baseclasses_count;
2758 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2759 }
2760 break;
2761
2762 case 'd':
2763 {
2764 bfd_vma flags;
2765 const char *fieldname, *mangledname;
2766 unsigned long fieldlen, mangledlen;
2767 char *fieldcopy;
2768 boolean staticp;
2769 debug_type ftype;
2770 const debug_field *pf = NULL;
2771 enum debug_visibility visibility;
2772 debug_field field;
2773
2774 /* This represents a data member. */
2775
2776 if (! ieee_require_asn (info, pp, &flags)
2777 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2778 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2779 return false;
2780 count -= 3;
2781
2782 fieldcopy = savestring (fieldname, fieldlen);
2783
2784 staticp = (flags & CXXFLAGS_STATIC) != 0 ? true : false;
2785
2786 if (staticp)
2787 {
2788 struct ieee_var *pv, *pvend;
2789
2790 /* See if we can find a definition for this variable. */
2791 pv = info->vars.vars;
2792 pvend = pv + info->vars.alloc;
2793 for (; pv < pvend; pv++)
2794 if (pv->namlen == mangledlen
2795 && strncmp (pv->name, mangledname, mangledlen) == 0)
2796 break;
2797 if (pv < pvend)
2798 ftype = pv->type;
2799 else
2800 {
2801 /* This can happen if the variable is never used. */
2802 ftype = ieee_builtin_type (info, start,
2803 (unsigned int) builtin_void);
2804 }
2805 }
2806 else
2807 {
2808 unsigned int findx;
2809
2810 if (structfields == NULL)
2811 {
2812 ieee_error (info, start, _("C++ object has no fields"));
2813 return false;
2814 }
2815
2816 for (pf = structfields, findx = 0;
2817 *pf != DEBUG_FIELD_NULL;
2818 pf++, findx++)
2819 {
2820 const char *fname;
2821
2822 fname = debug_get_field_name (dhandle, *pf);
2823 if (fname == NULL)
2824 return false;
2825 if (fname[0] == mangledname[0]
2826 && strncmp (fname, mangledname, mangledlen) == 0
2827 && strlen (fname) == mangledlen)
2828 break;
2829 }
2830 if (*pf == DEBUG_FIELD_NULL)
2831 {
2832 ieee_error (info, start,
2833 _("C++ data member not found in container"));
2834 return false;
2835 }
2836
2837 ftype = debug_get_field_type (dhandle, *pf);
2838
2839 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2840 {
2841 /* We might need to convert this field into a
2842 reference type later on, so make it an indirect
2843 type. */
2844 if (it->fslots == NULL)
2845 {
2846 unsigned int fcnt;
2847 const debug_field *pfcnt;
2848
2849 fcnt = 0;
2850 for (pfcnt = structfields;
2851 *pfcnt != DEBUG_FIELD_NULL;
2852 pfcnt++)
2853 ++fcnt;
2854 it->fslots = ((debug_type *)
2855 xmalloc (fcnt * sizeof *it->fslots));
2856 memset (it->fslots, 0,
2857 fcnt * sizeof *it->fslots);
2858 }
2859
2860 if (ftype == DEBUG_TYPE_NULL)
2861 return false;
2862 it->fslots[findx] = ftype;
2863 ftype = debug_make_indirect_type (dhandle,
2864 it->fslots + findx,
2865 (const char *) NULL);
2866 }
2867 }
2868 if (ftype == DEBUG_TYPE_NULL)
2869 return false;
2870
2871 switch (flags & CXXFLAGS_VISIBILITY)
2872 {
2873 default:
2874 ieee_error (info, start, _("unknown C++ visibility"));
2875 return false;
2876
2877 case CXXFLAGS_VISIBILITY_PUBLIC:
2878 visibility = DEBUG_VISIBILITY_PUBLIC;
2879 break;
2880
2881 case CXXFLAGS_VISIBILITY_PRIVATE:
2882 visibility = DEBUG_VISIBILITY_PRIVATE;
2883 break;
2884
2885 case CXXFLAGS_VISIBILITY_PROTECTED:
2886 visibility = DEBUG_VISIBILITY_PROTECTED;
2887 break;
2888 }
2889
2890 if (staticp)
2891 {
2892 char *mangledcopy;
2893
2894 mangledcopy = savestring (mangledname, mangledlen);
2895
2896 field = debug_make_static_member (dhandle, fieldcopy,
2897 ftype, mangledcopy,
2898 visibility);
2899 }
2900 else
2901 {
2902 bfd_vma bitpos, bitsize;
2903
2904 bitpos = debug_get_field_bitpos (dhandle, *pf);
2905 bitsize = debug_get_field_bitsize (dhandle, *pf);
2906 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2907 {
2908 ieee_error (info, start, _("bad C++ field bit pos or size"));
2909 return false;
2910 }
2911 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2912 bitsize, visibility);
2913 }
2914
2915 if (field == DEBUG_FIELD_NULL)
2916 return false;
2917
2918 if (field_count + 1 >= field_alloc)
2919 {
2920 field_alloc += 10;
2921 fields = ((debug_field *)
2922 xrealloc (fields, field_alloc * sizeof *fields));
2923 }
2924
2925 fields[field_count] = field;
2926 ++field_count;
2927 fields[field_count] = DEBUG_FIELD_NULL;
2928 }
2929 break;
2930
2931 case 'm':
2932 case 'v':
2933 {
2934 bfd_vma flags, voffset, control;
2935 const char *name, *mangled;
2936 unsigned long namlen, mangledlen;
2937 struct ieee_var *pv, *pvend;
2938 debug_type type;
2939 enum debug_visibility visibility;
2940 boolean constp, volatilep;
2941 char *mangledcopy;
2942 debug_method_variant mv;
2943 struct ieee_method *meth;
2944 unsigned int im;
2945
2946 if (! ieee_require_asn (info, pp, &flags)
2947 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2948 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2949 return false;
2950 count -= 3;
2951 if (id != 'v')
2952 voffset = 0;
2953 else
2954 {
2955 if (! ieee_require_asn (info, pp, &voffset))
2956 return false;
2957 --count;
2958 }
2959 if (! ieee_require_asn (info, pp, &control))
2960 return false;
2961 --count;
2962
2963 /* We just ignore the control information. */
2964
2965 /* We have no way to represent friend information, so we
2966 just ignore it. */
2967 if ((flags & CXXFLAGS_FRIEND) != 0)
2968 break;
2969
2970 /* We should already have seen a type for the function. */
2971 pv = info->vars.vars;
2972 pvend = pv + info->vars.alloc;
2973 for (; pv < pvend; pv++)
2974 if (pv->namlen == mangledlen
2975 && strncmp (pv->name, mangled, mangledlen) == 0)
2976 break;
2977
2978 if (pv >= pvend)
2979 {
2980 /* We won't have type information for this function if
2981 it is not included in this file. We don't try to
2982 handle this case. FIXME. */
2983 type = (debug_make_function_type
2984 (dhandle,
2985 ieee_builtin_type (info, start,
2986 (unsigned int) builtin_void),
2987 (debug_type *) NULL,
2988 false));
2989 }
2990 else
2991 {
2992 debug_type return_type;
2993 const debug_type *arg_types;
2994 boolean varargs;
2995
2996 if (debug_get_type_kind (dhandle, pv->type)
2997 != DEBUG_KIND_FUNCTION)
2998 {
2999 ieee_error (info, start,
3000 _("bad type for C++ method function"));
3001 return false;
3002 }
3003
3004 return_type = debug_get_return_type (dhandle, pv->type);
3005 arg_types = debug_get_parameter_types (dhandle, pv->type,
3006 &varargs);
3007 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
3008 {
3009 ieee_error (info, start,
3010 _("no type information for C++ method function"));
3011 return false;
3012 }
3013
3014 type = debug_make_method_type (dhandle, return_type, it->type,
3015 (debug_type *) arg_types,
3016 varargs);
3017 }
3018 if (type == DEBUG_TYPE_NULL)
3019 return false;
3020
3021 switch (flags & CXXFLAGS_VISIBILITY)
3022 {
3023 default:
3024 ieee_error (info, start, _("unknown C++ visibility"));
3025 return false;
3026
3027 case CXXFLAGS_VISIBILITY_PUBLIC:
3028 visibility = DEBUG_VISIBILITY_PUBLIC;
3029 break;
3030
3031 case CXXFLAGS_VISIBILITY_PRIVATE:
3032 visibility = DEBUG_VISIBILITY_PRIVATE;
3033 break;
3034
3035 case CXXFLAGS_VISIBILITY_PROTECTED:
3036 visibility = DEBUG_VISIBILITY_PROTECTED;
3037 break;
3038 }
3039
3040 constp = (flags & CXXFLAGS_CONST) != 0 ? true : false;
3041 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? true : false;
3042
3043 mangledcopy = savestring (mangled, mangledlen);
3044
3045 if ((flags & CXXFLAGS_STATIC) != 0)
3046 {
3047 if (id == 'v')
3048 {
3049 ieee_error (info, start, _("C++ static virtual method"));
3050 return false;
3051 }
3052 mv = debug_make_static_method_variant (dhandle, mangledcopy,
3053 type, visibility,
3054 constp, volatilep);
3055 }
3056 else
3057 {
3058 debug_type vcontext;
3059
3060 if (id != 'v')
3061 vcontext = DEBUG_TYPE_NULL;
3062 else
3063 {
3064 /* FIXME: How can we calculate this correctly? */
3065 vcontext = it->type;
3066 }
3067 mv = debug_make_method_variant (dhandle, mangledcopy, type,
3068 visibility, constp,
3069 volatilep, voffset,
3070 vcontext);
3071 }
3072 if (mv == DEBUG_METHOD_VARIANT_NULL)
3073 return false;
3074
3075 for (meth = methods, im = 0; im < methods_count; meth++, im++)
3076 if (meth->namlen == namlen
3077 && strncmp (meth->name, name, namlen) == 0)
3078 break;
3079 if (im >= methods_count)
3080 {
3081 if (methods_count >= methods_alloc)
3082 {
3083 methods_alloc += 10;
3084 methods = ((struct ieee_method *)
3085 xrealloc (methods,
3086 methods_alloc * sizeof *methods));
3087 }
3088 methods[methods_count].name = name;
3089 methods[methods_count].namlen = namlen;
3090 methods[methods_count].variants = NULL;
3091 methods[methods_count].count = 0;
3092 methods[methods_count].alloc = 0;
3093 meth = methods + methods_count;
3094 ++methods_count;
3095 }
3096
3097 if (meth->count + 1 >= meth->alloc)
3098 {
3099 meth->alloc += 10;
3100 meth->variants = ((debug_method_variant *)
3101 xrealloc (meth->variants,
3102 (meth->alloc
3103 * sizeof *meth->variants)));
3104 }
3105
3106 meth->variants[meth->count] = mv;
3107 ++meth->count;
3108 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
3109 }
3110 break;
3111
3112 case 'o':
3113 {
3114 bfd_vma spec;
3115
3116 /* We have no way to store this information, so we just
3117 ignore it. */
3118 if (! ieee_require_asn (info, pp, &spec))
3119 return false;
3120 --count;
3121 if ((spec & 4) != 0)
3122 {
3123 const char *filename;
3124 unsigned long filenamlen;
3125 bfd_vma lineno;
3126
3127 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
3128 || ! ieee_require_asn (info, pp, &lineno))
3129 return false;
3130 count -= 2;
3131 }
3132 else if ((spec & 8) != 0)
3133 {
3134 const char *mangled;
3135 unsigned long mangledlen;
3136
3137 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
3138 return false;
3139 --count;
3140 }
3141 else
3142 {
3143 ieee_error (info, start,
3144 _("unrecognized C++ object overhead spec"));
3145 return false;
3146 }
3147 }
3148 break;
3149
3150 case 'z':
3151 {
3152 const char *vname, *basename;
3153 unsigned long vnamelen, baselen;
3154 bfd_vma vsize, control;
3155
3156 /* A virtual table pointer. */
3157
3158 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3159 || ! ieee_require_asn (info, pp, &vsize)
3160 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
3161 || ! ieee_require_asn (info, pp, &control))
3162 return false;
3163 count -= 4;
3164
3165 /* We just ignore the control number. We don't care what
3166 the virtual table name is. We have no way to store the
3167 virtual table size, and I don't think we care anyhow. */
3168
3169 /* FIXME: We can't handle multiple virtual table pointers. */
3170
3171 if (baselen == 0)
3172 ownvptr = true;
3173 else
3174 {
3175 char *basecopy;
3176
3177 basecopy = savestring (basename, baselen);
3178 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3179 DEBUG_KIND_ILLEGAL);
3180 free (basecopy);
3181 if (vptrbase == DEBUG_TYPE_NULL)
3182 {
3183 ieee_error (info, start, _("undefined C++ vtable"));
3184 return false;
3185 }
3186 }
3187 }
3188 break;
3189 }
3190 }
3191
3192 /* Now that we have seen all the method variants, we can call
3193 debug_make_method for each one. */
3194
3195 if (methods_count == 0)
3196 dmethods = NULL;
3197 else
3198 {
3199 unsigned int i;
3200
3201 dmethods = ((debug_method *)
3202 xmalloc ((methods_count + 1) * sizeof *dmethods));
3203 for (i = 0; i < methods_count; i++)
3204 {
3205 char *namcopy;
3206
3207 namcopy = savestring (methods[i].name, methods[i].namlen);
3208 dmethods[i] = debug_make_method (dhandle, namcopy,
3209 methods[i].variants);
3210 if (dmethods[i] == DEBUG_METHOD_NULL)
3211 return false;
3212 }
3213 dmethods[i] = DEBUG_METHOD_NULL;
3214 free (methods);
3215 }
3216
3217 /* The struct type was created as an indirect type pointing at
3218 it->slot. We update it->slot to automatically update all
3219 references to this struct. */
3220 it->slot = debug_make_object_type (dhandle,
3221 class != 'u',
3222 debug_get_type_size (dhandle,
3223 it->slot),
3224 fields, baseclasses, dmethods,
3225 vptrbase, ownvptr);
3226 if (it->slot == DEBUG_TYPE_NULL)
3227 return false;
3228
3229 return true;
3230}
3231
3232/* Read C++ default argument value and reference type information. */
3233
3234static boolean
3235ieee_read_cxx_defaults (info, pp, count)
3236 struct ieee_info *info;
3237 const bfd_byte **pp;
3238 unsigned long count;
3239{
3240 const bfd_byte *start;
3241 const char *fnname;
3242 unsigned long fnlen;
3243 bfd_vma defcount;
3244
3245 start = *pp;
3246
3247 /* Giving the function name before the argument count is an addendum
3248 to the spec. The function name is demangled, though, so this
3249 record must always refer to the current function. */
3250
3251 if (info->blockstack.bsp <= info->blockstack.stack
3252 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3253 {
3254 ieee_error (info, start, _("C++ default values not in a function"));
3255 return false;
3256 }
3257
3258 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3259 || ! ieee_require_asn (info, pp, &defcount))
3260 return false;
3261 count -= 2;
3262
3263 while (defcount-- > 0)
3264 {
3265 bfd_vma type, val;
3266 const char *strval;
3267 unsigned long strvallen;
3268
3269 if (! ieee_require_asn (info, pp, &type))
3270 return false;
3271 --count;
3272
3273 switch (type)
3274 {
3275 case 0:
3276 case 4:
3277 break;
3278
3279 case 1:
3280 case 2:
3281 if (! ieee_require_asn (info, pp, &val))
3282 return false;
3283 --count;
3284 break;
3285
3286 case 3:
3287 case 7:
3288 if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3289 return false;
3290 --count;
3291 break;
3292
3293 default:
3294 ieee_error (info, start, _("unrecognized C++ default type"));
3295 return false;
3296 }
3297
3298 /* We have no way to record the default argument values, so we
3299 just ignore them. FIXME. */
3300 }
3301
3302 /* Any remaining arguments are indices of parameters that are really
3303 reference type. */
3304 if (count > 0)
3305 {
3306 PTR dhandle;
3307 debug_type *arg_slots;
3308
3309 dhandle = info->dhandle;
3310 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3311 while (count-- > 0)
3312 {
3313 bfd_vma indx;
3314 debug_type target;
3315
3316 if (! ieee_require_asn (info, pp, &indx))
3317 return false;
3318 /* The index is 1 based. */
3319 --indx;
3320 if (arg_slots == NULL
3321 || arg_slots[indx] == DEBUG_TYPE_NULL
3322 || (debug_get_type_kind (dhandle, arg_slots[indx])
3323 != DEBUG_KIND_POINTER))
3324 {
3325 ieee_error (info, start, _("reference parameter is not a pointer"));
3326 return false;
3327 }
3328
3329 target = debug_get_target_type (dhandle, arg_slots[indx]);
3330 arg_slots[indx] = debug_make_reference_type (dhandle, target);
3331 if (arg_slots[indx] == DEBUG_TYPE_NULL)
3332 return false;
3333 }
3334 }
3335
3336 return true;
3337}
3338
3339/* Read a C++ reference definition. */
3340
3341static boolean
3342ieee_read_reference (info, pp)
3343 struct ieee_info *info;
3344 const bfd_byte **pp;
3345{
3346 const bfd_byte *start;
3347 bfd_vma flags;
3348 const char *class, *name;
3349 unsigned long classlen, namlen;
3350 debug_type *pslot;
3351 debug_type target;
3352
3353 start = *pp;
3354
3355 if (! ieee_require_asn (info, pp, &flags))
3356 return false;
3357
3358 /* Giving the class name before the member name is in an addendum to
3359 the spec. */
3360 if (flags == 3)
3361 {
3362 if (! ieee_require_atn65 (info, pp, &class, &classlen))
3363 return false;
3364 }
3365
3366 if (! ieee_require_atn65 (info, pp, &name, &namlen))
3367 return false;
3368
3369 pslot = NULL;
3370 if (flags != 3)
3371 {
3372 int pass;
3373
3374 /* We search from the last variable indices to the first in
3375 hopes of finding local variables correctly. We search the
3376 local variables on the first pass, and the global variables
3377 on the second. FIXME: This probably won't work in all cases.
3378 On the other hand, I don't know what will. */
3379 for (pass = 0; pass < 2; pass++)
3380 {
3381 struct ieee_vars *vars;
3382 int i;
3383 struct ieee_var *pv = NULL;
3384
3385 if (pass == 0)
3386 vars = &info->vars;
3387 else
3388 {
3389 vars = info->global_vars;
3390 if (vars == NULL)
3391 break;
3392 }
3393
3394 for (i = (int) vars->alloc - 1; i >= 0; i--)
3395 {
3396 boolean found;
3397
3398 pv = vars->vars + i;
3399
3400 if (pv->pslot == NULL
3401 || pv->namlen != namlen
3402 || strncmp (pv->name, name, namlen) != 0)
3403 continue;
3404
3405 found = false;
3406 switch (flags)
3407 {
3408 default:
3409 ieee_error (info, start,
3410 _("unrecognized C++ reference type"));
3411 return false;
3412
3413 case 0:
3414 /* Global variable or function. */
3415 if (pv->kind == IEEE_GLOBAL
3416 || pv->kind == IEEE_EXTERNAL
3417 || pv->kind == IEEE_FUNCTION)
3418 found = true;
3419 break;
3420
3421 case 1:
3422 /* Global static variable or function. */
3423 if (pv->kind == IEEE_STATIC
3424 || pv->kind == IEEE_FUNCTION)
3425 found = true;
3426 break;
3427
3428 case 2:
3429 /* Local variable. */
3430 if (pv->kind == IEEE_LOCAL)
3431 found = true;
3432 break;
3433 }
3434
3435 if (found)
3436 break;
3437 }
3438
3439 if (i >= 0)
3440 {
3441 pslot = pv->pslot;
3442 break;
3443 }
3444 }
3445 }
3446 else
3447 {
3448 struct ieee_tag *it;
3449
3450 for (it = info->tags; it != NULL; it = it->next)
3451 {
3452 if (it->name[0] == class[0]
3453 && strncmp (it->name, class, classlen) == 0
3454 && strlen (it->name) == classlen)
3455 {
3456 if (it->fslots != NULL)
3457 {
3458 const debug_field *pf;
3459 unsigned int findx;
3460
3461 pf = debug_get_fields (info->dhandle, it->type);
3462 if (pf == NULL)
3463 {
3464 ieee_error (info, start,
3465 "C++ reference in class with no fields");
3466 return false;
3467 }
3468
3469 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3470 {
3471 const char *fname;
3472
3473 fname = debug_get_field_name (info->dhandle, *pf);
3474 if (fname == NULL)
3475 return false;
3476 if (strncmp (fname, name, namlen) == 0
3477 && strlen (fname) == namlen)
3478 {
3479 pslot = it->fslots + findx;
3480 break;
3481 }
3482 }
3483 }
3484
3485 break;
3486 }
3487 }
3488 }
3489
3490 if (pslot == NULL)
3491 {
3492 ieee_error (info, start, _("C++ reference not found"));
3493 return false;
3494 }
3495
3496 /* We allocated the type of the object as an indirect type pointing
3497 to *pslot, which we can now update to be a reference type. */
3498 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3499 {
3500 ieee_error (info, start, _("C++ reference is not pointer"));
3501 return false;
3502 }
3503
3504 target = debug_get_target_type (info->dhandle, *pslot);
3505 *pslot = debug_make_reference_type (info->dhandle, target);
3506 if (*pslot == DEBUG_TYPE_NULL)
3507 return false;
3508
3509 return true;
3510}
3511
3512/* Require an ASN record. */
3513
3514static boolean
3515ieee_require_asn (info, pp, pv)
3516 struct ieee_info *info;
3517 const bfd_byte **pp;
3518 bfd_vma *pv;
3519{
3520 const bfd_byte *start;
3521 ieee_record_enum_type c;
3522 bfd_vma varindx;
3523
3524 start = *pp;
3525
3526 c = (ieee_record_enum_type) **pp;
3527 if (c != ieee_e2_first_byte_enum)
3528 {
3529 ieee_error (info, start, _("missing required ASN"));
3530 return false;
3531 }
3532 ++*pp;
3533
3534 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3535 if (c != ieee_asn_record_enum)
3536 {
3537 ieee_error (info, start, _("missing required ASN"));
3538 return false;
3539 }
3540 ++*pp;
3541
3542 /* Just ignore the variable index. */
3543 if (! ieee_read_number (info, pp, &varindx))
3544 return false;
3545
3546 return ieee_read_expression (info, pp, pv);
3547}
3548
3549/* Require an ATN65 record. */
3550
3551static boolean
3552ieee_require_atn65 (info, pp, pname, pnamlen)
3553 struct ieee_info *info;
3554 const bfd_byte **pp;
3555 const char **pname;
3556 unsigned long *pnamlen;
3557{
3558 const bfd_byte *start;
3559 ieee_record_enum_type c;
3560 bfd_vma name_indx, type_indx, atn_code;
3561
3562 start = *pp;
3563
3564 c = (ieee_record_enum_type) **pp;
3565 if (c != ieee_at_record_enum)
3566 {
3567 ieee_error (info, start, _("missing required ATN65"));
3568 return false;
3569 }
3570 ++*pp;
3571
3572 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3573 if (c != ieee_atn_record_enum)
3574 {
3575 ieee_error (info, start, _("missing required ATN65"));
3576 return false;
3577 }
3578 ++*pp;
3579
3580 if (! ieee_read_number (info, pp, &name_indx)
3581 || ! ieee_read_number (info, pp, &type_indx)
3582 || ! ieee_read_number (info, pp, &atn_code))
3583 return false;
3584
3585 /* Just ignore name_indx. */
3586
3587 if (type_indx != 0 || atn_code != 65)
3588 {
3589 ieee_error (info, start, _("bad ATN65 record"));
3590 return false;
3591 }
3592
3593 return ieee_read_id (info, pp, pname, pnamlen);
3594}
3595\f
3596/* Convert a register number in IEEE debugging information into a
3597 generic register number. */
3598
3599static int
3600ieee_regno_to_genreg (abfd, r)
3601 bfd *abfd;
3602 int r;
3603{
3604 switch (bfd_get_arch (abfd))
3605 {
3606 case bfd_arch_m68k:
3607 /* For some reasons stabs adds 2 to the floating point register
3608 numbers. */
3609 if (r >= 16)
3610 r += 2;
3611 break;
3612
3613 case bfd_arch_i960:
3614 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3615 32 to 35 for fp0 to fp3. */
3616 --r;
3617 break;
3618
3619 default:
3620 break;
3621 }
3622
3623 return r;
3624}
3625
3626/* Convert a generic register number to an IEEE specific one. */
3627
3628static int
3629ieee_genreg_to_regno (abfd, r)
3630 bfd *abfd;
3631 int r;
3632{
3633 switch (bfd_get_arch (abfd))
3634 {
3635 case bfd_arch_m68k:
3636 /* For some reason stabs add 2 to the floating point register
3637 numbers. */
3638 if (r >= 18)
3639 r -= 2;
3640 break;
3641
3642 case bfd_arch_i960:
3643 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3644 32 to 35 for fp0 to fp3. */
3645 ++r;
3646 break;
3647
3648 default:
3649 break;
3650 }
3651
3652 return r;
3653}
3654\f
3655/* These routines build IEEE debugging information out of the generic
3656 debugging information. */
3657
3658/* We build the IEEE debugging information byte by byte. Rather than
3659 waste time copying data around, we use a linked list of buffers to
3660 hold the data. */
3661
3662#define IEEE_BUFSIZE (490)
3663
3664struct ieee_buf
3665{
3666 /* Next buffer. */
3667 struct ieee_buf *next;
3668 /* Number of data bytes in this buffer. */
3669 unsigned int c;
3670 /* Bytes. */
3671 bfd_byte buf[IEEE_BUFSIZE];
3672};
3673
3674/* A list of buffers. */
3675
3676struct ieee_buflist
3677{
3678 /* Head of list. */
3679 struct ieee_buf *head;
3680 /* Tail--last buffer on list. */
3681 struct ieee_buf *tail;
3682};
3683
3684/* In order to generate the BB11 blocks required by the HP emulator,
3685 we keep track of ranges of addresses which correspond to a given
3686 compilation unit. */
3687
3688struct ieee_range
3689{
3690 /* Next range. */
3691 struct ieee_range *next;
3692 /* Low address. */
3693 bfd_vma low;
3694 /* High address. */
3695 bfd_vma high;
3696};
3697
3698/* This structure holds information for a class on the type stack. */
3699
3700struct ieee_type_class
3701{
3702 /* The name index in the debugging information. */
3703 unsigned int indx;
3704 /* The pmisc records for the class. */
3705 struct ieee_buflist pmiscbuf;
3706 /* The number of pmisc records. */
3707 unsigned int pmisccount;
3708 /* The name of the class holding the virtual table, if not this
3709 class. */
3710 const char *vclass;
3711 /* Whether this class holds its own virtual table. */
3712 boolean ownvptr;
3713 /* The largest virtual table offset seen so far. */
3714 bfd_vma voffset;
3715 /* The current method. */
3716 const char *method;
3717 /* Additional pmisc records used to record fields of reference type. */
3718 struct ieee_buflist refs;
3719};
3720
3721/* This is how we store types for the writing routines. Most types
3722 are simply represented by a type index. */
3723
3724struct ieee_write_type
3725{
3726 /* Type index. */
3727 unsigned int indx;
3728 /* The size of the type, if known. */
3729 unsigned int size;
3730 /* The name of the type, if any. */
3731 const char *name;
3732 /* If this is a function or method type, we build the type here, and
3733 only add it to the output buffers if we need it. */
3734 struct ieee_buflist fndef;
3735 /* If this is a struct, this is where the struct definition is
3736 built. */
3737 struct ieee_buflist strdef;
3738 /* If this is a class, this is where the class information is built. */
3739 struct ieee_type_class *classdef;
3740 /* Whether the type is unsigned. */
3741 unsigned int unsignedp : 1;
3742 /* Whether this is a reference type. */
3743 unsigned int referencep : 1;
3744 /* Whether this is in the local type block. */
3745 unsigned int localp : 1;
3746 /* Whether this is a duplicate struct definition which we are
3747 ignoring. */
3748 unsigned int ignorep : 1;
3749};
3750
3751/* This is the type stack used by the debug writing routines. FIXME:
3752 We could generate more efficient output if we remembered when we
3753 have output a particular type before. */
3754
3755struct ieee_type_stack
3756{
3757 /* Next entry on stack. */
3758 struct ieee_type_stack *next;
3759 /* Type information. */
3760 struct ieee_write_type type;
3761};
3762
3763/* This is a list of associations between a name and some types.
3764 These are used for typedefs and tags. */
3765
3766struct ieee_name_type
3767{
3768 /* Next type for this name. */
3769 struct ieee_name_type *next;
3770 /* ID number. For a typedef, this is the index of the type to which
3771 this name is typedefed. */
3772 unsigned int id;
3773 /* Type. */
3774 struct ieee_write_type type;
3775 /* If this is a tag which has not yet been defined, this is the
3776 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3777 enum debug_type_kind kind;
3778};
3779
3780/* We use a hash table to associate names and types. */
3781
3782struct ieee_name_type_hash_table
3783{
3784 struct bfd_hash_table root;
3785};
3786
3787struct ieee_name_type_hash_entry
3788{
3789 struct bfd_hash_entry root;
3790 /* Information for this name. */
3791 struct ieee_name_type *types;
3792};
3793
3794/* This is a list of enums. */
3795
3796struct ieee_defined_enum
3797{
3798 /* Next enum. */
3799 struct ieee_defined_enum *next;
3800 /* Type index. */
3801 unsigned int indx;
3802 /* Whether this enum has been defined. */
3803 boolean defined;
3804 /* Tag. */
3805 const char *tag;
3806 /* Names. */
3807 const char **names;
3808 /* Values. */
3809 bfd_signed_vma *vals;
3810};
3811
3812/* We keep a list of modified versions of types, so that we don't
3813 output them more than once. */
3814
3815struct ieee_modified_type
3816{
3817 /* Pointer to this type. */
3818 unsigned int pointer;
3819 /* Function with unknown arguments returning this type. */
3820 unsigned int function;
3821 /* Const version of this type. */
3822 unsigned int const_qualified;
3823 /* Volatile version of this type. */
3824 unsigned int volatile_qualified;
3825 /* List of arrays of this type of various bounds. */
3826 struct ieee_modified_array_type *arrays;
3827};
3828
3829/* A list of arrays bounds. */
3830
3831struct ieee_modified_array_type
3832{
3833 /* Next array bounds. */
3834 struct ieee_modified_array_type *next;
3835 /* Type index with these bounds. */
3836 unsigned int indx;
3837 /* Low bound. */
3838 bfd_signed_vma low;
3839 /* High bound. */
3840 bfd_signed_vma high;
3841};
3842
3843/* This is a list of pending function parameter information. We don't
3844 output them until we see the first block. */
3845
3846struct ieee_pending_parm
3847{
3848 /* Next pending parameter. */
3849 struct ieee_pending_parm *next;
3850 /* Name. */
3851 const char *name;
3852 /* Type index. */
3853 unsigned int type;
3854 /* Whether the type is a reference. */
3855 boolean referencep;
3856 /* Kind. */
3857 enum debug_parm_kind kind;
3858 /* Value. */
3859 bfd_vma val;
3860};
3861
3862/* This is the handle passed down by debug_write. */
3863
3864struct ieee_handle
3865{
3866 /* BFD we are writing to. */
3867 bfd *abfd;
3868 /* Whether we got an error in a subroutine called via traverse or
3869 map_over_sections. */
3870 boolean error;
3871 /* Current data buffer list. */
3872 struct ieee_buflist *current;
3873 /* Current data buffer. */
3874 struct ieee_buf *curbuf;
3875 /* Filename of current compilation unit. */
3876 const char *filename;
3877 /* Module name of current compilation unit. */
3878 const char *modname;
3879 /* List of buffer for global types. */
3880 struct ieee_buflist global_types;
3881 /* List of finished data buffers. */
3882 struct ieee_buflist data;
3883 /* List of buffers for typedefs in the current compilation unit. */
3884 struct ieee_buflist types;
3885 /* List of buffers for variables and functions in the current
3886 compilation unit. */
3887 struct ieee_buflist vars;
3888 /* List of buffers for C++ class definitions in the current
3889 compilation unit. */
3890 struct ieee_buflist cxx;
3891 /* List of buffers for line numbers in the current compilation unit. */
3892 struct ieee_buflist linenos;
3893 /* Ranges for the current compilation unit. */
3894 struct ieee_range *ranges;
3895 /* Ranges for all debugging information. */
3896 struct ieee_range *global_ranges;
3897 /* Nested pending ranges. */
3898 struct ieee_range *pending_ranges;
3899 /* Type stack. */
3900 struct ieee_type_stack *type_stack;
3901 /* Next unallocated type index. */
3902 unsigned int type_indx;
3903 /* Next unallocated name index. */
3904 unsigned int name_indx;
3905 /* Typedefs. */
3906 struct ieee_name_type_hash_table typedefs;
3907 /* Tags. */
3908 struct ieee_name_type_hash_table tags;
3909 /* Enums. */
3910 struct ieee_defined_enum *enums;
3911 /* Modified versions of types. */
3912 struct ieee_modified_type *modified;
3913 /* Number of entries allocated in modified. */
3914 unsigned int modified_alloc;
3915 /* 4 byte complex type. */
3916 unsigned int complex_float_index;
3917 /* 8 byte complex type. */
3918 unsigned int complex_double_index;
3919 /* The depth of block nesting. This is 0 outside a function, and 1
3920 just after start_function is called. */
3921 unsigned int block_depth;
3922 /* The name of the current function. */
3923 const char *fnname;
3924 /* List of buffers for the type of the function we are currently
3925 writing out. */
3926 struct ieee_buflist fntype;
3927 /* List of buffers for the parameters of the function we are
3928 currently writing out. */
3929 struct ieee_buflist fnargs;
3930 /* Number of arguments written to fnargs. */
3931 unsigned int fnargcount;
3932 /* Pending function parameters. */
3933 struct ieee_pending_parm *pending_parms;
3934 /* Current line number filename. */
3935 const char *lineno_filename;
3936 /* Line number name index. */
3937 unsigned int lineno_name_indx;
3938 /* Filename of pending line number. */
3939 const char *pending_lineno_filename;
3940 /* Pending line number. */
3941 unsigned long pending_lineno;
3942 /* Address of pending line number. */
3943 bfd_vma pending_lineno_addr;
3944 /* Highest address seen at end of procedure. */
3945 bfd_vma highaddr;
3946};
3947
3948static boolean ieee_init_buffer
3949 PARAMS ((struct ieee_handle *, struct ieee_buflist *));
3950static boolean ieee_change_buffer
3951 PARAMS ((struct ieee_handle *, struct ieee_buflist *));
3952static boolean ieee_append_buffer
3953 PARAMS ((struct ieee_handle *, struct ieee_buflist *,
3954 struct ieee_buflist *));
3955static boolean ieee_real_write_byte PARAMS ((struct ieee_handle *, int));
3956static boolean ieee_write_2bytes PARAMS ((struct ieee_handle *, int));
3957static boolean ieee_write_number PARAMS ((struct ieee_handle *, bfd_vma));
3958static boolean ieee_write_id PARAMS ((struct ieee_handle *, const char *));
3959static boolean ieee_write_asn
3960 PARAMS ((struct ieee_handle *, unsigned int, bfd_vma));
3961static boolean ieee_write_atn65
3962 PARAMS ((struct ieee_handle *, unsigned int, const char *));
3963static boolean ieee_push_type
3964 PARAMS ((struct ieee_handle *, unsigned int, unsigned int, boolean,
3965 boolean));
3966static unsigned int ieee_pop_type PARAMS ((struct ieee_handle *));
3967static void ieee_pop_unused_type PARAMS ((struct ieee_handle *));
3968static unsigned int ieee_pop_type_used
3969 PARAMS ((struct ieee_handle *, boolean));
3970static boolean ieee_add_range
3971 PARAMS ((struct ieee_handle *, boolean, bfd_vma, bfd_vma));
3972static boolean ieee_start_range PARAMS ((struct ieee_handle *, bfd_vma));
3973static boolean ieee_end_range PARAMS ((struct ieee_handle *, bfd_vma));
3974static boolean ieee_define_type
3975 PARAMS ((struct ieee_handle *, unsigned int, boolean, boolean));
3976static boolean ieee_define_named_type
3977 PARAMS ((struct ieee_handle *, const char *, unsigned int, unsigned int,
3978 boolean, boolean, struct ieee_buflist *));
3979static struct ieee_modified_type *ieee_get_modified_info
3980 PARAMS ((struct ieee_handle *, unsigned int));
3981static struct bfd_hash_entry *ieee_name_type_newfunc
3982 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
3983static boolean ieee_write_undefined_tag
3984 PARAMS ((struct ieee_name_type_hash_entry *, PTR));
3985static boolean ieee_finish_compilation_unit PARAMS ((struct ieee_handle *));
3986static void ieee_add_bb11_blocks PARAMS ((bfd *, asection *, PTR));
3987static boolean ieee_add_bb11
3988 PARAMS ((struct ieee_handle *, asection *, bfd_vma, bfd_vma));
3989static boolean ieee_output_pending_parms PARAMS ((struct ieee_handle *));
3990static unsigned int ieee_vis_to_flags PARAMS ((enum debug_visibility));
3991static boolean ieee_class_method_var
3992 PARAMS ((struct ieee_handle *, const char *, enum debug_visibility, boolean,
3993 boolean, boolean, bfd_vma, boolean));
3994
3995static boolean ieee_start_compilation_unit PARAMS ((PTR, const char *));
3996static boolean ieee_start_source PARAMS ((PTR, const char *));
3997static boolean ieee_empty_type PARAMS ((PTR));
3998static boolean ieee_void_type PARAMS ((PTR));
3999static boolean ieee_int_type PARAMS ((PTR, unsigned int, boolean));
4000static boolean ieee_float_type PARAMS ((PTR, unsigned int));
4001static boolean ieee_complex_type PARAMS ((PTR, unsigned int));
4002static boolean ieee_bool_type PARAMS ((PTR, unsigned int));
4003static boolean ieee_enum_type
4004 PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
4005static boolean ieee_pointer_type PARAMS ((PTR));
4006static boolean ieee_function_type PARAMS ((PTR, int, boolean));
4007static boolean ieee_reference_type PARAMS ((PTR));
4008static boolean ieee_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
4009static boolean ieee_array_type
4010 PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
4011static boolean ieee_set_type PARAMS ((PTR, boolean));
4012static boolean ieee_offset_type PARAMS ((PTR));
4013static boolean ieee_method_type PARAMS ((PTR, boolean, int, boolean));
4014static boolean ieee_const_type PARAMS ((PTR));
4015static boolean ieee_volatile_type PARAMS ((PTR));
4016static boolean ieee_start_struct_type
4017 PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
4018static boolean ieee_struct_field
4019 PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
4020static boolean ieee_end_struct_type PARAMS ((PTR));
4021static boolean ieee_start_class_type
4022 PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
4023 boolean));
4024static boolean ieee_class_static_member
4025 PARAMS ((PTR, const char *, const char *, enum debug_visibility));
4026static boolean ieee_class_baseclass
4027 PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
4028static boolean ieee_class_start_method PARAMS ((PTR, const char *));
4029static boolean ieee_class_method_variant
4030 PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
4031 bfd_vma, boolean));
4032static boolean ieee_class_static_method_variant
4033 PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
4034static boolean ieee_class_end_method PARAMS ((PTR));
4035static boolean ieee_end_class_type PARAMS ((PTR));
4036static boolean ieee_typedef_type PARAMS ((PTR, const char *));
4037static boolean ieee_tag_type
4038 PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
4039static boolean ieee_typdef PARAMS ((PTR, const char *));
4040static boolean ieee_tag PARAMS ((PTR, const char *));
4041static boolean ieee_int_constant PARAMS ((PTR, const char *, bfd_vma));
4042static boolean ieee_float_constant PARAMS ((PTR, const char *, double));
4043static boolean ieee_typed_constant PARAMS ((PTR, const char *, bfd_vma));
4044static boolean ieee_variable
4045 PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
4046static boolean ieee_start_function PARAMS ((PTR, const char *, boolean));
4047static boolean ieee_function_parameter
4048 PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
4049static boolean ieee_start_block PARAMS ((PTR, bfd_vma));
4050static boolean ieee_end_block PARAMS ((PTR, bfd_vma));
4051static boolean ieee_end_function PARAMS ((PTR));
4052static boolean ieee_lineno
4053 PARAMS ((PTR, const char *, unsigned long, bfd_vma));
4054
4055static const struct debug_write_fns ieee_fns =
4056{
4057 ieee_start_compilation_unit,
4058 ieee_start_source,
4059 ieee_empty_type,
4060 ieee_void_type,
4061 ieee_int_type,
4062 ieee_float_type,
4063 ieee_complex_type,
4064 ieee_bool_type,
4065 ieee_enum_type,
4066 ieee_pointer_type,
4067 ieee_function_type,
4068 ieee_reference_type,
4069 ieee_range_type,
4070 ieee_array_type,
4071 ieee_set_type,
4072 ieee_offset_type,
4073 ieee_method_type,
4074 ieee_const_type,
4075 ieee_volatile_type,
4076 ieee_start_struct_type,
4077 ieee_struct_field,
4078 ieee_end_struct_type,
4079 ieee_start_class_type,
4080 ieee_class_static_member,
4081 ieee_class_baseclass,
4082 ieee_class_start_method,
4083 ieee_class_method_variant,
4084 ieee_class_static_method_variant,
4085 ieee_class_end_method,
4086 ieee_end_class_type,
4087 ieee_typedef_type,
4088 ieee_tag_type,
4089 ieee_typdef,
4090 ieee_tag,
4091 ieee_int_constant,
4092 ieee_float_constant,
4093 ieee_typed_constant,
4094 ieee_variable,
4095 ieee_start_function,
4096 ieee_function_parameter,
4097 ieee_start_block,
4098 ieee_end_block,
4099 ieee_end_function,
4100 ieee_lineno
4101};
4102
4103/* Initialize a buffer to be empty. */
4104
4105/*ARGSUSED*/
4106static boolean
4107ieee_init_buffer (info, buflist)
b4c96d0d 4108 struct ieee_handle *info ATTRIBUTE_UNUSED;
252b5132
RH		 4109 struct ieee_buflist *buflist;
4110{
4111 buflist->head = NULL;
4112 buflist->tail = NULL;
4113 return true;
4114}
4115
4116/* See whether a buffer list has any data. */
4117
4118#define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
4119
4120/* Change the current buffer to a specified buffer chain. */
4121
4122static boolean
4123ieee_change_buffer (info, buflist)
4124 struct ieee_handle *info;
4125 struct ieee_buflist *buflist;
4126{
4127 if (buflist->head == NULL)
4128 {
4129 struct ieee_buf *buf;
4130
4131 buf = (struct ieee_buf *) xmalloc (sizeof *buf);
4132 buf->next = NULL;
4133 buf->c = 0;
4134 buflist->head = buf;
4135 buflist->tail = buf;
4136 }
4137
4138 info->current = buflist;
4139 info->curbuf = buflist->tail;
4140
4141 return true;
4142}
4143
4144/* Append a buffer chain. */
4145
4146/*ARGSUSED*/
4147static boolean
4148ieee_append_buffer (info, mainbuf, newbuf)
b4c96d0d 4149 struct ieee_handle *info ATTRIBUTE_UNUSED;
252b5132
RH		 4150 struct ieee_buflist *mainbuf;
4151 struct ieee_buflist *newbuf;
4152{
4153 if (newbuf->head != NULL)
4154 {
4155 if (mainbuf->head == NULL)
4156 mainbuf->head = newbuf->head;
4157 else
4158 mainbuf->tail->next = newbuf->head;
4159 mainbuf->tail = newbuf->tail;
4160 }
4161 return true;
4162}
4163
4164/* Write a byte into the buffer. We use a macro for speed and a
4165 function for the complex cases. */
4166
4167#define ieee_write_byte(info, b) \
4168 ((info)->curbuf->c < IEEE_BUFSIZE \
4169 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), true) \
4170 : ieee_real_write_byte ((info), (b)))
4171
4172static boolean
4173ieee_real_write_byte (info, b)
4174 struct ieee_handle *info;
4175 int b;
4176{
4177 if (info->curbuf->c >= IEEE_BUFSIZE)
4178 {
4179 struct ieee_buf *n;
4180
4181 n = (struct ieee_buf *) xmalloc (sizeof *n);
4182 n->next = NULL;
4183 n->c = 0;
4184 if (info->current->head == NULL)
4185 info->current->head = n;
4186 else
4187 info->current->tail->next = n;
4188 info->current->tail = n;
4189 info->curbuf = n;
4190 }
4191
4192 info->curbuf->buf[info->curbuf->c] = b;
4193 ++info->curbuf->c;
4194
4195 return true;
4196}
4197
4198/* Write out two bytes. */
4199
4200static boolean
4201ieee_write_2bytes (info, i)
4202 struct ieee_handle *info;
4203 int i;
4204{
4205 return (ieee_write_byte (info, i >> 8)
4206 && ieee_write_byte (info, i & 0xff));
4207}
4208
4209/* Write out an integer. */
4210
4211static boolean
4212ieee_write_number (info, v)
4213 struct ieee_handle *info;
4214 bfd_vma v;
4215{
4216 bfd_vma t;
4217 bfd_byte ab[20];
4218 bfd_byte *p;
4219 unsigned int c;
4220
4221 if (v <= (bfd_vma) ieee_number_end_enum)
4222 return ieee_write_byte (info, (int) v);
4223
4224 t = v;
4225 p = ab + sizeof ab;
4226 while (t != 0)
4227 {
4228 *--p = t & 0xff;
4229 t >>= 8;
4230 }
4231 c = (ab + 20) - p;
4232
4233 if (c > (unsigned int) (ieee_number_repeat_end_enum
4234 - ieee_number_repeat_start_enum))
4235 {
4236 fprintf (stderr, _("IEEE numeric overflow: 0x"));
4237 fprintf_vma (stderr, v);
4238 fprintf (stderr, "\n");
4239 return false;
4240 }
4241
4242 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
4243 return false;
4244 for (; c > 0; --c, ++p)
4245 {
4246 if (! ieee_write_byte (info, *p))
4247 return false;
4248 }
4249
4250 return true;
4251}
4252
4253/* Write out a string. */
4254
4255static boolean
4256ieee_write_id (info, s)
4257 struct ieee_handle *info;
4258 const char *s;
4259{
4260 unsigned int len;
4261
4262 len = strlen (s);
4263 if (len <= 0x7f)
4264 {
4265 if (! ieee_write_byte (info, len))
4266 return false;
4267 }
4268 else if (len <= 0xff)
4269 {
4270 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
4271 || ! ieee_write_byte (info, len))
4272 return false;
4273 }
4274 else if (len <= 0xffff)
4275 {
4276 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
4277 || ! ieee_write_2bytes (info, len))
4278 return false;
4279 }
4280 else
4281 {
4282 fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
4283 return false;
4284 }
4285
4286 for (; *s != '\0'; s++)
4287 if (! ieee_write_byte (info, *s))
4288 return false;
4289
4290 return true;
4291}
4292
4293/* Write out an ASN record. */
4294
4295static boolean
4296ieee_write_asn (info, indx, val)
4297 struct ieee_handle *info;
4298 unsigned int indx;
4299 bfd_vma val;
4300{
4301 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
4302 && ieee_write_number (info, indx)
4303 && ieee_write_number (info, val));
4304}
4305
4306/* Write out an ATN65 record. */
4307
4308static boolean
4309ieee_write_atn65 (info, indx, s)
4310 struct ieee_handle *info;
4311 unsigned int indx;
4312 const char *s;
4313{
4314 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
4315 && ieee_write_number (info, indx)
4316 && ieee_write_number (info, 0)
4317 && ieee_write_number (info, 65)
4318 && ieee_write_id (info, s));
4319}
4320
4321/* Push a type index onto the type stack. */
4322
4323static boolean
4324ieee_push_type (info, indx, size, unsignedp, localp)
4325 struct ieee_handle *info;
4326 unsigned int indx;
4327 unsigned int size;
4328 boolean unsignedp;
4329 boolean localp;
4330{
4331 struct ieee_type_stack *ts;
4332
4333 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
4334 memset (ts, 0, sizeof *ts);
4335
4336 ts->type.indx = indx;
4337 ts->type.size = size;
4338 ts->type.unsignedp = unsignedp;
4339 ts->type.localp = localp;
4340
4341 ts->next = info->type_stack;
4342 info->type_stack = ts;
4343
4344 return true;
4345}
4346
4347/* Pop a type index off the type stack. */
4348
4349static unsigned int
4350ieee_pop_type (info)
4351 struct ieee_handle *info;
4352{
4353 return ieee_pop_type_used (info, true);
4354}
4355
4356/* Pop an unused type index off the type stack. */
4357
4358static void
4359ieee_pop_unused_type (info)
4360 struct ieee_handle *info;
4361{
4362 (void) ieee_pop_type_used (info, false);
4363}
4364
4365/* Pop a used or unused type index off the type stack. */
4366
4367static unsigned int
4368ieee_pop_type_used (info, used)
4369 struct ieee_handle *info;
4370 boolean used;
4371{
4372 struct ieee_type_stack *ts;
4373 unsigned int ret;
4374
4375 ts = info->type_stack;
4376 assert (ts != NULL);
4377
4378 /* If this is a function type, and we need it, we need to append the
4379 actual definition to the typedef block now. */
4380 if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
4381 {
4382 struct ieee_buflist *buflist;
4383
4384 if (ts->type.localp)
4385 {
4386 /* Make sure we have started the types block. */
4387 if (ieee_buffer_emptyp (&info->types))
4388 {
4389 if (! ieee_change_buffer (info, &info->types)
4390 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4391 || ! ieee_write_byte (info, 1)
4392 || ! ieee_write_number (info, 0)
4393 || ! ieee_write_id (info, info->modname))
4394 return false;
4395 }
4396 buflist = &info->types;
4397 }
4398 else
4399 {
4400 /* Make sure we started the global type block. */
4401 if (ieee_buffer_emptyp (&info->global_types))
4402 {
4403 if (! ieee_change_buffer (info, &info->global_types)
4404 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4405 || ! ieee_write_byte (info, 2)
4406 || ! ieee_write_number (info, 0)
4407 || ! ieee_write_id (info, ""))
4408 return false;
4409 }
4410 buflist = &info->global_types;
4411 }
4412
4413 if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
4414 return false;
4415 }
4416
4417 ret = ts->type.indx;
4418 info->type_stack = ts->next;
4419 free (ts);
4420 return ret;
4421}
4422
4423/* Add a range of bytes included in the current compilation unit. */
4424
4425static boolean
4426ieee_add_range (info, global, low, high)
4427 struct ieee_handle *info;
4428 boolean global;
4429 bfd_vma low;
4430 bfd_vma high;
4431{
4432 struct ieee_range **plist, *r, **pr;
4433
4434 if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
4435 return true;
4436
4437 if (global)
4438 plist = &info->global_ranges;
4439 else
4440 plist = &info->ranges;
4441
4442 for (r = *plist; r != NULL; r = r->next)
4443 {
4444 if (high >= r->low && low <= r->high)
4445 {
4446 /* The new range overlaps r. */
4447 if (low < r->low)
4448 r->low = low;
4449 if (high > r->high)
4450 r->high = high;
4451 pr = &r->next;
4452 while (*pr != NULL && (*pr)->low <= r->high)
4453 {
4454 struct ieee_range *n;
4455
4456 if ((*pr)->high > r->high)
4457 r->high = (*pr)->high;
4458 n = (*pr)->next;
4459 free (*pr);
4460 *pr = n;
4461 }
4462 return true;
4463 }
4464 }
4465
4466 r = (struct ieee_range *) xmalloc (sizeof *r);
4467 memset (r, 0, sizeof *r);
4468
4469 r->low = low;
4470 r->high = high;
4471
4472 /* Store the ranges sorted by address. */
4473 for (pr = plist; *pr != NULL; pr = &(*pr)->next)
4474 if ((*pr)->low > high)
4475 break;
4476 r->next = *pr;
4477 *pr = r;
4478
4479 return true;
4480}
4481
4482/* Start a new range for which we only have the low address. */
4483
4484static boolean
4485ieee_start_range (info, low)
4486 struct ieee_handle *info;
4487 bfd_vma low;
4488{
4489 struct ieee_range *r;
4490
4491 r = (struct ieee_range *) xmalloc (sizeof *r);
4492 memset (r, 0, sizeof *r);
4493 r->low = low;
4494 r->next = info->pending_ranges;
4495 info->pending_ranges = r;
4496 return true;
4497}
4498
4499/* Finish a range started by ieee_start_range. */
4500
4501static boolean
4502ieee_end_range (info, high)
4503 struct ieee_handle *info;
4504 bfd_vma high;
4505{
4506 struct ieee_range *r;
4507 bfd_vma low;
4508
4509 assert (info->pending_ranges != NULL);
4510 r = info->pending_ranges;
4511 low = r->low;
4512 info->pending_ranges = r->next;
4513 free (r);
4514 return ieee_add_range (info, false, low, high);
4515}
4516
4517/* Start defining a type. */
4518
4519static boolean
4520ieee_define_type (info, size, unsignedp, localp)
4521 struct ieee_handle *info;
4522 unsigned int size;
4523 boolean unsignedp;
4524 boolean localp;
4525{
4526 return ieee_define_named_type (info, (const char *) NULL,
4527 (unsigned int) -1, size, unsignedp,
4528 localp, (struct ieee_buflist *) NULL);
4529}
4530
4531/* Start defining a named type. */
4532
4533static boolean
4534ieee_define_named_type (info, name, indx, size, unsignedp, localp, buflist)
4535 struct ieee_handle *info;
4536 const char *name;
4537 unsigned int indx;
4538 unsigned int size;
4539 boolean unsignedp;
4540 boolean localp;
4541 struct ieee_buflist *buflist;
4542{
4543 unsigned int type_indx;
4544 unsigned int name_indx;
4545
4546 if (indx != (unsigned int) -1)
4547 type_indx = indx;
4548 else
4549 {
4550 type_indx = info->type_indx;
4551 ++info->type_indx;
4552 }
4553
4554 name_indx = info->name_indx;
4555 ++info->name_indx;
4556
4557 if (name == NULL)
4558 name = "";
4559
4560 /* If we were given a buffer, use it; otherwise, use either the
4561 local or the global type information, and make sure that the type
4562 block is started. */
4563 if (buflist != NULL)
4564 {
4565 if (! ieee_change_buffer (info, buflist))
4566 return false;
4567 }
4568 else if (localp)
4569 {
4570 if (! ieee_buffer_emptyp (&info->types))
4571 {
4572 if (! ieee_change_buffer (info, &info->types))
4573 return false;
4574 }
4575 else
4576 {
4577 if (! ieee_change_buffer (info, &info->types)
4578 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4579 || ! ieee_write_byte (info, 1)
4580 || ! ieee_write_number (info, 0)
4581 || ! ieee_write_id (info, info->modname))
4582 return false;
4583 }
4584 }
4585 else
4586 {
4587 if (! ieee_buffer_emptyp (&info->global_types))
4588 {
4589 if (! ieee_change_buffer (info, &info->global_types))
4590 return false;
4591 }
4592 else
4593 {
4594 if (! ieee_change_buffer (info, &info->global_types)
4595 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4596 || ! ieee_write_byte (info, 2)
4597 || ! ieee_write_number (info, 0)
4598 || ! ieee_write_id (info, ""))
4599 return false;
4600 }
4601 }
4602
4603 /* Push the new type on the type stack, write out an NN record, and
4604 write out the start of a TY record. The caller will then finish
4605 the TY record. */
4606 if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
4607 return false;
4608
4609 return (ieee_write_byte (info, (int) ieee_nn_record)
4610 && ieee_write_number (info, name_indx)
4611 && ieee_write_id (info, name)
4612 && ieee_write_byte (info, (int) ieee_ty_record_enum)
4613 && ieee_write_number (info, type_indx)
4614 && ieee_write_byte (info, 0xce)
4615 && ieee_write_number (info, name_indx));
4616}
4617
4618/* Get an entry to the list of modified versions of a type. */
4619
4620static struct ieee_modified_type *
4621ieee_get_modified_info (info, indx)
4622 struct ieee_handle *info;
4623 unsigned int indx;
4624{
4625 if (indx >= info->modified_alloc)
4626 {
4627 unsigned int nalloc;
4628
4629 nalloc = info->modified_alloc;
4630 if (nalloc == 0)
4631 nalloc = 16;
4632 while (indx >= nalloc)
4633 nalloc *= 2;
4634 info->modified = ((struct ieee_modified_type *)
4635 xrealloc (info->modified,
4636 nalloc * sizeof *info->modified));
4637 memset (info->modified + info->modified_alloc, 0,
4638 (nalloc - info->modified_alloc) * sizeof *info->modified);
4639 info->modified_alloc = nalloc;
4640 }
4641
4642 return info->modified + indx;
4643}
4644\f
4645/* Routines for the hash table mapping names to types. */
4646
4647/* Initialize an entry in the hash table. */
4648
4649static struct bfd_hash_entry *
4650ieee_name_type_newfunc (entry, table, string)
4651 struct bfd_hash_entry *entry;
4652 struct bfd_hash_table *table;
4653 const char *string;
4654{
4655 struct ieee_name_type_hash_entry *ret =
4656 (struct ieee_name_type_hash_entry *) entry;
4657
4658 /* Allocate the structure if it has not already been allocated by a
4659 subclass. */
4660 if (ret == NULL)
4661 ret = ((struct ieee_name_type_hash_entry *)
4662 bfd_hash_allocate (table, sizeof *ret));
4663 if (ret == NULL)
4664 return NULL;
4665
4666 /* Call the allocation method of the superclass. */
4667 ret = ((struct ieee_name_type_hash_entry *)
4668 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
4669 if (ret)
4670 {
4671 /* Set local fields. */
4672 ret->types = NULL;
4673 }
4674
4675 return (struct bfd_hash_entry *) ret;
4676}
4677
4678/* Look up an entry in the hash table. */
4679
4680#define ieee_name_type_hash_lookup(table, string, create, copy) \
4681 ((struct ieee_name_type_hash_entry *) \
4682 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4683
4684/* Traverse the hash table. */
4685
4686#define ieee_name_type_hash_traverse(table, func, info) \
4687 (bfd_hash_traverse \
4688 (&(table)->root, \
4689 (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
4690 (info)))
4691\f
4692/* The general routine to write out IEEE debugging information. */
4693
4694boolean
4695write_ieee_debugging_info (abfd, dhandle)
4696 bfd *abfd;
4697 PTR dhandle;
4698{
4699 struct ieee_handle info;
4700 asection *s;
4701 const char *err;
4702 struct ieee_buf *b;
4703
4704 memset (&info, 0, sizeof info);
4705 info.abfd = abfd;
4706 info.type_indx = 256;
4707 info.name_indx = 32;
4708
4709 if (! bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc)
4710 || ! bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc))
4711 return false;
4712
4713 if (! ieee_init_buffer (&info, &info.global_types)
4714 || ! ieee_init_buffer (&info, &info.data)
4715 || ! ieee_init_buffer (&info, &info.types)
4716 || ! ieee_init_buffer (&info, &info.vars)
4717 || ! ieee_init_buffer (&info, &info.cxx)
4718 || ! ieee_init_buffer (&info, &info.linenos)
4719 || ! ieee_init_buffer (&info, &info.fntype)
4720 || ! ieee_init_buffer (&info, &info.fnargs))
4721 return false;
4722
4723 if (! debug_write (dhandle, &ieee_fns, (PTR) &info))
4724 return false;
4725
4726 if (info.filename != NULL)
4727 {
4728 if (! ieee_finish_compilation_unit (&info))
4729 return false;
4730 }
4731
4732 /* Put any undefined tags in the global typedef information. */
4733 info.error = false;
4734 ieee_name_type_hash_traverse (&info.tags,
4735 ieee_write_undefined_tag,
4736 (PTR) &info);
4737 if (info.error)
4738 return false;
4739
4740 /* Prepend the global typedef information to the other data. */
4741 if (! ieee_buffer_emptyp (&info.global_types))
4742 {
4743 /* The HP debugger seems to have a bug in which it ignores the
4744 last entry in the global types, so we add a dummy entry. */
4745 if (! ieee_change_buffer (&info, &info.global_types)
4746 || ! ieee_write_byte (&info, (int) ieee_nn_record)
4747 || ! ieee_write_number (&info, info.name_indx)
4748 || ! ieee_write_id (&info, "")
4749 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
4750 || ! ieee_write_number (&info, info.type_indx)
4751 || ! ieee_write_byte (&info, 0xce)
4752 || ! ieee_write_number (&info, info.name_indx)
4753 || ! ieee_write_number (&info, 'P')
4754 || ! ieee_write_number (&info, (int) builtin_void + 32)
4755 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4756 return false;
4757
4758 if (! ieee_append_buffer (&info, &info.global_types, &info.data))
4759 return false;
4760 info.data = info.global_types;
4761 }
4762
4763 /* Make sure that we have declare BB11 blocks for each range in the
4764 file. They are added to info->vars. */
4765 info.error = false;
4766 if (! ieee_init_buffer (&info, &info.vars))
4767 return false;
4768 bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (PTR) &info);
4769 if (info.error)
4770 return false;
4771 if (! ieee_buffer_emptyp (&info.vars))
4772 {
4773 if (! ieee_change_buffer (&info, &info.vars)
4774 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4775 return false;
4776
4777 if (! ieee_append_buffer (&info, &info.data, &info.vars))
4778 return false;
4779 }
4780
4781 /* Now all the data is in info.data. Write it out to the BFD. We
4782 normally would need to worry about whether all the other sections
4783 are set up yet, but the IEEE backend will handle this particular
4784 case correctly regardless. */
4785 if (ieee_buffer_emptyp (&info.data))
4786 {
4787 /* There is no debugging information. */
4788 return true;
4789 }
4790 err = NULL;
4791 s = bfd_make_section (abfd, ".debug");
4792 if (s == NULL)
4793 err = "bfd_make_section";
4794 if (err == NULL)
4795 {
4796 if (! bfd_set_section_flags (abfd, s, SEC_DEBUGGING | SEC_HAS_CONTENTS))
4797 err = "bfd_set_section_flags";
4798 }
4799 if (err == NULL)
4800 {
4801 bfd_size_type size;
4802
4803 size = 0;
4804 for (b = info.data.head; b != NULL; b = b->next)
4805 size += b->c;
4806 if (! bfd_set_section_size (abfd, s, size))
4807 err = "bfd_set_section_size";
4808 }
4809 if (err == NULL)
4810 {
4811 file_ptr offset;
4812
4813 offset = 0;
4814 for (b = info.data.head; b != NULL; b = b->next)
4815 {
4816 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4817 {
4818 err = "bfd_set_section_contents";
4819 break;
4820 }
4821 offset += b->c;
4822 }
4823 }
4824
4825 if (err != NULL)
4826 {
4827 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4828 bfd_errmsg (bfd_get_error ()));
4829 return false;
4830 }
4831
4832 bfd_hash_table_free (&info.typedefs.root);
4833 bfd_hash_table_free (&info.tags.root);
4834
4835 return true;
4836}
4837
4838/* Write out information for an undefined tag. This is called via
4839 ieee_name_type_hash_traverse. */
4840
4841static boolean
4842ieee_write_undefined_tag (h, p)
4843 struct ieee_name_type_hash_entry *h;
4844 PTR p;
4845{
4846 struct ieee_handle *info = (struct ieee_handle *) p;
4847 struct ieee_name_type *nt;
4848
4849 for (nt = h->types; nt != NULL; nt = nt->next)
4850 {
4851 unsigned int name_indx;
4852 char code;
4853
4854 if (nt->kind == DEBUG_KIND_ILLEGAL)
4855 continue;
4856
4857 if (ieee_buffer_emptyp (&info->global_types))
4858 {
4859 if (! ieee_change_buffer (info, &info->global_types)
4860 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4861 || ! ieee_write_byte (info, 2)
4862 || ! ieee_write_number (info, 0)
4863 || ! ieee_write_id (info, ""))
4864 {
4865 info->error = true;
4866 return false;
4867 }
4868 }
4869 else
4870 {
4871 if (! ieee_change_buffer (info, &info->global_types))
4872 {
4873 info->error = true;
4874 return false;
4875 }
4876 }
4877
4878 name_indx = info->name_indx;
4879 ++info->name_indx;
4880 if (! ieee_write_byte (info, (int) ieee_nn_record)
4881 || ! ieee_write_number (info, name_indx)
4882 || ! ieee_write_id (info, nt->type.name)
4883 || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
4884 || ! ieee_write_number (info, nt->type.indx)
4885 || ! ieee_write_byte (info, 0xce)
4886 || ! ieee_write_number (info, name_indx))
4887 {
4888 info->error = true;
4889 return false;
4890 }
4891
4892 switch (nt->kind)
4893 {
4894 default:
4895 abort ();
4896 info->error = true;
4897 return false;
4898 case DEBUG_KIND_STRUCT:
4899 case DEBUG_KIND_CLASS:
4900 code = 'S';
4901 break;
4902 case DEBUG_KIND_UNION:
4903 case DEBUG_KIND_UNION_CLASS:
4904 code = 'U';
4905 break;
4906 case DEBUG_KIND_ENUM:
4907 code = 'E';
4908 break;
4909 }
4910 if (! ieee_write_number (info, code)
4911 || ! ieee_write_number (info, 0))
4912 {
4913 info->error = true;
4914 return false;
4915 }
4916 }
4917
4918 return true;
4919}
4920
4921/* Start writing out information for a compilation unit. */
4922
4923static boolean
4924ieee_start_compilation_unit (p, filename)
4925 PTR p;
4926 const char *filename;
4927{
4928 struct ieee_handle *info = (struct ieee_handle *) p;
4929 const char *modname;
5af11cab 4930 const char *backslash;
252b5132
RH		 4931 char *c, *s;
4932 unsigned int nindx;
4933
4934 if (info->filename != NULL)
4935 {
4936 if (! ieee_finish_compilation_unit (info))
4937 return false;
4938 }
4939
4940 info->filename = filename;
4941 modname = strrchr (filename, '/');
5af11cab
AM		 4942 /* We could have a mixed forward/back slash case. */
4943 backslash = strrchr (modname, '\\');
4944 if (backslash > modname)
4945 modname = backslash;
4946
252b5132
RH		 4947 if (modname != NULL)
4948 ++modname;
5af11cab
AM		 4949#ifdef HAVE_DOS_BASED_FILE_SYSTEM
4950 else if (filename[0] && filename[1] == ':')
4951 modname = filename + 2;
4952#endif
252b5132 4953 else
5af11cab
AM		 4954 modname = filename;
4955
252b5132
RH		 4956 c = xstrdup (modname);
4957 s = strrchr (c, '.');
4958 if (s != NULL)
4959 *s = '\0';
4960 info->modname = c;
4961
4962 if (! ieee_init_buffer (info, &info->types)
4963 || ! ieee_init_buffer (info, &info->vars)
4964 || ! ieee_init_buffer (info, &info->cxx)
4965 || ! ieee_init_buffer (info, &info->linenos))
4966 return false;
4967 info->ranges = NULL;
4968
4969 /* Always include a BB1 and a BB3 block. That is what the output of
4970 the MRI linker seems to look like. */
4971 if (! ieee_change_buffer (info, &info->types)
4972 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4973 || ! ieee_write_byte (info, 1)
4974 || ! ieee_write_number (info, 0)
4975 || ! ieee_write_id (info, info->modname))
4976 return false;
4977
4978 nindx = info->name_indx;
4979 ++info->name_indx;
4980 if (! ieee_change_buffer (info, &info->vars)
4981 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4982 || ! ieee_write_byte (info, 3)
4983 || ! ieee_write_number (info, 0)
4984 || ! ieee_write_id (info, info->modname))
4985 return false;
4986
4987 return true;
4988}
4989
4990/* Finish up a compilation unit. */
4991
4992static boolean
4993ieee_finish_compilation_unit (info)
4994 struct ieee_handle *info;
4995{
4996 struct ieee_range *r;
4997
4998 if (! ieee_buffer_emptyp (&info->types))
4999 {
5000 if (! ieee_change_buffer (info, &info->types)
5001 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
5002 return false;
5003 }
5004
5005 if (! ieee_buffer_emptyp (&info->cxx))
5006 {
5007 /* Append any C++ information to the global function and
5008 variable information. */
5009 assert (! ieee_buffer_emptyp (&info->vars));
5010 if (! ieee_change_buffer (info, &info->vars))
5011 return false;
5012
5013 /* We put the pmisc records in a dummy procedure, just as the
5014 MRI compiler does. */
5015 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5016 || ! ieee_write_byte (info, 6)
5017 || ! ieee_write_number (info, 0)
5018 || ! ieee_write_id (info, "__XRYCPP")
5019 || ! ieee_write_number (info, 0)
5020 || ! ieee_write_number (info, 0)
5021 || ! ieee_write_number (info, info->highaddr - 1)
5022 || ! ieee_append_buffer (info, &info->vars, &info->cxx)
5023 || ! ieee_change_buffer (info, &info->vars)
5024 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5025 || ! ieee_write_number (info, info->highaddr - 1))
5026 return false;
5027 }
5028
5029 if (! ieee_buffer_emptyp (&info->vars))
5030 {
5031 if (! ieee_change_buffer (info, &info->vars)
5032 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
5033 return false;
5034 }
5035
5036 if (info->pending_lineno_filename != NULL)
5037 {
5038 /* Force out the pending line number. */
5039 if (! ieee_lineno ((PTR) info, (const char *) NULL, 0, (bfd_vma) -1))
5040 return false;
5041 }
5042 if (! ieee_buffer_emptyp (&info->linenos))
5043 {
5044 if (! ieee_change_buffer (info, &info->linenos)
5045 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
5046 return false;
5047 if (strcmp (info->filename, info->lineno_filename) != 0)
5048 {
5049 /* We were not in the main file. We just closed the
5050 included line number block, and now we must close the
5051 main line number block. */
5052 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
5053 return false;
5054 }
5055 }
5056
5057 if (! ieee_append_buffer (info, &info->data, &info->types)
5058 || ! ieee_append_buffer (info, &info->data, &info->vars)
5059 || ! ieee_append_buffer (info, &info->data, &info->linenos))
5060 return false;
5061
5062 /* Build BB10/BB11 blocks based on the ranges we recorded. */
5063 if (! ieee_change_buffer (info, &info->data))
5064 return false;
5065
5066 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5067 || ! ieee_write_byte (info, 10)
5068 || ! ieee_write_number (info, 0)
5069 || ! ieee_write_id (info, info->modname)
5070 || ! ieee_write_id (info, "")
5071 || ! ieee_write_number (info, 0)
5072 || ! ieee_write_id (info, "GNU objcopy"))
5073 return false;
5074
5075 for (r = info->ranges; r != NULL; r = r->next)
5076 {
5077 bfd_vma low, high;
5078 asection *s;
5079 int kind;
5080
5081 low = r->low;
5082 high = r->high;
5083
5084 /* Find the section corresponding to this range. */
5085 for (s = info->abfd->sections; s != NULL; s = s->next)
5086 {
5087 if (bfd_get_section_vma (info->abfd, s) <= low
5088 && high <= (bfd_get_section_vma (info->abfd, s)
5089 + bfd_section_size (info->abfd, s)))
5090 break;
5091 }
5092
5093 if (s == NULL)
5094 {
5095 /* Just ignore this range. */
5096 continue;
5097 }
5098
5099 /* Coalesce ranges if it seems reasonable. */
5100 while (r->next != NULL
5101 && high + 0x1000 >= r->next->low
5102 && (r->next->high
5103 <= (bfd_get_section_vma (info->abfd, s)
5104 + bfd_section_size (info->abfd, s))))
5105 {
5106 r = r->next;
5107 high = r->high;
5108 }
5109
5110 if ((s->flags & SEC_CODE) != 0)
5111 kind = 1;
5112 else if ((s->flags & SEC_READONLY) != 0)
5113 kind = 3;
5114 else
5115 kind = 2;
5116
5117 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5118 || ! ieee_write_byte (info, 11)
5119 || ! ieee_write_number (info, 0)
5120 || ! ieee_write_id (info, "")
5121 || ! ieee_write_number (info, kind)
5122 || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
5123 || ! ieee_write_number (info, low)
5124 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5125 || ! ieee_write_number (info, high - low))
5126 return false;
5127
5128 /* Add this range to the list of global ranges. */
5129 if (! ieee_add_range (info, true, low, high))
5130 return false;
5131 }
5132
5133 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
5134 return false;
5135
5136 return true;
5137}
5138
5139/* Add BB11 blocks describing each range that we have not already
5140 described. */
5141
5142static void
5143ieee_add_bb11_blocks (abfd, sec, data)
b4c96d0d 5144 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 5145 asection *sec;
5146 PTR data;
5147{
5148 struct ieee_handle *info = (struct ieee_handle *) data;
5149 bfd_vma low, high;
5150 struct ieee_range *r;
5151
5152 low = bfd_get_section_vma (abfd, sec);
5153 high = low + bfd_section_size (abfd, sec);
5154
5155 /* Find the first range at or after this section. The ranges are
5156 sorted by address. */
5157 for (r = info->global_ranges; r != NULL; r = r->next)
5158 if (r->high > low)
5159 break;
5160
5161 while (low < high)
5162 {
5163 if (r == NULL || r->low >= high)
5164 {
5165 if (! ieee_add_bb11 (info, sec, low, high))
5166 info->error = true;
5167 return;
5168 }
5169
5170 if (low < r->low
5171 && r->low - low > 0x100)
5172 {
5173 if (! ieee_add_bb11 (info, sec, low, r->low))
5174 {
5175 info->error = true;
5176 return;
5177 }
5178 }
5179 low = r->high;
5180
5181 r = r->next;
5182 }
5183}
5184
5185/* Add a single BB11 block for a range. We add it to info->vars. */
5186
5187static boolean
5188ieee_add_bb11 (info, sec, low, high)
5189 struct ieee_handle *info;
5190 asection *sec;
5191 bfd_vma low;
5192 bfd_vma high;
5193{
5194 int kind;
5195
5196 if (! ieee_buffer_emptyp (&info->vars))
5197 {
5198 if (! ieee_change_buffer (info, &info->vars))
5199 return false;
5200 }
5201 else
5202 {
5af11cab 5203 const char *filename, *modname, *backslash;
252b5132
RH		 5204 char *c, *s;
5205
5206 /* Start the enclosing BB10 block. */
5207 filename = bfd_get_filename (info->abfd);
5208 modname = strrchr (filename, '/');
5af11cab
AM		 5209 backslash = strrchr (modname, '\\');
5210 if (backslash > modname)
5211 modname = backslash;
5212
252b5132
RH		 5213 if (modname != NULL)
5214 ++modname;
5af11cab
AM		 5215#ifdef HAVE_DOS_BASED_FILE_SYSTEM
5216 else if (filename[0] && filename[1] == ':')
5217 modname = filename + 2;
5218#endif
252b5132 5219 else
5af11cab
AM		 5220 modname = filename;
5221
252b5132
RH		 5222 c = xstrdup (modname);
5223 s = strrchr (c, '.');
5224 if (s != NULL)
5225 *s = '\0';
5226
5227 if (! ieee_change_buffer (info, &info->vars)
5228 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5229 || ! ieee_write_byte (info, 10)
5230 || ! ieee_write_number (info, 0)
5231 || ! ieee_write_id (info, c)
5232 || ! ieee_write_id (info, "")
5233 || ! ieee_write_number (info, 0)
5234 || ! ieee_write_id (info, "GNU objcopy"))
5235 return false;
5236
5237 free (c);
5238 }
5239
5240 if ((sec->flags & SEC_CODE) != 0)
5241 kind = 1;
5242 else if ((sec->flags & SEC_READONLY) != 0)
5243 kind = 3;
5244 else
5245 kind = 2;
5246
5247 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5248 || ! ieee_write_byte (info, 11)
5249 || ! ieee_write_number (info, 0)
5250 || ! ieee_write_id (info, "")
5251 || ! ieee_write_number (info, kind)
5252 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5253 || ! ieee_write_number (info, low)
5254 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5255 || ! ieee_write_number (info, high - low))
5256 return false;
5257
5258 return true;
5259}
5260
5261/* Start recording information from a particular source file. This is
5262 used to record which file defined which types, variables, etc. It
5263 is not used for line numbers, since the lineno entry point passes
5264 down the file name anyhow. IEEE debugging information doesn't seem
5265 to store this information anywhere. */
5266
5267/*ARGSUSED*/
5268static boolean
5269ieee_start_source (p, filename)
b4c96d0d
ILT		 5270 PTR p ATTRIBUTE_UNUSED;
5271 const char *filename ATTRIBUTE_UNUSED;
252b5132
RH		 5272{
5273 return true;
5274}
5275
5276/* Make an empty type. */
5277
5278static boolean
5279ieee_empty_type (p)
5280 PTR p;
5281{
5282 struct ieee_handle *info = (struct ieee_handle *) p;
5283
5284 return ieee_push_type (info, (int) builtin_unknown, 0, false, false);
5285}
5286
5287/* Make a void type. */
5288
5289static boolean
5290ieee_void_type (p)
5291 PTR p;
5292{
5293 struct ieee_handle *info = (struct ieee_handle *) p;
5294
5295 return ieee_push_type (info, (int) builtin_void, 0, false, false);
5296}
5297
5298/* Make an integer type. */
5299
5300static boolean
5301ieee_int_type (p, size, unsignedp)
5302 PTR p;
5303 unsigned int size;
5304 boolean unsignedp;
5305{
5306 struct ieee_handle *info = (struct ieee_handle *) p;
5307 unsigned int indx;
5308
5309 switch (size)
5310 {
5311 case 1:
5312 indx = (int) builtin_signed_char;
5313 break;
5314 case 2:
5315 indx = (int) builtin_signed_short_int;
5316 break;
5317 case 4:
5318 indx = (int) builtin_signed_long;
5319 break;
5320 case 8:
5321 indx = (int) builtin_signed_long_long;
5322 break;
5323 default:
5324 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
5325 return false;
5326 }
5327
5328 if (unsignedp)
5329 ++indx;
5330
5331 return ieee_push_type (info, indx, size, unsignedp, false);
5332}
5333
5334/* Make a floating point type. */
5335
5336static boolean
5337ieee_float_type (p, size)
5338 PTR p;
5339 unsigned int size;
5340{
5341 struct ieee_handle *info = (struct ieee_handle *) p;
5342 unsigned int indx;
5343
5344 switch (size)
5345 {
5346 case 4:
5347 indx = (int) builtin_float;
5348 break;
5349 case 8:
5350 indx = (int) builtin_double;
5351 break;
5352 case 12:
5353 /* FIXME: This size really depends upon the processor. */
5354 indx = (int) builtin_long_double;
5355 break;
5356 case 16:
5357 indx = (int) builtin_long_long_double;
5358 break;
5359 default:
5360 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
5361 return false;
5362 }
5363
5364 return ieee_push_type (info, indx, size, false, false);
5365}
5366
5367/* Make a complex type. */
5368
5369static boolean
5370ieee_complex_type (p, size)
5371 PTR p;
5372 unsigned int size;
5373{
5374 struct ieee_handle *info = (struct ieee_handle *) p;
5375 char code;
5376
5377 switch (size)
5378 {
5379 case 4:
5380 if (info->complex_float_index != 0)
5381 return ieee_push_type (info, info->complex_float_index, size * 2,
5382 false, false);
5383 code = 'c';
5384 break;
5385 case 12:
5386 case 16:
5387 /* These cases can be output by gcc -gstabs. Outputting the
5388 wrong type is better than crashing. */
5389 case 8:
5390 if (info->complex_double_index != 0)
5391 return ieee_push_type (info, info->complex_double_index, size * 2,
5392 false, false);
5393 code = 'd';
5394 break;
5395 default:
5396 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
5397 return false;
5398 }
5399
5400 /* FIXME: I don't know what the string is for. */
5401 if (! ieee_define_type (info, size * 2, false, false)
5402 || ! ieee_write_number (info, code)
5403 || ! ieee_write_id (info, ""))
5404 return false;
5405
5406 if (size == 4)
5407 info->complex_float_index = info->type_stack->type.indx;
5408 else
5409 info->complex_double_index = info->type_stack->type.indx;
5410
5411 return true;
5412}
5413
5414/* Make a boolean type. IEEE doesn't support these, so we just make
5415 an integer type instead. */
5416
5417static boolean
5418ieee_bool_type (p, size)
5419 PTR p;
5420 unsigned int size;
5421{
5422 return ieee_int_type (p, size, true);
5423}
5424
5425/* Make an enumeration. */
5426
5427static boolean
5428ieee_enum_type (p, tag, names, vals)
5429 PTR p;
5430 const char *tag;
5431 const char **names;
5432 bfd_signed_vma *vals;
5433{
5434 struct ieee_handle *info = (struct ieee_handle *) p;
5435 struct ieee_defined_enum *e;
5436 boolean localp, simple;
5437 unsigned int indx;
5438 int i = 0;
5439
5440 localp = false;
5441 indx = (unsigned int) -1;
5442 for (e = info->enums; e != NULL; e = e->next)
5443 {
5444 if (tag == NULL)
5445 {
5446 if (e->tag != NULL)
5447 continue;
5448 }
5449 else
5450 {
5451 if (e->tag == NULL
5452 || tag[0] != e->tag[0]
5453 || strcmp (tag, e->tag) != 0)
5454 continue;
5455 }
5456
5457 if (! e->defined)
5458 {
5459 /* This enum tag has been seen but not defined. */
5460 indx = e->indx;
5461 break;
5462 }
5463
5464 if (names != NULL && e->names != NULL)
5465 {
5466 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5467 {
5468 if (names[i][0] != e->names[i][0]
5469 || vals[i] != e->vals[i]
5470 || strcmp (names[i], e->names[i]) != 0)
5471 break;
5472 }
5473 }
5474
5475 if ((names == NULL && e->names == NULL)
5476 || (names != NULL
5477 && e->names != NULL
5478 && names[i] == NULL
5479 && e->names[i] == NULL))
5480 {
5481 /* We've seen this enum before. */
5482 return ieee_push_type (info, e->indx, 0, true, false);
5483 }
5484
5485 if (tag != NULL)
5486 {
5487 /* We've already seen an enum of the same name, so we must make
5488 sure to output this one locally. */
5489 localp = true;
5490 break;
5491 }
5492 }
5493
5494 /* If this is a simple enumeration, in which the values start at 0
5495 and always increment by 1, we can use type E. Otherwise we must
5496 use type N. */
5497
5498 simple = true;
5499 if (names != NULL)
5500 {
5501 for (i = 0; names[i] != NULL; i++)
5502 {
5503 if (vals[i] != i)
5504 {
5505 simple = false;
5506 break;
5507 }
5508 }
5509 }
5510
5511 if (! ieee_define_named_type (info, tag, indx, 0, true, localp,
5512 (struct ieee_buflist *) NULL)
5513 || ! ieee_write_number (info, simple ? 'E' : 'N'))
5514 return false;
5515 if (simple)
5516 {
5517 /* FIXME: This is supposed to be the enumeration size, but we
5518 don't store that. */
5519 if (! ieee_write_number (info, 4))
5520 return false;
5521 }
5522 if (names != NULL)
5523 {
5524 for (i = 0; names[i] != NULL; i++)
5525 {
5526 if (! ieee_write_id (info, names[i]))
5527 return false;
5528 if (! simple)
5529 {
5530 if (! ieee_write_number (info, vals[i]))
5531 return false;
5532 }
5533 }
5534 }
5535
5536 if (! localp)
5537 {
5538 if (indx == (unsigned int) -1)
5539 {
5540 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5541 memset (e, 0, sizeof *e);
5542 e->indx = info->type_stack->type.indx;
5543 e->tag = tag;
5544
5545 e->next = info->enums;
5546 info->enums = e;
5547 }
5548
5549 e->names = names;
5550 e->vals = vals;
5551 e->defined = true;
5552 }
5553
5554 return true;
5555}
5556
5557/* Make a pointer type. */
5558
5559static boolean
5560ieee_pointer_type (p)
5561 PTR p;
5562{
5563 struct ieee_handle *info = (struct ieee_handle *) p;
5564 boolean localp;
5565 unsigned int indx;
5566 struct ieee_modified_type *m = NULL;
5567
5568 localp = info->type_stack->type.localp;
5569 indx = ieee_pop_type (info);
5570
5571 /* A pointer to a simple builtin type can be obtained by adding 32.
5572 FIXME: Will this be a short pointer, and will that matter? */
5573 if (indx < 32)
5574 return ieee_push_type (info, indx + 32, 0, true, false);
5575
5576 if (! localp)
5577 {
5578 m = ieee_get_modified_info (p, indx);
5579 if (m == NULL)
5580 return false;
5581
5582 /* FIXME: The size should depend upon the architecture. */
5583 if (m->pointer > 0)
5584 return ieee_push_type (info, m->pointer, 4, true, false);
5585 }
5586
5587 if (! ieee_define_type (info, 4, true, localp)
5588 || ! ieee_write_number (info, 'P')
5589 || ! ieee_write_number (info, indx))
5590 return false;
5591
5592 if (! localp)
5593 m->pointer = info->type_stack->type.indx;
5594
5595 return true;
5596}
5597
5598/* Make a function type. This will be called for a method, but we
5599 don't want to actually add it to the type table in that case. We
5600 handle this by defining the type in a private buffer, and only
5601 adding that buffer to the typedef block if we are going to use it. */
5602
5603static boolean
5604ieee_function_type (p, argcount, varargs)
5605 PTR p;
5606 int argcount;
5607 boolean varargs;
5608{
5609 struct ieee_handle *info = (struct ieee_handle *) p;
5610 boolean localp;
5611 unsigned int *args = NULL;
5612 int i;
5613 unsigned int retindx;
5614 struct ieee_buflist fndef;
5615 struct ieee_modified_type *m;
5616
5617 localp = false;
5618
5619 if (argcount > 0)
5620 {
5621 args = (unsigned int *) xmalloc (argcount * sizeof *args);
5622 for (i = argcount - 1; i >= 0; i--)
5623 {
5624 if (info->type_stack->type.localp)
5625 localp = true;
5626 args[i] = ieee_pop_type (info);
5627 }
5628 }
5629 else if (argcount < 0)
5630 varargs = false;
5631
5632 if (info->type_stack->type.localp)
5633 localp = true;
5634 retindx = ieee_pop_type (info);
5635
5636 m = NULL;
5637 if (argcount < 0 && ! localp)
5638 {
5639 m = ieee_get_modified_info (p, retindx);
5640 if (m == NULL)
5641 return false;
5642
5643 if (m->function > 0)
5644 return ieee_push_type (info, m->function, 0, true, false);
5645 }
5646
5647 /* An attribute of 0x41 means that the frame and push mask are
5648 unknown. */
5649 if (! ieee_init_buffer (info, &fndef)
5650 || ! ieee_define_named_type (info, (const char *) NULL,
5651 (unsigned int) -1, 0, true, localp,
5652 &fndef)
5653 || ! ieee_write_number (info, 'x')
5654 || ! ieee_write_number (info, 0x41)
5655 || ! ieee_write_number (info, 0)
5656 || ! ieee_write_number (info, 0)
5657 || ! ieee_write_number (info, retindx)
5658 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5659 return false;
5660 if (argcount > 0)
5661 {
5662 for (i = 0; i < argcount; i++)
5663 if (! ieee_write_number (info, args[i]))
5664 return false;
5665 free (args);
5666 }
5667 if (varargs)
5668 {
5669 /* A varargs function is represented by writing out the last
5670 argument as type void *, although this makes little sense. */
5671 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5672 return false;
5673 }
5674
5675 if (! ieee_write_number (info, 0))
5676 return false;
5677
5678 /* We wrote the information into fndef, in case we don't need it.
5679 It will be appended to info->types by ieee_pop_type. */
5680 info->type_stack->type.fndef = fndef;
5681
5682 if (m != NULL)
5683 m->function = info->type_stack->type.indx;
5684
5685 return true;
5686}
5687
5688/* Make a reference type. */
5689
5690static boolean
5691ieee_reference_type (p)
5692 PTR p;
5693{
5694 struct ieee_handle *info = (struct ieee_handle *) p;
5695
5696 /* IEEE appears to record a normal pointer type, and then use a
5697 pmisc record to indicate that it is really a reference. */
5698
5699 if (! ieee_pointer_type (p))
5700 return false;
5701 info->type_stack->type.referencep = true;
5702 return true;
5703}
5704
5705/* Make a range type. */
5706
5707static boolean
5708ieee_range_type (p, low, high)
5709 PTR p;
5710 bfd_signed_vma low;
5711 bfd_signed_vma high;
5712{
5713 struct ieee_handle *info = (struct ieee_handle *) p;
5714 unsigned int size;
5715 boolean unsignedp, localp;
5716
5717 size = info->type_stack->type.size;
5718 unsignedp = info->type_stack->type.unsignedp;
5719 localp = info->type_stack->type.localp;
5720 ieee_pop_unused_type (info);
5721 return (ieee_define_type (info, size, unsignedp, localp)
5722 && ieee_write_number (info, 'R')
5723 && ieee_write_number (info, (bfd_vma) low)
5724 && ieee_write_number (info, (bfd_vma) high)
5725 && ieee_write_number (info, unsignedp ? 0 : 1)
5726 && ieee_write_number (info, size));
5727}
5728
5729/* Make an array type. */
5730
5731/*ARGSUSED*/
5732static boolean
5733ieee_array_type (p, low, high, stringp)
5734 PTR p;
5735 bfd_signed_vma low;
5736 bfd_signed_vma high;
b4c96d0d 5737 boolean stringp ATTRIBUTE_UNUSED;
252b5132
RH		 5738{
5739 struct ieee_handle *info = (struct ieee_handle *) p;
5740 unsigned int eleindx;
5741 boolean localp;
5742 unsigned int size;
5743 struct ieee_modified_type *m = NULL;
5744 struct ieee_modified_array_type *a;
5745
5746 /* IEEE does not store the range, so we just ignore it. */
5747 ieee_pop_unused_type (info);
5748 localp = info->type_stack->type.localp;
5749 size = info->type_stack->type.size;
5750 eleindx = ieee_pop_type (info);
5751
5752 /* If we don't know the range, treat the size as exactly one
5753 element. */
5754 if (low < high)
5755 size *= (high - low) + 1;
5756
5757 if (! localp)
5758 {
5759 m = ieee_get_modified_info (info, eleindx);
5760 if (m == NULL)
5761 return false;
5762
5763 for (a = m->arrays; a != NULL; a = a->next)
5764 {
5765 if (a->low == low && a->high == high)
5766 return ieee_push_type (info, a->indx, size, false, false);
5767 }
5768 }
5769
5770 if (! ieee_define_type (info, size, false, localp)
5771 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5772 || ! ieee_write_number (info, eleindx))
5773 return false;
5774 if (low != 0)
5775 {
5776 if (! ieee_write_number (info, low))
5777 return false;
5778 }
5779
5780 if (! ieee_write_number (info, high + 1))
5781 return false;
5782
5783 if (! localp)
5784 {
5785 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5786 memset (a, 0, sizeof *a);
5787
5788 a->indx = info->type_stack->type.indx;
5789 a->low = low;
5790 a->high = high;
5791
5792 a->next = m->arrays;
5793 m->arrays = a;
5794 }
5795
5796 return true;
5797}
5798
5799/* Make a set type. */
5800
5801static boolean
5802ieee_set_type (p, bitstringp)
5803 PTR p;
b4c96d0d 5804 boolean bitstringp ATTRIBUTE_UNUSED;
252b5132
RH		 5805{
5806 struct ieee_handle *info = (struct ieee_handle *) p;
5807 boolean localp;
5808 unsigned int eleindx;
5809
5810 localp = info->type_stack->type.localp;
5811 eleindx = ieee_pop_type (info);
5812
5813 /* FIXME: We don't know the size, so we just use 4. */
5814
5815 return (ieee_define_type (info, 0, true, localp)
5816 && ieee_write_number (info, 's')
5817 && ieee_write_number (info, 4)
5818 && ieee_write_number (info, eleindx));
5819}
5820
5821/* Make an offset type. */
5822
5823static boolean
5824ieee_offset_type (p)
5825 PTR p;
5826{
5827 struct ieee_handle *info = (struct ieee_handle *) p;
5828 unsigned int targetindx, baseindx;
5829
5830 targetindx = ieee_pop_type (info);
5831 baseindx = ieee_pop_type (info);
5832
5833 /* FIXME: The MRI C++ compiler does not appear to generate any
5834 useful type information about an offset type. It just records a
5835 pointer to member as an integer. The MRI/HP IEEE spec does
5836 describe a pmisc record which can be used for a pointer to
5837 member. Unfortunately, it does not describe the target type,
5838 which seems pretty important. I'm going to punt this for now. */
5839
5840 return ieee_int_type (p, 4, true);
5841}
5842
5843/* Make a method type. */
5844
5845static boolean
5846ieee_method_type (p, domain, argcount, varargs)
5847 PTR p;
5848 boolean domain;
5849 int argcount;
5850 boolean varargs;
5851{
5852 struct ieee_handle *info = (struct ieee_handle *) p;
5853
5854 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5855 method, but the definition is incomplete. We just output an 'x'
5856 type. */
5857
5858 if (domain)
5859 ieee_pop_unused_type (info);
5860
5861 return ieee_function_type (p, argcount, varargs);
5862}
5863
5864/* Make a const qualified type. */
5865
5866static boolean
5867ieee_const_type (p)
5868 PTR p;
5869{
5870 struct ieee_handle *info = (struct ieee_handle *) p;
5871 unsigned int size;
5872 boolean unsignedp, localp;
5873 unsigned int indx;
5874 struct ieee_modified_type *m = NULL;
5875
5876 size = info->type_stack->type.size;
5877 unsignedp = info->type_stack->type.unsignedp;
5878 localp = info->type_stack->type.localp;
5879 indx = ieee_pop_type (info);
5880
5881 if (! localp)
5882 {
5883 m = ieee_get_modified_info (info, indx);
5884 if (m == NULL)
5885 return false;
5886
5887 if (m->const_qualified > 0)
5888 return ieee_push_type (info, m->const_qualified, size, unsignedp,
5889 false);
5890 }
5891
5892 if (! ieee_define_type (info, size, unsignedp, localp)
5893 || ! ieee_write_number (info, 'n')
5894 || ! ieee_write_number (info, 1)
5895 || ! ieee_write_number (info, indx))
5896 return false;
5897
5898 if (! localp)
5899 m->const_qualified = info->type_stack->type.indx;
5900
5901 return true;
5902}
5903
5904/* Make a volatile qualified type. */
5905
5906static boolean
5907ieee_volatile_type (p)
5908 PTR p;
5909{
5910 struct ieee_handle *info = (struct ieee_handle *) p;
5911 unsigned int size;
5912 boolean unsignedp, localp;
5913 unsigned int indx;
5914 struct ieee_modified_type *m = NULL;
5915
5916 size = info->type_stack->type.size;
5917 unsignedp = info->type_stack->type.unsignedp;
5918 localp = info->type_stack->type.localp;
5919 indx = ieee_pop_type (info);
5920
5921 if (! localp)
5922 {
5923 m = ieee_get_modified_info (info, indx);
5924 if (m == NULL)
5925 return false;
5926
5927 if (m->volatile_qualified > 0)
5928 return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
5929 false);
5930 }
5931
5932 if (! ieee_define_type (info, size, unsignedp, localp)
5933 || ! ieee_write_number (info, 'n')
5934 || ! ieee_write_number (info, 2)
5935 || ! ieee_write_number (info, indx))
5936 return false;
5937
5938 if (! localp)
5939 m->volatile_qualified = info->type_stack->type.indx;
5940
5941 return true;
5942}
5943
5944/* Convert an enum debug_visibility into a CXXFLAGS value. */
5945
5946static unsigned int
5947ieee_vis_to_flags (visibility)
5948 enum debug_visibility visibility;
5949{
5950 switch (visibility)
5951 {
5952 default:
5953 abort ();
5954 case DEBUG_VISIBILITY_PUBLIC:
5955 return CXXFLAGS_VISIBILITY_PUBLIC;
5956 case DEBUG_VISIBILITY_PRIVATE:
5957 return CXXFLAGS_VISIBILITY_PRIVATE;
5958 case DEBUG_VISIBILITY_PROTECTED:
5959 return CXXFLAGS_VISIBILITY_PROTECTED;
5960 }
5961 /*NOTREACHED*/
5962}
5963
5964/* Start defining a struct type. We build it in the strdef field on
5965 the stack, to avoid confusing type definitions required by the
5966 fields with the struct type itself. */
5967
5968static boolean
5969ieee_start_struct_type (p, tag, id, structp, size)
5970 PTR p;
5971 const char *tag;
5972 unsigned int id;
5973 boolean structp;
5974 unsigned int size;
5975{
5976 struct ieee_handle *info = (struct ieee_handle *) p;
5977 boolean localp, ignorep;
5978 boolean copy;
5979 char ab[20];
5980 const char *look;
5981 struct ieee_name_type_hash_entry *h;
5982 struct ieee_name_type *nt, *ntlook;
5983 struct ieee_buflist strdef;
5984
5985 localp = false;
5986 ignorep = false;
5987
5988 /* We need to create a tag for internal use even if we don't want
5989 one for external use. This will let us refer to an anonymous
5990 struct. */
5991 if (tag != NULL)
5992 {
5993 look = tag;
5994 copy = false;
5995 }
5996 else
5997 {
5998 sprintf (ab, "__anon%u", id);
5999 look = ab;
6000 copy = true;
6001 }
6002
6003 /* If we already have references to the tag, we must use the
6004 existing type index. */
6005 h = ieee_name_type_hash_lookup (&info->tags, look, true, copy);
6006 if (h == NULL)
6007 return false;
6008
6009 nt = NULL;
6010 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
6011 {
6012 if (ntlook->id == id)
6013 nt = ntlook;
6014 else if (! ntlook->type.localp)
6015 {
6016 /* We are creating a duplicate definition of a globally
6017 defined tag. Force it to be local to avoid
6018 confusion. */
6019 localp = true;
6020 }
6021 }
6022
6023 if (nt != NULL)
6024 {
6025 assert (localp == nt->type.localp);
6026 if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
6027 {
6028 /* We've already seen a global definition of the type.
6029 Ignore this new definition. */
6030 ignorep = true;
6031 }
6032 }
6033 else
6034 {
6035 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6036 memset (nt, 0, sizeof *nt);
6037 nt->id = id;
6038 nt->type.name = h->root.string;
6039 nt->next = h->types;
6040 h->types = nt;
6041 nt->type.indx = info->type_indx;
6042 ++info->type_indx;
6043 }
6044
6045 nt->kind = DEBUG_KIND_ILLEGAL;
6046
6047 if (! ieee_init_buffer (info, &strdef)
6048 || ! ieee_define_named_type (info, tag, nt->type.indx, size, true,
6049 localp, &strdef)
6050 || ! ieee_write_number (info, structp ? 'S' : 'U')
6051 || ! ieee_write_number (info, size))
6052 return false;
6053
6054 if (! ignorep)
6055 {
6056 const char *hold;
6057
6058 /* We never want nt->type.name to be NULL. We want the rest of
6059 the type to be the object set up on the type stack; it will
6060 have a NULL name if tag is NULL. */
6061 hold = nt->type.name;
6062 nt->type = info->type_stack->type;
6063 nt->type.name = hold;
6064 }
6065
6066 info->type_stack->type.name = tag;
6067 info->type_stack->type.strdef = strdef;
6068 info->type_stack->type.ignorep = ignorep;
6069
6070 return true;
6071}
6072
6073/* Add a field to a struct. */
6074
6075static boolean
6076ieee_struct_field (p, name, bitpos, bitsize, visibility)
6077 PTR p;
6078 const char *name;
6079 bfd_vma bitpos;
6080 bfd_vma bitsize;
6081 enum debug_visibility visibility;
6082{
6083 struct ieee_handle *info = (struct ieee_handle *) p;
6084 unsigned int size;
6085 boolean unsignedp;
6086 boolean referencep;
6087 boolean localp;
6088 unsigned int indx;
6089 bfd_vma offset;
6090
6091 assert (info->type_stack != NULL
6092 && info->type_stack->next != NULL
6093 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6094
6095 /* If we are ignoring this struct definition, just pop and ignore
6096 the type. */
6097 if (info->type_stack->next->type.ignorep)
6098 {
6099 ieee_pop_unused_type (info);
6100 return true;
6101 }
6102
6103 size = info->type_stack->type.size;
6104 unsignedp = info->type_stack->type.unsignedp;
6105 referencep = info->type_stack->type.referencep;
6106 localp = info->type_stack->type.localp;
6107 indx = ieee_pop_type (info);
6108
6109 if (localp)
6110 info->type_stack->type.localp = true;
6111
6112 if (info->type_stack->type.classdef != NULL)
6113 {
6114 unsigned int flags;
6115 unsigned int nindx;
6116
6117 /* This is a class. We must add a description of this field to
6118 the class records we are building. */
6119
6120 flags = ieee_vis_to_flags (visibility);
6121 nindx = info->type_stack->type.classdef->indx;
6122 if (! ieee_change_buffer (info,
6123 &info->type_stack->type.classdef->pmiscbuf)
6124 || ! ieee_write_asn (info, nindx, 'd')
6125 || ! ieee_write_asn (info, nindx, flags)
6126 || ! ieee_write_atn65 (info, nindx, name)
6127 || ! ieee_write_atn65 (info, nindx, name))
6128 return false;
6129 info->type_stack->type.classdef->pmisccount += 4;
6130
6131 if (referencep)
6132 {
6133 unsigned int nindx;
6134
6135 /* We need to output a record recording that this field is
6136 really of reference type. We put this on the refs field
6137 of classdef, so that it can be appended to the C++
6138 records after the class is defined. */
6139
6140 nindx = info->name_indx;
6141 ++info->name_indx;
6142
6143 if (! ieee_change_buffer (info,
6144 &info->type_stack->type.classdef->refs)
6145 || ! ieee_write_byte (info, (int) ieee_nn_record)
6146 || ! ieee_write_number (info, nindx)
6147 || ! ieee_write_id (info, "")
6148 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6149 || ! ieee_write_number (info, nindx)
6150 || ! ieee_write_number (info, 0)
6151 || ! ieee_write_number (info, 62)
6152 || ! ieee_write_number (info, 80)
6153 || ! ieee_write_number (info, 4)
6154 || ! ieee_write_asn (info, nindx, 'R')
6155 || ! ieee_write_asn (info, nindx, 3)
6156 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
6157 || ! ieee_write_atn65 (info, nindx, name))
6158 return false;
6159 }
6160 }
6161
6162 /* If the bitsize doesn't match the expected size, we need to output
6163 a bitfield type. */
6164 if (size == 0 || bitsize == 0 || bitsize == size * 8)
6165 offset = bitpos / 8;
6166 else
6167 {
6168 if (! ieee_define_type (info, 0, unsignedp,
6169 info->type_stack->type.localp)
6170 || ! ieee_write_number (info, 'g')
6171 || ! ieee_write_number (info, unsignedp ? 0 : 1)
6172 || ! ieee_write_number (info, bitsize)
6173 || ! ieee_write_number (info, indx))
6174 return false;
6175 indx = ieee_pop_type (info);
6176 offset = bitpos;
6177 }
6178
6179 /* Switch to the struct we are building in order to output this
6180 field definition. */
6181 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
6182 && ieee_write_id (info, name)
6183 && ieee_write_number (info, indx)
6184 && ieee_write_number (info, offset));
6185}
6186
6187/* Finish up a struct type. */
6188
6189static boolean
6190ieee_end_struct_type (p)
6191 PTR p;
6192{
6193 struct ieee_handle *info = (struct ieee_handle *) p;
6194 struct ieee_buflist *pb;
6195
6196 assert (info->type_stack != NULL
6197 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
6198
6199 /* If we were ignoring this struct definition because it was a
6200 duplicate defintion, just through away whatever bytes we have
6201 accumulated. Leave the type on the stack. */
6202 if (info->type_stack->type.ignorep)
6203 return true;
6204
6205 /* If this is not a duplicate definition of this tag, then localp
6206 will be false, and we can put it in the global type block.
6207 FIXME: We should avoid outputting duplicate definitions which are
6208 the same. */
6209 if (! info->type_stack->type.localp)
6210 {
6211 /* Make sure we have started the global type block. */
6212 if (ieee_buffer_emptyp (&info->global_types))
6213 {
6214 if (! ieee_change_buffer (info, &info->global_types)
6215 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6216 || ! ieee_write_byte (info, 2)
6217 || ! ieee_write_number (info, 0)
6218 || ! ieee_write_id (info, ""))
6219 return false;
6220 }
6221 pb = &info->global_types;
6222 }
6223 else
6224 {
6225 /* Make sure we have started the types block. */
6226 if (ieee_buffer_emptyp (&info->types))
6227 {
6228 if (! ieee_change_buffer (info, &info->types)
6229 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6230 || ! ieee_write_byte (info, 1)
6231 || ! ieee_write_number (info, 0)
6232 || ! ieee_write_id (info, info->modname))
6233 return false;
6234 }
6235 pb = &info->types;
6236 }
6237
6238 /* Append the struct definition to the types. */
6239 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6240 || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6241 return false;
6242
6243 /* Leave the struct on the type stack. */
6244
6245 return true;
6246}
6247
6248/* Start a class type. */
6249
6250static boolean
6251ieee_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
6252 PTR p;
6253 const char *tag;
6254 unsigned int id;
6255 boolean structp;
6256 unsigned int size;
6257 boolean vptr;
6258 boolean ownvptr;
6259{
6260 struct ieee_handle *info = (struct ieee_handle *) p;
6261 const char *vclass;
6262 struct ieee_buflist pmiscbuf;
6263 unsigned int indx;
6264 struct ieee_type_class *classdef;
6265
6266 /* A C++ class is output as a C++ struct along with a set of pmisc
6267 records describing the class. */
6268
6269 /* We need to have a name so that we can associate the struct and
6270 the class. */
6271 if (tag == NULL)
6272 {
6273 char *t;
6274
6275 t = (char *) xmalloc (20);
6276 sprintf (t, "__anon%u", id);
6277 tag = t;
6278 }
6279
6280 /* We can't write out the virtual table information until we have
6281 finished the class, because we don't know the virtual table size.
6282 We get the size from the largest voffset we see. */
6283 vclass = NULL;
6284 if (vptr && ! ownvptr)
6285 {
6286 vclass = info->type_stack->type.name;
6287 assert (vclass != NULL);
6288 /* We don't call ieee_pop_unused_type, since the class should
6289 get defined. */
6290 (void) ieee_pop_type (info);
6291 }
6292
6293 if (! ieee_start_struct_type (p, tag, id, structp, size))
6294 return false;
6295
6296 indx = info->name_indx;
6297 ++info->name_indx;
6298
6299 /* We write out pmisc records into the classdef field. We will
6300 write out the pmisc start after we know the number of records we
6301 need. */
6302 if (! ieee_init_buffer (info, &pmiscbuf)
6303 || ! ieee_change_buffer (info, &pmiscbuf)
6304 || ! ieee_write_asn (info, indx, 'T')
6305 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6306 || ! ieee_write_atn65 (info, indx, tag))
6307 return false;
6308
6309 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6310 memset (classdef, 0, sizeof *classdef);
6311
6312 classdef->indx = indx;
6313 classdef->pmiscbuf = pmiscbuf;
6314 classdef->pmisccount = 3;
6315 classdef->vclass = vclass;
6316 classdef->ownvptr = ownvptr;
6317
6318 info->type_stack->type.classdef = classdef;
6319
6320 return true;
6321}
6322
6323/* Add a static member to a class. */
6324
6325static boolean
6326ieee_class_static_member (p, name, physname, visibility)
6327 PTR p;
6328 const char *name;
6329 const char *physname;
6330 enum debug_visibility visibility;
6331{
6332 struct ieee_handle *info = (struct ieee_handle *) p;
6333 unsigned int flags;
6334 unsigned int nindx;
6335
6336 /* We don't care about the type. Hopefully there will be a call to
6337 ieee_variable declaring the physical name and the type, since
6338 that is where an IEEE consumer must get the type. */
6339 ieee_pop_unused_type (info);
6340
6341 assert (info->type_stack != NULL
6342 && info->type_stack->type.classdef != NULL);
6343
6344 flags = ieee_vis_to_flags (visibility);
6345 flags |= CXXFLAGS_STATIC;
6346
6347 nindx = info->type_stack->type.classdef->indx;
6348
6349 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6350 || ! ieee_write_asn (info, nindx, 'd')
6351 || ! ieee_write_asn (info, nindx, flags)
6352 || ! ieee_write_atn65 (info, nindx, name)
6353 || ! ieee_write_atn65 (info, nindx, physname))
6354 return false;
6355 info->type_stack->type.classdef->pmisccount += 4;
6356
6357 return true;
6358}
6359
6360/* Add a base class to a class. */
6361
6362static boolean
6363ieee_class_baseclass (p, bitpos, virtual, visibility)
6364 PTR p;
6365 bfd_vma bitpos;
6366 boolean virtual;
6367 enum debug_visibility visibility;
6368{
6369 struct ieee_handle *info = (struct ieee_handle *) p;
6370 const char *bname;
6371 boolean localp;
6372 unsigned int bindx;
6373 char *fname;
6374 unsigned int flags;
6375 unsigned int nindx;
6376
6377 assert (info->type_stack != NULL
6378 && info->type_stack->type.name != NULL
6379 && info->type_stack->next != NULL
6380 && info->type_stack->next->type.classdef != NULL
6381 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6382
6383 bname = info->type_stack->type.name;
6384 localp = info->type_stack->type.localp;
6385 bindx = ieee_pop_type (info);
6386
6387 /* We are currently defining both a struct and a class. We must
6388 write out a field definition in the struct which holds the base
6389 class. The stabs debugging reader will create a field named
6390 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6391 we should not depend upon a detail of stabs debugging. */
6392 if (virtual)
6393 {
6394 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6395 sprintf (fname, "_vb$%s", bname);
6396 flags = BASEFLAGS_VIRTUAL;
6397 }
6398 else
6399 {
6400 if (localp)
6401 info->type_stack->type.localp = true;
6402
6403 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6404 sprintf (fname, "_b$%s", bname);
6405
6406 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6407 || ! ieee_write_id (info, fname)
6408 || ! ieee_write_number (info, bindx)
6409 || ! ieee_write_number (info, bitpos / 8))
6410 return false;
6411 flags = 0;
6412 }
6413
6414 if (visibility == DEBUG_VISIBILITY_PRIVATE)
6415 flags |= BASEFLAGS_PRIVATE;
6416
6417 nindx = info->type_stack->type.classdef->indx;
6418
6419 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6420 || ! ieee_write_asn (info, nindx, 'b')
6421 || ! ieee_write_asn (info, nindx, flags)
6422 || ! ieee_write_atn65 (info, nindx, bname)
6423 || ! ieee_write_asn (info, nindx, 0)
6424 || ! ieee_write_atn65 (info, nindx, fname))
6425 return false;
6426 info->type_stack->type.classdef->pmisccount += 5;
6427
6428 free (fname);
6429
6430 return true;
6431}
6432
6433/* Start building a method for a class. */
6434
6435static boolean
6436ieee_class_start_method (p, name)
6437 PTR p;
6438 const char *name;
6439{
6440 struct ieee_handle *info = (struct ieee_handle *) p;
6441
6442 assert (info->type_stack != NULL
6443 && info->type_stack->type.classdef != NULL
6444 && info->type_stack->type.classdef->method == NULL);
6445
6446 info->type_stack->type.classdef->method = name;
6447
6448 return true;
6449}
6450
6451/* Define a new method variant, either static or not. */
6452
6453static boolean
6454ieee_class_method_var (info, physname, visibility, staticp, constp,
6455 volatilep, voffset, context)
6456 struct ieee_handle *info;
6457 const char *physname;
6458 enum debug_visibility visibility;
6459 boolean staticp;
6460 boolean constp;
6461 boolean volatilep;
6462 bfd_vma voffset;
6463 boolean context;
6464{
6465 unsigned int flags;
6466 unsigned int nindx;
6467 boolean virtual;
6468
6469 /* We don't need the type of the method. An IEEE consumer which
6470 wants the type must track down the function by the physical name
6471 and get the type from that. */
6472 ieee_pop_unused_type (info);
6473
6474 /* We don't use the context. FIXME: We probably ought to use it to
6475 adjust the voffset somehow, but I don't really know how. */
6476 if (context)
6477 ieee_pop_unused_type (info);
6478
6479 assert (info->type_stack != NULL
6480 && info->type_stack->type.classdef != NULL
6481 && info->type_stack->type.classdef->method != NULL);
6482
6483 flags = ieee_vis_to_flags (visibility);
6484
6485 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6486 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6487
6488 if (staticp)
6489 flags |= CXXFLAGS_STATIC;
6490 if (constp)
6491 flags |= CXXFLAGS_CONST;
6492 if (volatilep)
6493 flags |= CXXFLAGS_VOLATILE;
6494
6495 nindx = info->type_stack->type.classdef->indx;
6496
6497 virtual = context || voffset > 0;
6498
6499 if (! ieee_change_buffer (info,
6500 &info->type_stack->type.classdef->pmiscbuf)
6501 || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm')
6502 || ! ieee_write_asn (info, nindx, flags)
6503 || ! ieee_write_atn65 (info, nindx,
6504 info->type_stack->type.classdef->method)
6505 || ! ieee_write_atn65 (info, nindx, physname))
6506 return false;
6507
6508 if (virtual)
6509 {
6510 if (voffset > info->type_stack->type.classdef->voffset)
6511 info->type_stack->type.classdef->voffset = voffset;
6512 if (! ieee_write_asn (info, nindx, voffset))
6513 return false;
6514 ++info->type_stack->type.classdef->pmisccount;
6515 }
6516
6517 if (! ieee_write_asn (info, nindx, 0))
6518 return false;
6519
6520 info->type_stack->type.classdef->pmisccount += 5;
6521
6522 return true;
6523}
6524
6525/* Define a new method variant. */
6526
6527static boolean
6528ieee_class_method_variant (p, physname, visibility, constp, volatilep,
6529 voffset, context)
6530 PTR p;
6531 const char *physname;
6532 enum debug_visibility visibility;
6533 boolean constp;
6534 boolean volatilep;
6535 bfd_vma voffset;
6536 boolean context;
6537{
6538 struct ieee_handle *info = (struct ieee_handle *) p;
6539
6540 return ieee_class_method_var (info, physname, visibility, false, constp,
6541 volatilep, voffset, context);
6542}
6543
6544/* Define a new static method variant. */
6545
6546static boolean
6547ieee_class_static_method_variant (p, physname, visibility, constp, volatilep)
6548 PTR p;
6549 const char *physname;
6550 enum debug_visibility visibility;
6551 boolean constp;
6552 boolean volatilep;
6553{
6554 struct ieee_handle *info = (struct ieee_handle *) p;
6555
6556 return ieee_class_method_var (info, physname, visibility, true, constp,
6557 volatilep, 0, false);
6558}
6559
6560/* Finish up a method. */
6561
6562static boolean
6563ieee_class_end_method (p)
6564 PTR p;
6565{
6566 struct ieee_handle *info = (struct ieee_handle *) p;
6567
6568 assert (info->type_stack != NULL
6569 && info->type_stack->type.classdef != NULL
6570 && info->type_stack->type.classdef->method != NULL);
6571
6572 info->type_stack->type.classdef->method = NULL;
6573
6574 return true;
6575}
6576
6577/* Finish up a class. */
6578
6579static boolean
6580ieee_end_class_type (p)
6581 PTR p;
6582{
6583 struct ieee_handle *info = (struct ieee_handle *) p;
6584 unsigned int nindx;
6585
6586 assert (info->type_stack != NULL
6587 && info->type_stack->type.classdef != NULL);
6588
6589 /* If we were ignoring this class definition because it was a
6590 duplicate definition, just through away whatever bytes we have
6591 accumulated. Leave the type on the stack. */
6592 if (info->type_stack->type.ignorep)
6593 return true;
6594
6595 nindx = info->type_stack->type.classdef->indx;
6596
6597 /* If we have a virtual table, we can write out the information now. */
6598 if (info->type_stack->type.classdef->vclass != NULL
6599 || info->type_stack->type.classdef->ownvptr)
6600 {
6601 if (! ieee_change_buffer (info,
6602 &info->type_stack->type.classdef->pmiscbuf)
6603 || ! ieee_write_asn (info, nindx, 'z')
6604 || ! ieee_write_atn65 (info, nindx, "")
6605 || ! ieee_write_asn (info, nindx,
6606 info->type_stack->type.classdef->voffset))
6607 return false;
6608 if (info->type_stack->type.classdef->ownvptr)
6609 {
6610 if (! ieee_write_atn65 (info, nindx, ""))
6611 return false;
6612 }
6613 else
6614 {
6615 if (! ieee_write_atn65 (info, nindx,
6616 info->type_stack->type.classdef->vclass))
6617 return false;
6618 }
6619 if (! ieee_write_asn (info, nindx, 0))
6620 return false;
6621 info->type_stack->type.classdef->pmisccount += 5;
6622 }
6623
6624 /* Now that we know the number of pmisc records, we can write out
6625 the atn62 which starts the pmisc records, and append them to the
6626 C++ buffers. */
6627
6628 if (! ieee_change_buffer (info, &info->cxx)
6629 || ! ieee_write_byte (info, (int) ieee_nn_record)
6630 || ! ieee_write_number (info, nindx)
6631 || ! ieee_write_id (info, "")
6632 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6633 || ! ieee_write_number (info, nindx)
6634 || ! ieee_write_number (info, 0)
6635 || ! ieee_write_number (info, 62)
6636 || ! ieee_write_number (info, 80)
6637 || ! ieee_write_number (info,
6638 info->type_stack->type.classdef->pmisccount))
6639 return false;
6640
6641 if (! ieee_append_buffer (info, &info->cxx,
6642 &info->type_stack->type.classdef->pmiscbuf))
6643 return false;
6644 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6645 {
6646 if (! ieee_append_buffer (info, &info->cxx,
6647 &info->type_stack->type.classdef->refs))
6648 return false;
6649 }
6650
6651 return ieee_end_struct_type (p);
6652}
6653
6654/* Push a previously seen typedef onto the type stack. */
6655
6656static boolean
6657ieee_typedef_type (p, name)
6658 PTR p;
6659 const char *name;
6660{
6661 struct ieee_handle *info = (struct ieee_handle *) p;
6662 struct ieee_name_type_hash_entry *h;
6663 struct ieee_name_type *nt;
6664
6665 h = ieee_name_type_hash_lookup (&info->typedefs, name, false, false);
6666
6667 /* h should never be NULL, since that would imply that the generic
6668 debugging code has asked for a typedef which it has not yet
6669 defined. */
6670 assert (h != NULL);
6671
6672 /* We always use the most recently defined type for this name, which
6673 will be the first one on the list. */
6674
6675 nt = h->types;
6676 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6677 nt->type.unsignedp, nt->type.localp))
6678 return false;
6679
6680 /* Copy over any other type information we may have. */
6681 info->type_stack->type = nt->type;
6682
6683 return true;
6684}
6685
6686/* Push a tagged type onto the type stack. */
6687
6688static boolean
6689ieee_tag_type (p, name, id, kind)
6690 PTR p;
6691 const char *name;
6692 unsigned int id;
6693 enum debug_type_kind kind;
6694{
6695 struct ieee_handle *info = (struct ieee_handle *) p;
6696 boolean localp;
6697 boolean copy;
6698 char ab[20];
6699 struct ieee_name_type_hash_entry *h;
6700 struct ieee_name_type *nt;
6701
6702 if (kind == DEBUG_KIND_ENUM)
6703 {
6704 struct ieee_defined_enum *e;
6705
6706 if (name == NULL)
6707 abort ();
6708 for (e = info->enums; e != NULL; e = e->next)
6709 if (e->tag != NULL && strcmp (e->tag, name) == 0)
6710 return ieee_push_type (info, e->indx, 0, true, false);
6711
6712 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
6713 memset (e, 0, sizeof *e);
6714
6715 e->indx = info->type_indx;
6716 ++info->type_indx;
6717 e->tag = name;
6718 e->defined = false;
6719
6720 e->next = info->enums;
6721 info->enums = e;
6722
6723 return ieee_push_type (info, e->indx, 0, true, false);
6724 }
6725
6726 localp = false;
6727
6728 copy = false;
6729 if (name == NULL)
6730 {
6731 sprintf (ab, "__anon%u", id);
6732 name = ab;
6733 copy = true;
6734 }
6735
6736 h = ieee_name_type_hash_lookup (&info->tags, name, true, copy);
6737 if (h == NULL)
6738 return false;
6739
6740 for (nt = h->types; nt != NULL; nt = nt->next)
6741 {
6742 if (nt->id == id)
6743 {
6744 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6745 nt->type.unsignedp, nt->type.localp))
6746 return false;
6747 /* Copy over any other type information we may have. */
6748 info->type_stack->type = nt->type;
6749 return true;
6750 }
6751
6752 if (! nt->type.localp)
6753 {
6754 /* This is a duplicate of a global type, so it must be
6755 local. */
6756 localp = true;
6757 }
6758 }
6759
6760 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6761 memset (nt, 0, sizeof *nt);
6762
6763 nt->id = id;
6764 nt->type.name = h->root.string;
6765 nt->type.indx = info->type_indx;
6766 nt->type.localp = localp;
6767 ++info->type_indx;
6768 nt->kind = kind;
6769
6770 nt->next = h->types;
6771 h->types = nt;
6772
6773 if (! ieee_push_type (info, nt->type.indx, 0, false, localp))
6774 return false;
6775
6776 info->type_stack->type.name = h->root.string;
6777
6778 return true;
6779}
6780
6781/* Output a typedef. */
6782
6783static boolean
6784ieee_typdef (p, name)
6785 PTR p;
6786 const char *name;
6787{
6788 struct ieee_handle *info = (struct ieee_handle *) p;
6789 struct ieee_write_type type;
6790 unsigned int indx;
6791 boolean found;
6792 boolean localp;
6793 struct ieee_name_type_hash_entry *h;
6794 struct ieee_name_type *nt;
6795
6796 type = info->type_stack->type;
6797 indx = type.indx;
6798
6799 /* If this is a simple builtin type using a builtin name, we don't
6800 want to output the typedef itself. We also want to change the
6801 type index to correspond to the name being used. We recognize
6802 names used in stabs debugging output even if they don't exactly
6803 correspond to the names used for the IEEE builtin types. */
6804 found = false;
6805 if (indx <= (unsigned int) builtin_bcd_float)
6806 {
6807 switch ((enum builtin_types) indx)
6808 {
6809 default:
6810 break;
6811
6812 case builtin_void:
6813 if (strcmp (name, "void") == 0)
6814 found = true;
6815 break;
6816
6817 case builtin_signed_char:
6818 case builtin_char:
6819 if (strcmp (name, "signed char") == 0)
6820 {
6821 indx = (unsigned int) builtin_signed_char;
6822 found = true;
6823 }
6824 else if (strcmp (name, "char") == 0)
6825 {
6826 indx = (unsigned int) builtin_char;
6827 found = true;
6828 }
6829 break;
6830
6831 case builtin_unsigned_char:
6832 if (strcmp (name, "unsigned char") == 0)
6833 found = true;
6834 break;
6835
6836 case builtin_signed_short_int:
6837 case builtin_short:
6838 case builtin_short_int:
6839 case builtin_signed_short:
6840 if (strcmp (name, "signed short int") == 0)
6841 {
6842 indx = (unsigned int) builtin_signed_short_int;
6843 found = true;
6844 }
6845 else if (strcmp (name, "short") == 0)
6846 {
6847 indx = (unsigned int) builtin_short;
6848 found = true;
6849 }
6850 else if (strcmp (name, "short int") == 0)
6851 {
6852 indx = (unsigned int) builtin_short_int;
6853 found = true;
6854 }
6855 else if (strcmp (name, "signed short") == 0)
6856 {
6857 indx = (unsigned int) builtin_signed_short;
6858 found = true;
6859 }
6860 break;
6861
6862 case builtin_unsigned_short_int:
6863 case builtin_unsigned_short:
6864 if (strcmp (name, "unsigned short int") == 0
6865 || strcmp (name, "short unsigned int") == 0)
6866 {
6867 indx = builtin_unsigned_short_int;
6868 found = true;
6869 }
6870 else if (strcmp (name, "unsigned short") == 0)
6871 {
6872 indx = builtin_unsigned_short;
6873 found = true;
6874 }
6875 break;
6876
6877 case builtin_signed_long:
6878 case builtin_int: /* FIXME: Size depends upon architecture. */
6879 case builtin_long:
6880 if (strcmp (name, "signed long") == 0)
6881 {
6882 indx = builtin_signed_long;
6883 found = true;
6884 }
6885 else if (strcmp (name, "int") == 0)
6886 {
6887 indx = builtin_int;
6888 found = true;
6889 }
6890 else if (strcmp (name, "long") == 0
6891 || strcmp (name, "long int") == 0)
6892 {
6893 indx = builtin_long;
6894 found = true;
6895 }
6896 break;
6897
6898 case builtin_unsigned_long:
6899 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
6900 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
6901 if (strcmp (name, "unsigned long") == 0
6902 || strcmp (name, "long unsigned int") == 0)
6903 {
6904 indx = builtin_unsigned_long;
6905 found = true;
6906 }
6907 else if (strcmp (name, "unsigned") == 0)
6908 {
6909 indx = builtin_unsigned;
6910 found = true;
6911 }
6912 else if (strcmp (name, "unsigned int") == 0)
6913 {
6914 indx = builtin_unsigned_int;
6915 found = true;
6916 }
6917 break;
6918
6919 case builtin_signed_long_long:
6920 if (strcmp (name, "signed long long") == 0
6921 || strcmp (name, "long long int") == 0)
6922 found = true;
6923 break;
6924
6925 case builtin_unsigned_long_long:
6926 if (strcmp (name, "unsigned long long") == 0
6927 || strcmp (name, "long long unsigned int") == 0)
6928 found = true;
6929 break;
6930
6931 case builtin_float:
6932 if (strcmp (name, "float") == 0)
6933 found = true;
6934 break;
6935
6936 case builtin_double:
6937 if (strcmp (name, "double") == 0)
6938 found = true;
6939 break;
6940
6941 case builtin_long_double:
6942 if (strcmp (name, "long double") == 0)
6943 found = true;
6944 break;
6945
6946 case builtin_long_long_double:
6947 if (strcmp (name, "long long double") == 0)
6948 found = true;
6949 break;
6950 }
6951
6952 if (found)
6953 type.indx = indx;
6954 }
6955
6956 h = ieee_name_type_hash_lookup (&info->typedefs, name, true, false);
6957 if (h == NULL)
6958 return false;
6959
6960 /* See if we have already defined this type with this name. */
6961 localp = type.localp;
6962 for (nt = h->types; nt != NULL; nt = nt->next)
6963 {
6964 if (nt->id == indx)
6965 {
6966 /* If this is a global definition, then we don't need to
6967 do anything here. */
6968 if (! nt->type.localp)
6969 {
6970 ieee_pop_unused_type (info);
6971 return true;
6972 }
6973 }
6974 else
6975 {
6976 /* This is a duplicate definition, so make this one local. */
6977 localp = true;
6978 }
6979 }
6980
6981 /* We need to add a new typedef for this type. */
6982
6983 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6984 memset (nt, 0, sizeof *nt);
6985 nt->id = indx;
6986 nt->type = type;
6987 nt->type.name = name;
6988 nt->type.localp = localp;
6989 nt->kind = DEBUG_KIND_ILLEGAL;
6990
6991 nt->next = h->types;
6992 h->types = nt;
6993
6994 if (found)
6995 {
6996 /* This is one of the builtin typedefs, so we don't need to
6997 actually define it. */
6998 ieee_pop_unused_type (info);
6999 return true;
7000 }
7001
7002 indx = ieee_pop_type (info);
7003
7004 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
7005 type.unsignedp, localp,
7006 (struct ieee_buflist *) NULL)
7007 || ! ieee_write_number (info, 'T')
7008 || ! ieee_write_number (info, indx))
7009 return false;
7010
7011 /* Remove the type we just added to the type stack. This should not
7012 be ieee_pop_unused_type, since the type is used, we just don't
7013 need it now. */
7014 (void) ieee_pop_type (info);
7015
7016 return true;
7017}
7018
7019/* Output a tag for a type. We don't have to do anything here. */
7020
7021static boolean
7022ieee_tag (p, name)
7023 PTR p;
b4c96d0d 7024 const char *name ATTRIBUTE_UNUSED;
252b5132
RH		 7025{
7026 struct ieee_handle *info = (struct ieee_handle *) p;
7027
7028 /* This should not be ieee_pop_unused_type, since we want the type
7029 to be defined. */
7030 (void) ieee_pop_type (info);
7031 return true;
7032}
7033
7034/* Output an integer constant. */
7035
7036static boolean
7037ieee_int_constant (p, name, val)
b4c96d0d
ILT		 7038 PTR p ATTRIBUTE_UNUSED;
7039 const char *name ATTRIBUTE_UNUSED;
7040 bfd_vma val ATTRIBUTE_UNUSED;
252b5132
RH		 7041{
7042 /* FIXME. */
7043 return true;
7044}
7045
7046/* Output a floating point constant. */
7047
7048static boolean
7049ieee_float_constant (p, name, val)
b4c96d0d
ILT		 7050 PTR p ATTRIBUTE_UNUSED;
7051 const char *name ATTRIBUTE_UNUSED;
7052 double val ATTRIBUTE_UNUSED;
252b5132
RH		 7053{
7054 /* FIXME. */
7055 return true;
7056}
7057
7058/* Output a typed constant. */
7059
7060static boolean
7061ieee_typed_constant (p, name, val)
7062 PTR p;
b4c96d0d
ILT		 7063 const char *name ATTRIBUTE_UNUSED;
7064 bfd_vma val ATTRIBUTE_UNUSED;
252b5132
RH		 7065{
7066 struct ieee_handle *info = (struct ieee_handle *) p;
7067
7068 /* FIXME. */
7069 ieee_pop_unused_type (info);
7070 return true;
7071}
7072
7073/* Output a variable. */
7074
7075static boolean
7076ieee_variable (p, name, kind, val)
7077 PTR p;
7078 const char *name;
7079 enum debug_var_kind kind;
7080 bfd_vma val;
7081{
7082 struct ieee_handle *info = (struct ieee_handle *) p;
7083 unsigned int name_indx;
7084 unsigned int size;
7085 boolean referencep;
7086 unsigned int type_indx;
7087 boolean asn;
7088 int refflag;
7089
7090 size = info->type_stack->type.size;
7091 referencep = info->type_stack->type.referencep;
7092 type_indx = ieee_pop_type (info);
7093
7094 assert (! ieee_buffer_emptyp (&info->vars));
7095 if (! ieee_change_buffer (info, &info->vars))
7096 return false;
7097
7098 name_indx = info->name_indx;
7099 ++info->name_indx;
7100
7101 /* Write out an NN and an ATN record for this variable. */
7102 if (! ieee_write_byte (info, (int) ieee_nn_record)
7103 || ! ieee_write_number (info, name_indx)
7104 || ! ieee_write_id (info, name)
7105 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7106 || ! ieee_write_number (info, name_indx)
7107 || ! ieee_write_number (info, type_indx))
7108 return false;
7109 switch (kind)
7110 {
7111 default:
7112 abort ();
7113 return false;
7114 case DEBUG_GLOBAL:
7115 if (! ieee_write_number (info, 8)
7116 || ! ieee_add_range (info, false, val, val + size))
7117 return false;
7118 refflag = 0;
7119 asn = true;
7120 break;
7121 case DEBUG_STATIC:
7122 if (! ieee_write_number (info, 3)
7123 || ! ieee_add_range (info, false, val, val + size))
7124 return false;
7125 refflag = 1;
7126 asn = true;
7127 break;
7128 case DEBUG_LOCAL_STATIC:
7129 if (! ieee_write_number (info, 3)
7130 || ! ieee_add_range (info, false, val, val + size))
7131 return false;
7132 refflag = 2;
7133 asn = true;
7134 break;
7135 case DEBUG_LOCAL:
7136 if (! ieee_write_number (info, 1)
7137 || ! ieee_write_number (info, val))
7138 return false;
7139 refflag = 2;
7140 asn = false;
7141 break;
7142 case DEBUG_REGISTER:
7143 if (! ieee_write_number (info, 2)
7144 || ! ieee_write_number (info,
7145 ieee_genreg_to_regno (info->abfd, val)))
7146 return false;
7147 refflag = 2;
7148 asn = false;
7149 break;
7150 }
7151
7152 if (asn)
7153 {
7154 if (! ieee_write_asn (info, name_indx, val))
7155 return false;
7156 }
7157
7158 /* If this is really a reference type, then we just output it with
7159 pointer type, and must now output a C++ record indicating that it
7160 is really reference type. */
7161 if (referencep)
7162 {
7163 unsigned int nindx;
7164
7165 nindx = info->name_indx;
7166 ++info->name_indx;
7167
7168 /* If this is a global variable, we want to output the misc
7169 record in the C++ misc record block. Otherwise, we want to
7170 output it just after the variable definition, which is where
7171 the current buffer is. */
7172 if (refflag != 2)
7173 {
7174 if (! ieee_change_buffer (info, &info->cxx))
7175 return false;
7176 }
7177
7178 if (! ieee_write_byte (info, (int) ieee_nn_record)
7179 || ! ieee_write_number (info, nindx)
7180 || ! ieee_write_id (info, "")
7181 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7182 || ! ieee_write_number (info, nindx)
7183 || ! ieee_write_number (info, 0)
7184 || ! ieee_write_number (info, 62)
7185 || ! ieee_write_number (info, 80)
7186 || ! ieee_write_number (info, 3)
7187 || ! ieee_write_asn (info, nindx, 'R')
7188 || ! ieee_write_asn (info, nindx, refflag)
7189 || ! ieee_write_atn65 (info, nindx, name))
7190 return false;
7191 }
7192
7193 return true;
7194}
7195
7196/* Start outputting information for a function. */
7197
7198static boolean
7199ieee_start_function (p, name, global)
7200 PTR p;
7201 const char *name;
7202 boolean global;
7203{
7204 struct ieee_handle *info = (struct ieee_handle *) p;
7205 boolean referencep;
7206 unsigned int retindx, typeindx;
7207
7208 referencep = info->type_stack->type.referencep;
7209 retindx = ieee_pop_type (info);
7210
7211 /* Besides recording a BB4 or BB6 block, we record the type of the
7212 function in the BB1 typedef block. We can't write out the full
7213 type until we have seen all the parameters, so we accumulate it
7214 in info->fntype and info->fnargs. */
7215 if (! ieee_buffer_emptyp (&info->fntype))
7216 {
7217 /* FIXME: This might happen someday if we support nested
7218 functions. */
7219 abort ();
7220 }
7221
7222 info->fnname = name;
7223
7224 /* An attribute of 0x40 means that the push mask is unknown. */
7225 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, false, true,
7226 &info->fntype)
7227 || ! ieee_write_number (info, 'x')
7228 || ! ieee_write_number (info, 0x40)
7229 || ! ieee_write_number (info, 0)
7230 || ! ieee_write_number (info, 0)
7231 || ! ieee_write_number (info, retindx))
7232 return false;
7233
7234 typeindx = ieee_pop_type (info);
7235
7236 if (! ieee_init_buffer (info, &info->fnargs))
7237 return false;
7238 info->fnargcount = 0;
7239
7240 /* If the function return value is actually a reference type, we
7241 must add a record indicating that. */
7242 if (referencep)
7243 {
7244 unsigned int nindx;
7245
7246 nindx = info->name_indx;
7247 ++info->name_indx;
7248 if (! ieee_change_buffer (info, &info->cxx)
7249 || ! ieee_write_byte (info, (int) ieee_nn_record)
7250 || ! ieee_write_number (info, nindx)
7251 || ! ieee_write_id (info, "")
7252 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7253 || ! ieee_write_number (info, nindx)
7254 || ! ieee_write_number (info, 0)
7255 || ! ieee_write_number (info, 62)
7256 || ! ieee_write_number (info, 80)
7257 || ! ieee_write_number (info, 3)
7258 || ! ieee_write_asn (info, nindx, 'R')
7259 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7260 || ! ieee_write_atn65 (info, nindx, name))
7261 return false;
7262 }
7263
7264 assert (! ieee_buffer_emptyp (&info->vars));
7265 if (! ieee_change_buffer (info, &info->vars))
7266 return false;
7267
7268 /* The address is written out as the first block. */
7269
7270 ++info->block_depth;
7271
7272 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7273 && ieee_write_byte (info, global ? 4 : 6)
7274 && ieee_write_number (info, 0)
7275 && ieee_write_id (info, name)
7276 && ieee_write_number (info, 0)
7277 && ieee_write_number (info, typeindx));
7278}
7279
7280/* Add a function parameter. This will normally be called before the
7281 first block, so we postpone them until we see the block. */
7282
7283static boolean
7284ieee_function_parameter (p, name, kind, val)
7285 PTR p;
7286 const char *name;
7287 enum debug_parm_kind kind;
7288 bfd_vma val;
7289{
7290 struct ieee_handle *info = (struct ieee_handle *) p;
7291 struct ieee_pending_parm *m, **pm;
7292
7293 assert (info->block_depth == 1);
7294
7295 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7296 memset (m, 0, sizeof *m);
7297
7298 m->next = NULL;
7299 m->name = name;
7300 m->referencep = info->type_stack->type.referencep;
7301 m->type = ieee_pop_type (info);
7302 m->kind = kind;
7303 m->val = val;
7304
7305 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7306 ;
7307 *pm = m;
7308
7309 /* Add the type to the fnargs list. */
7310 if (! ieee_change_buffer (info, &info->fnargs)
7311 || ! ieee_write_number (info, m->type))
7312 return false;
7313 ++info->fnargcount;
7314
7315 return true;
7316}
7317
7318/* Output pending function parameters. */
7319
7320static boolean
7321ieee_output_pending_parms (info)
7322 struct ieee_handle *info;
7323{
7324 struct ieee_pending_parm *m;
7325 unsigned int refcount;
7326
7327 refcount = 0;
7328 for (m = info->pending_parms; m != NULL; m = m->next)
7329 {
7330 enum debug_var_kind vkind;
7331
7332 switch (m->kind)
7333 {
7334 default:
7335 abort ();
7336 return false;
7337 case DEBUG_PARM_STACK:
7338 case DEBUG_PARM_REFERENCE:
7339 vkind = DEBUG_LOCAL;
7340 break;
7341 case DEBUG_PARM_REG:
7342 case DEBUG_PARM_REF_REG:
7343 vkind = DEBUG_REGISTER;
7344 break;
7345 }
7346
7347 if (! ieee_push_type (info, m->type, 0, false, false))
7348 return false;
7349 info->type_stack->type.referencep = m->referencep;
7350 if (m->referencep)
7351 ++refcount;
7352 if (! ieee_variable ((PTR) info, m->name, vkind, m->val))
7353 return false;
7354 }
7355
7356 /* If there are any reference parameters, we need to output a
7357 miscellaneous record indicating them. */
7358 if (refcount > 0)
7359 {
7360 unsigned int nindx, varindx;
7361
7362 /* FIXME: The MRI compiler outputs the demangled function name
7363 here, but we are outputting the mangled name. */
7364 nindx = info->name_indx;
7365 ++info->name_indx;
7366 if (! ieee_change_buffer (info, &info->vars)
7367 || ! ieee_write_byte (info, (int) ieee_nn_record)
7368 || ! ieee_write_number (info, nindx)
7369 || ! ieee_write_id (info, "")
7370 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7371 || ! ieee_write_number (info, nindx)
7372 || ! ieee_write_number (info, 0)
7373 || ! ieee_write_number (info, 62)
7374 || ! ieee_write_number (info, 80)
7375 || ! ieee_write_number (info, refcount + 3)
7376 || ! ieee_write_asn (info, nindx, 'B')
7377 || ! ieee_write_atn65 (info, nindx, info->fnname)
7378 || ! ieee_write_asn (info, nindx, 0))
7379 return false;
7380 for (m = info->pending_parms, varindx = 1;
7381 m != NULL;
7382 m = m->next, varindx++)
7383 {
7384 if (m->referencep)
7385 {
7386 if (! ieee_write_asn (info, nindx, varindx))
7387 return false;
7388 }
7389 }
7390 }
7391
7392 m = info->pending_parms;
7393 while (m != NULL)
7394 {
7395 struct ieee_pending_parm *next;
7396
7397 next = m->next;
7398 free (m);
7399 m = next;
7400 }
7401
7402 info->pending_parms = NULL;
7403
7404 return true;
7405}
7406
7407/* Start a block. If this is the first block, we output the address
7408 to finish the BB4 or BB6, and then output the function parameters. */
7409
7410static boolean
7411ieee_start_block (p, addr)
7412 PTR p;
7413 bfd_vma addr;
7414{
7415 struct ieee_handle *info = (struct ieee_handle *) p;
7416
7417 if (! ieee_change_buffer (info, &info->vars))
7418 return false;
7419
7420 if (info->block_depth == 1)
7421 {
7422 if (! ieee_write_number (info, addr)
7423 || ! ieee_output_pending_parms (info))
7424 return false;
7425 }
7426 else
7427 {
7428 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7429 || ! ieee_write_byte (info, 6)
7430 || ! ieee_write_number (info, 0)
7431 || ! ieee_write_id (info, "")
7432 || ! ieee_write_number (info, 0)
7433 || ! ieee_write_number (info, 0)
7434 || ! ieee_write_number (info, addr))
7435 return false;
7436 }
7437
7438 if (! ieee_start_range (info, addr))
7439 return false;
7440
7441 ++info->block_depth;
7442
7443 return true;
7444}
7445
7446/* End a block. */
7447
7448static boolean
7449ieee_end_block (p, addr)
7450 PTR p;
7451 bfd_vma addr;
7452{
7453 struct ieee_handle *info = (struct ieee_handle *) p;
7454
7455 /* The address we are given is the end of the block, but IEEE seems
7456 to want to the address of the last byte in the block, so we
7457 subtract one. */
7458 if (! ieee_change_buffer (info, &info->vars)
7459 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7460 || ! ieee_write_number (info, addr - 1))
7461 return false;
7462
7463 if (! ieee_end_range (info, addr))
7464 return false;
7465
7466 --info->block_depth;
7467
7468 if (addr > info->highaddr)
7469 info->highaddr = addr;
7470
7471 return true;
7472}
7473
7474/* End a function. */
7475
7476static boolean
7477ieee_end_function (p)
7478 PTR p;
7479{
7480 struct ieee_handle *info = (struct ieee_handle *) p;
7481
7482 assert (info->block_depth == 1);
7483
7484 --info->block_depth;
7485
7486 /* Now we can finish up fntype, and add it to the typdef section.
7487 At this point, fntype is the 'x' type up to the argument count,
7488 and fnargs is the argument types. We must add the argument
7489 count, and we must add the level. FIXME: We don't record varargs
7490 functions correctly. In fact, stabs debugging does not give us
7491 enough information to do so. */
7492 if (! ieee_change_buffer (info, &info->fntype)
7493 || ! ieee_write_number (info, info->fnargcount)
7494 || ! ieee_change_buffer (info, &info->fnargs)
7495 || ! ieee_write_number (info, 0))
7496 return false;
7497
7498 /* Make sure the typdef block has been started. */
7499 if (ieee_buffer_emptyp (&info->types))
7500 {
7501 if (! ieee_change_buffer (info, &info->types)
7502 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7503 || ! ieee_write_byte (info, 1)
7504 || ! ieee_write_number (info, 0)
7505 || ! ieee_write_id (info, info->modname))
7506 return false;
7507 }
7508
7509 if (! ieee_append_buffer (info, &info->types, &info->fntype)
7510 || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7511 return false;
7512
7513 info->fnname = NULL;
7514 if (! ieee_init_buffer (info, &info->fntype)
7515 || ! ieee_init_buffer (info, &info->fnargs))
7516 return false;
7517 info->fnargcount = 0;
7518
7519 return true;
7520}
7521
7522/* Record line number information. */
7523
7524static boolean
7525ieee_lineno (p, filename, lineno, addr)
7526 PTR p;
7527 const char *filename;
7528 unsigned long lineno;
7529 bfd_vma addr;
7530{
7531 struct ieee_handle *info = (struct ieee_handle *) p;
7532
7533 assert (info->filename != NULL);
7534
7535 /* The HP simulator seems to get confused when more than one line is
7536 listed for the same address, at least if they are in different
7537 files. We handle this by always listing the last line for a
7538 given address, since that seems to be the one that gdb uses. */
7539 if (info->pending_lineno_filename != NULL
7540 && addr != info->pending_lineno_addr)
7541 {
7542 /* Make sure we have a line number block. */
7543 if (! ieee_buffer_emptyp (&info->linenos))
7544 {
7545 if (! ieee_change_buffer (info, &info->linenos))
7546 return false;
7547 }
7548 else
7549 {
7550 info->lineno_name_indx = info->name_indx;
7551 ++info->name_indx;
7552 if (! ieee_change_buffer (info, &info->linenos)
7553 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7554 || ! ieee_write_byte (info, 5)
7555 || ! ieee_write_number (info, 0)
7556 || ! ieee_write_id (info, info->filename)
7557 || ! ieee_write_byte (info, (int) ieee_nn_record)
7558 || ! ieee_write_number (info, info->lineno_name_indx)
7559 || ! ieee_write_id (info, ""))
7560 return false;
7561 info->lineno_filename = info->filename;
7562 }
7563
7564 if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0)
7565 {
7566 if (strcmp (info->filename, info->lineno_filename) != 0)
7567 {
7568 /* We were not in the main file. Close the block for the
7569 included file. */
7570 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7571 return false;
7572 if (strcmp (info->filename, info->pending_lineno_filename) == 0)
7573 {
7574 /* We need a new NN record, and we aren't about to
7575 output one. */
7576 info->lineno_name_indx = info->name_indx;
7577 ++info->name_indx;
7578 if (! ieee_write_byte (info, (int) ieee_nn_record)
7579 || ! ieee_write_number (info, info->lineno_name_indx)
7580 || ! ieee_write_id (info, ""))
7581 return false;
7582 }
7583 }
7584 if (strcmp (info->filename, info->pending_lineno_filename) != 0)
7585 {
7586 /* We are not changing to the main file. Open a block for
7587 the new included file. */
7588 info->lineno_name_indx = info->name_indx;
7589 ++info->name_indx;
7590 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7591 || ! ieee_write_byte (info, 5)
7592 || ! ieee_write_number (info, 0)
7593 || ! ieee_write_id (info, info->pending_lineno_filename)
7594 || ! ieee_write_byte (info, (int) ieee_nn_record)
7595 || ! ieee_write_number (info, info->lineno_name_indx)
7596 || ! ieee_write_id (info, ""))
7597 return false;
7598 }
7599 info->lineno_filename = info->pending_lineno_filename;
7600 }
7601
7602 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7603 || ! ieee_write_number (info, info->lineno_name_indx)
7604 || ! ieee_write_number (info, 0)
7605 || ! ieee_write_number (info, 7)
7606 || ! ieee_write_number (info, info->pending_lineno)
7607 || ! ieee_write_number (info, 0)
7608 || ! ieee_write_asn (info, info->lineno_name_indx,
7609 info->pending_lineno_addr))
7610 return false;
7611 }
7612
7613 info->pending_lineno_filename = filename;
7614 info->pending_lineno = lineno;
7615 info->pending_lineno_addr = addr;
7616
7617 return true;
7618}
GDB Binutils - Deliverables
This page took 0.316656 seconds and 4 git commands to generate.