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