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