Update my e-mail address.
[binutils-gdb.git] / binutils / ieee.c
blob13181b472afb9abef5f3cb56f0969bd0b99f1b3b
1 /* ieee.c -- Read and write IEEE-695 debugging information.
2 Copyright (C) 1996-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
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 3 of the License, or
10 (at your option) any later version.
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.
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., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
22 /* This file reads and writes IEEE-695 debugging information. */
24 #include "sysdep.h"
25 #include <assert.h>
26 #include "bfd.h"
27 #include "ieee.h"
28 #include "libiberty.h"
29 #include "debug.h"
30 #include "budbg.h"
31 #include "filenames.h"
33 /* This structure holds an entry on the block stack. */
35 struct ieee_block
37 /* The kind of block. */
38 int kind;
39 /* The source file name, for a BB5 block. */
40 const char *filename;
41 /* The index of the function type, for a BB4 or BB6 block. */
42 unsigned int fnindx;
43 /* TRUE if this function is being skipped. */
44 bfd_boolean skip;
47 /* This structure is the block stack. */
49 #define BLOCKSTACK_SIZE (16)
51 struct ieee_blockstack
53 /* The stack pointer. */
54 struct ieee_block *bsp;
55 /* The stack. */
56 struct ieee_block stack[BLOCKSTACK_SIZE];
59 /* This structure holds information for a variable. */
61 enum ieee_var_kind
63 IEEE_UNKNOWN,
64 IEEE_EXTERNAL,
65 IEEE_GLOBAL,
66 IEEE_STATIC,
67 IEEE_LOCAL,
68 IEEE_FUNCTION
71 struct ieee_var
73 /* Start of name. */
74 const char *name;
75 /* Length of name. */
76 unsigned long namlen;
77 /* Type. */
78 debug_type type;
79 /* Slot if we make an indirect type. */
80 debug_type *pslot;
81 /* Kind of variable or function. */
82 enum ieee_var_kind kind;
85 /* This structure holds all the variables. */
87 struct ieee_vars
89 /* Number of slots allocated. */
90 unsigned int alloc;
91 /* Variables. */
92 struct ieee_var *vars;
95 /* This structure holds information for a type. We need this because
96 we don't want to represent bitfields as real types. */
98 struct ieee_type
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;
111 /* This structure holds all the type information. */
113 struct ieee_types
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];
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. */
127 struct ieee_tag
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;
143 /* This structure holds the information we pass around to the parsing
144 functions. */
146 struct ieee_info
148 /* The debugging handle. */
149 void *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 bfd_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;
172 /* Basic builtin types, not including the pointers. */
174 enum builtin_types
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
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. */
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)
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. */
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)
250 /* Local functions. */
252 static void ieee_error (struct ieee_info *, const bfd_byte *, const char *);
253 static void ieee_eof (struct ieee_info *);
254 static char *savestring (const char *, unsigned long);
255 static bfd_boolean ieee_read_number
256 (struct ieee_info *, const bfd_byte **, bfd_vma *);
257 static bfd_boolean ieee_read_optional_number
258 (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *);
259 static bfd_boolean ieee_read_id
260 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
261 static bfd_boolean ieee_read_optional_id
262 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *,
263 bfd_boolean *);
264 static bfd_boolean ieee_read_expression
265 (struct ieee_info *, const bfd_byte **, bfd_vma *);
266 static debug_type ieee_builtin_type
267 (struct ieee_info *, const bfd_byte *, unsigned int);
268 static bfd_boolean ieee_alloc_type
269 (struct ieee_info *, unsigned int, bfd_boolean);
270 static bfd_boolean ieee_read_type_index
271 (struct ieee_info *, const bfd_byte **, debug_type *);
272 static int ieee_regno_to_genreg (bfd *, int);
273 static int ieee_genreg_to_regno (bfd *, int);
274 static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **);
275 static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **);
276 static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **);
277 static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **);
278 static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **);
279 static bfd_boolean ieee_read_cxx_misc
280 (struct ieee_info *, const bfd_byte **, unsigned long);
281 static bfd_boolean ieee_read_cxx_class
282 (struct ieee_info *, const bfd_byte **, unsigned long);
283 static bfd_boolean ieee_read_cxx_defaults
284 (struct ieee_info *, const bfd_byte **, unsigned long);
285 static bfd_boolean ieee_read_reference
286 (struct ieee_info *, const bfd_byte **);
287 static bfd_boolean ieee_require_asn
288 (struct ieee_info *, const bfd_byte **, bfd_vma *);
289 static bfd_boolean ieee_require_atn65
290 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
292 /* Report an error in the IEEE debugging information. */
294 static void
295 ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s)
297 if (p != NULL)
298 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
299 (unsigned long) (p - info->bytes), s, *p);
300 else
301 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
304 /* Report an unexpected EOF in the IEEE debugging information. */
306 static void
307 ieee_eof (struct ieee_info *info)
309 ieee_error (info, (const bfd_byte *) NULL,
310 _("unexpected end of debugging information"));
313 /* Save a string in memory. */
315 static char *
316 savestring (const char *start, unsigned long len)
318 char *ret;
320 ret = (char *) xmalloc (len + 1);
321 memcpy (ret, start, len);
322 ret[len] = '\0';
323 return ret;
326 /* Read a number which must be present in an IEEE file. */
328 static bfd_boolean
329 ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
331 return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
334 /* Read a number in an IEEE file. If ppresent is not NULL, the number
335 need not be there. */
337 static bfd_boolean
338 ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp,
339 bfd_vma *pv, bfd_boolean *ppresent)
341 ieee_record_enum_type b;
343 if (*pp >= info->pend)
345 if (ppresent != NULL)
347 *ppresent = FALSE;
348 return TRUE;
350 ieee_eof (info);
351 return FALSE;
354 b = (ieee_record_enum_type) **pp;
355 ++*pp;
357 if (b <= ieee_number_end_enum)
359 *pv = (bfd_vma) b;
360 if (ppresent != NULL)
361 *ppresent = TRUE;
362 return TRUE;
365 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
367 unsigned int i;
369 i = (int) b - (int) ieee_number_repeat_start_enum;
370 if (*pp + i - 1 >= info->pend)
372 ieee_eof (info);
373 return FALSE;
376 *pv = 0;
377 for (; i > 0; i--)
379 *pv <<= 8;
380 *pv += **pp;
381 ++*pp;
384 if (ppresent != NULL)
385 *ppresent = TRUE;
387 return TRUE;
390 if (ppresent != NULL)
392 --*pp;
393 *ppresent = FALSE;
394 return TRUE;
397 ieee_error (info, *pp - 1, _("invalid number"));
398 return FALSE;
401 /* Read a required string from an IEEE file. */
403 static bfd_boolean
404 ieee_read_id (struct ieee_info *info, const bfd_byte **pp,
405 const char **pname, unsigned long *pnamlen)
407 return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
410 /* Read a string from an IEEE file. If ppresent is not NULL, the
411 string is optional. */
413 static bfd_boolean
414 ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp,
415 const char **pname, unsigned long *pnamlen,
416 bfd_boolean *ppresent)
418 bfd_byte b;
419 unsigned long len;
421 if (*pp >= info->pend)
423 ieee_eof (info);
424 return FALSE;
427 b = **pp;
428 ++*pp;
430 if (b <= 0x7f)
431 len = b;
432 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
434 len = **pp;
435 ++*pp;
437 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
439 len = (**pp << 8) + (*pp)[1];
440 *pp += 2;
442 else
444 if (ppresent != NULL)
446 --*pp;
447 *ppresent = FALSE;
448 return TRUE;
450 ieee_error (info, *pp - 1, _("invalid string length"));
451 return FALSE;
454 if ((unsigned long) (info->pend - *pp) < len)
456 ieee_eof (info);
457 return FALSE;
460 *pname = (const char *) *pp;
461 *pnamlen = len;
462 *pp += len;
464 if (ppresent != NULL)
465 *ppresent = TRUE;
467 return TRUE;
470 /* Read an expression from an IEEE file. Since this code is only used
471 to parse debugging information, I haven't bothered to write a full
472 blown IEEE expression parser. I've only thrown in the things I've
473 seen in debugging information. This can be easily extended if
474 necessary. */
476 static bfd_boolean
477 ieee_read_expression (struct ieee_info *info, const bfd_byte **pp,
478 bfd_vma *pv)
480 const bfd_byte *expr_start;
481 #define EXPR_STACK_SIZE (10)
482 bfd_vma expr_stack[EXPR_STACK_SIZE];
483 bfd_vma *esp;
485 expr_start = *pp;
487 esp = expr_stack;
489 while (1)
491 const bfd_byte *start;
492 bfd_vma val;
493 bfd_boolean present;
494 ieee_record_enum_type c;
496 start = *pp;
498 if (! ieee_read_optional_number (info, pp, &val, &present))
499 return FALSE;
501 if (present)
503 if (esp - expr_stack >= EXPR_STACK_SIZE)
505 ieee_error (info, start, _("expression stack overflow"));
506 return FALSE;
508 *esp++ = val;
509 continue;
512 c = (ieee_record_enum_type) **pp;
514 if (c >= ieee_module_beginning_enum)
515 break;
517 ++*pp;
519 if (c == ieee_comma)
520 break;
522 switch (c)
524 default:
525 ieee_error (info, start, _("unsupported IEEE expression operator"));
526 break;
528 case ieee_variable_R_enum:
530 bfd_vma indx;
531 asection *s;
533 if (! ieee_read_number (info, pp, &indx))
534 return FALSE;
535 for (s = info->abfd->sections; s != NULL; s = s->next)
536 if ((bfd_vma) s->target_index == indx)
537 break;
538 if (s == NULL)
540 ieee_error (info, start, _("unknown section"));
541 return FALSE;
544 if (esp - expr_stack >= EXPR_STACK_SIZE)
546 ieee_error (info, start, _("expression stack overflow"));
547 return FALSE;
550 *esp++ = bfd_get_section_vma (info->abfd, s);
552 break;
554 case ieee_function_plus_enum:
555 case ieee_function_minus_enum:
557 bfd_vma v1, v2;
559 if (esp - expr_stack < 2)
561 ieee_error (info, start, _("expression stack underflow"));
562 return FALSE;
565 v1 = *--esp;
566 v2 = *--esp;
567 *esp++ = v1 + v2;
569 break;
573 if (esp - 1 != expr_stack)
575 ieee_error (info, expr_start, _("expression stack mismatch"));
576 return FALSE;
579 *pv = *--esp;
581 return TRUE;
584 /* Return an IEEE builtin type. */
586 static debug_type
587 ieee_builtin_type (struct ieee_info *info, const bfd_byte *p,
588 unsigned int indx)
590 void *dhandle;
591 debug_type type;
592 const char *name;
594 if (indx < BUILTIN_TYPE_COUNT
595 && info->types.builtins[indx] != DEBUG_TYPE_NULL)
596 return info->types.builtins[indx];
598 dhandle = info->dhandle;
600 if (indx >= 32 && indx < 64)
602 type = debug_make_pointer_type (dhandle,
603 ieee_builtin_type (info, p, indx - 32));
604 assert (indx < BUILTIN_TYPE_COUNT);
605 info->types.builtins[indx] = type;
606 return type;
609 switch ((enum builtin_types) indx)
611 default:
612 ieee_error (info, p, _("unknown builtin type"));
613 return NULL;
615 case builtin_unknown:
616 type = debug_make_void_type (dhandle);
617 name = NULL;
618 break;
620 case builtin_void:
621 type = debug_make_void_type (dhandle);
622 name = "void";
623 break;
625 case builtin_signed_char:
626 type = debug_make_int_type (dhandle, 1, FALSE);
627 name = "signed char";
628 break;
630 case builtin_unsigned_char:
631 type = debug_make_int_type (dhandle, 1, TRUE);
632 name = "unsigned char";
633 break;
635 case builtin_signed_short_int:
636 type = debug_make_int_type (dhandle, 2, FALSE);
637 name = "signed short int";
638 break;
640 case builtin_unsigned_short_int:
641 type = debug_make_int_type (dhandle, 2, TRUE);
642 name = "unsigned short int";
643 break;
645 case builtin_signed_long:
646 type = debug_make_int_type (dhandle, 4, FALSE);
647 name = "signed long";
648 break;
650 case builtin_unsigned_long:
651 type = debug_make_int_type (dhandle, 4, TRUE);
652 name = "unsigned long";
653 break;
655 case builtin_signed_long_long:
656 type = debug_make_int_type (dhandle, 8, FALSE);
657 name = "signed long long";
658 break;
660 case builtin_unsigned_long_long:
661 type = debug_make_int_type (dhandle, 8, TRUE);
662 name = "unsigned long long";
663 break;
665 case builtin_float:
666 type = debug_make_float_type (dhandle, 4);
667 name = "float";
668 break;
670 case builtin_double:
671 type = debug_make_float_type (dhandle, 8);
672 name = "double";
673 break;
675 case builtin_long_double:
676 /* FIXME: The size for this type should depend upon the
677 processor. */
678 type = debug_make_float_type (dhandle, 12);
679 name = "long double";
680 break;
682 case builtin_long_long_double:
683 type = debug_make_float_type (dhandle, 16);
684 name = "long long double";
685 break;
687 case builtin_quoted_string:
688 type = debug_make_array_type (dhandle,
689 ieee_builtin_type (info, p,
690 ((unsigned int)
691 builtin_char)),
692 ieee_builtin_type (info, p,
693 ((unsigned int)
694 builtin_int)),
695 0, -1, TRUE);
696 name = "QUOTED STRING";
697 break;
699 case builtin_instruction_address:
700 /* FIXME: This should be a code address. */
701 type = debug_make_int_type (dhandle, 4, TRUE);
702 name = "instruction address";
703 break;
705 case builtin_int:
706 /* FIXME: The size for this type should depend upon the
707 processor. */
708 type = debug_make_int_type (dhandle, 4, FALSE);
709 name = "int";
710 break;
712 case builtin_unsigned:
713 /* FIXME: The size for this type should depend upon the
714 processor. */
715 type = debug_make_int_type (dhandle, 4, TRUE);
716 name = "unsigned";
717 break;
719 case builtin_unsigned_int:
720 /* FIXME: The size for this type should depend upon the
721 processor. */
722 type = debug_make_int_type (dhandle, 4, TRUE);
723 name = "unsigned int";
724 break;
726 case builtin_char:
727 type = debug_make_int_type (dhandle, 1, FALSE);
728 name = "char";
729 break;
731 case builtin_long:
732 type = debug_make_int_type (dhandle, 4, FALSE);
733 name = "long";
734 break;
736 case builtin_short:
737 type = debug_make_int_type (dhandle, 2, FALSE);
738 name = "short";
739 break;
741 case builtin_unsigned_short:
742 type = debug_make_int_type (dhandle, 2, TRUE);
743 name = "unsigned short";
744 break;
746 case builtin_short_int:
747 type = debug_make_int_type (dhandle, 2, FALSE);
748 name = "short int";
749 break;
751 case builtin_signed_short:
752 type = debug_make_int_type (dhandle, 2, FALSE);
753 name = "signed short";
754 break;
756 case builtin_bcd_float:
757 ieee_error (info, p, _("BCD float type not supported"));
758 return DEBUG_TYPE_NULL;
761 if (name != NULL)
762 type = debug_name_type (dhandle, name, type);
764 assert (indx < BUILTIN_TYPE_COUNT);
766 info->types.builtins[indx] = type;
768 return type;
771 /* Allocate more space in the type table. If ref is TRUE, this is a
772 reference to the type; if it is not already defined, we should set
773 up an indirect type. */
775 static bfd_boolean
776 ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref)
778 unsigned int nalloc;
779 register struct ieee_type *t;
780 struct ieee_type *tend;
782 if (indx >= info->types.alloc)
784 nalloc = info->types.alloc;
785 if (nalloc == 0)
786 nalloc = 4;
787 while (indx >= nalloc)
788 nalloc *= 2;
790 info->types.types = ((struct ieee_type *)
791 xrealloc (info->types.types,
792 nalloc * sizeof *info->types.types));
794 memset (info->types.types + info->types.alloc, 0,
795 (nalloc - info->types.alloc) * sizeof *info->types.types);
797 tend = info->types.types + nalloc;
798 for (t = info->types.types + info->types.alloc; t < tend; t++)
799 t->type = DEBUG_TYPE_NULL;
801 info->types.alloc = nalloc;
804 if (ref)
806 t = info->types.types + indx;
807 if (t->type == NULL)
809 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
810 *t->pslot = DEBUG_TYPE_NULL;
811 t->type = debug_make_indirect_type (info->dhandle, t->pslot,
812 (const char *) NULL);
813 if (t->type == NULL)
814 return FALSE;
818 return TRUE;
821 /* Read a type index and return the corresponding type. */
823 static bfd_boolean
824 ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp,
825 debug_type *ptype)
827 const bfd_byte *start;
828 bfd_vma indx;
830 start = *pp;
832 if (! ieee_read_number (info, pp, &indx))
833 return FALSE;
835 if (indx < 256)
837 *ptype = ieee_builtin_type (info, start, indx);
838 if (*ptype == NULL)
839 return FALSE;
840 return TRUE;
843 indx -= 256;
844 if (! ieee_alloc_type (info, indx, TRUE))
845 return FALSE;
847 *ptype = info->types.types[indx].type;
849 return TRUE;
852 /* Parse IEEE debugging information for a file. This is passed the
853 bytes which compose the Debug Information Part of an IEEE file. */
855 bfd_boolean
856 parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len)
858 struct ieee_info info;
859 unsigned int i;
860 const bfd_byte *p, *pend;
862 info.dhandle = dhandle;
863 info.abfd = abfd;
864 info.bytes = bytes;
865 info.pend = bytes + len;
866 info.blockstack.bsp = info.blockstack.stack;
867 info.saw_filename = FALSE;
868 info.vars.alloc = 0;
869 info.vars.vars = NULL;
870 info.global_vars = NULL;
871 info.types.alloc = 0;
872 info.types.types = NULL;
873 info.global_types = NULL;
874 info.tags = NULL;
875 for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
876 info.types.builtins[i] = DEBUG_TYPE_NULL;
878 p = bytes;
879 pend = info.pend;
880 while (p < pend)
882 const bfd_byte *record_start;
883 ieee_record_enum_type c;
885 record_start = p;
887 c = (ieee_record_enum_type) *p++;
889 if (c == ieee_at_record_enum)
890 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
892 if (c <= ieee_number_repeat_end_enum)
894 ieee_error (&info, record_start, _("unexpected number"));
895 return FALSE;
898 switch (c)
900 default:
901 ieee_error (&info, record_start, _("unexpected record type"));
902 return FALSE;
904 case ieee_bb_record_enum:
905 if (! parse_ieee_bb (&info, &p))
906 return FALSE;
907 break;
909 case ieee_be_record_enum:
910 if (! parse_ieee_be (&info, &p))
911 return FALSE;
912 break;
914 case ieee_nn_record:
915 if (! parse_ieee_nn (&info, &p))
916 return FALSE;
917 break;
919 case ieee_ty_record_enum:
920 if (! parse_ieee_ty (&info, &p))
921 return FALSE;
922 break;
924 case ieee_atn_record_enum:
925 if (! parse_ieee_atn (&info, &p))
926 return FALSE;
927 break;
931 if (info.blockstack.bsp != info.blockstack.stack)
933 ieee_error (&info, (const bfd_byte *) NULL,
934 _("blocks left on stack at end"));
935 return FALSE;
938 return TRUE;
941 /* Handle an IEEE BB record. */
943 static bfd_boolean
944 parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp)
946 const bfd_byte *block_start;
947 bfd_byte b;
948 bfd_vma size;
949 const char *name;
950 unsigned long namlen;
951 char *namcopy = NULL;
952 unsigned int fnindx;
953 bfd_boolean skip;
955 block_start = *pp;
957 b = **pp;
958 ++*pp;
960 if (! ieee_read_number (info, pp, &size)
961 || ! ieee_read_id (info, pp, &name, &namlen))
962 return FALSE;
964 fnindx = (unsigned int) -1;
965 skip = FALSE;
967 switch (b)
969 case 1:
970 /* BB1: Type definitions local to a module. */
971 namcopy = savestring (name, namlen);
972 if (namcopy == NULL)
973 return FALSE;
974 if (! debug_set_filename (info->dhandle, namcopy))
975 return FALSE;
976 info->saw_filename = TRUE;
978 /* Discard any variables or types we may have seen before. */
979 if (info->vars.vars != NULL)
980 free (info->vars.vars);
981 info->vars.vars = NULL;
982 info->vars.alloc = 0;
983 if (info->types.types != NULL)
984 free (info->types.types);
985 info->types.types = NULL;
986 info->types.alloc = 0;
988 /* Initialize the types to the global types. */
989 if (info->global_types != NULL)
991 info->types.alloc = info->global_types->alloc;
992 info->types.types = ((struct ieee_type *)
993 xmalloc (info->types.alloc
994 * sizeof (*info->types.types)));
995 memcpy (info->types.types, info->global_types->types,
996 info->types.alloc * sizeof (*info->types.types));
999 break;
1001 case 2:
1002 /* BB2: Global type definitions. The name is supposed to be
1003 empty, but we don't check. */
1004 if (! debug_set_filename (info->dhandle, "*global*"))
1005 return FALSE;
1006 info->saw_filename = TRUE;
1007 break;
1009 case 3:
1010 /* BB3: High level module block begin. We don't have to do
1011 anything here. The name is supposed to be the same as for
1012 the BB1, but we don't check. */
1013 break;
1015 case 4:
1016 /* BB4: Global function. */
1018 bfd_vma stackspace, typindx, offset;
1019 debug_type return_type;
1021 if (! ieee_read_number (info, pp, &stackspace)
1022 || ! ieee_read_number (info, pp, &typindx)
1023 || ! ieee_read_expression (info, pp, &offset))
1024 return FALSE;
1026 /* We have no way to record the stack space. FIXME. */
1028 if (typindx < 256)
1030 return_type = ieee_builtin_type (info, block_start, typindx);
1031 if (return_type == DEBUG_TYPE_NULL)
1032 return FALSE;
1034 else
1036 typindx -= 256;
1037 if (! ieee_alloc_type (info, typindx, TRUE))
1038 return FALSE;
1039 fnindx = typindx;
1040 return_type = info->types.types[typindx].type;
1041 if (debug_get_type_kind (info->dhandle, return_type)
1042 == DEBUG_KIND_FUNCTION)
1043 return_type = debug_get_return_type (info->dhandle,
1044 return_type);
1047 namcopy = savestring (name, namlen);
1048 if (namcopy == NULL)
1049 return FALSE;
1050 if (! debug_record_function (info->dhandle, namcopy, return_type,
1051 TRUE, offset))
1052 return FALSE;
1054 break;
1056 case 5:
1057 /* BB5: File name for source line numbers. */
1059 unsigned int i;
1061 /* We ignore the date and time. FIXME. */
1062 for (i = 0; i < 6; i++)
1064 bfd_vma ignore;
1065 bfd_boolean present;
1067 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1068 return FALSE;
1069 if (! present)
1070 break;
1073 if (! info->saw_filename)
1075 namcopy = savestring (name, namlen);
1076 if (namcopy == NULL)
1077 return FALSE;
1078 if (! debug_set_filename (info->dhandle, namcopy))
1079 return FALSE;
1080 info->saw_filename = TRUE;
1083 namcopy = savestring (name, namlen);
1084 if (namcopy == NULL)
1085 return FALSE;
1086 if (! debug_start_source (info->dhandle, namcopy))
1087 return FALSE;
1089 break;
1091 case 6:
1092 /* BB6: Local function or block. */
1094 bfd_vma stackspace, typindx, offset;
1096 if (! ieee_read_number (info, pp, &stackspace)
1097 || ! ieee_read_number (info, pp, &typindx)
1098 || ! ieee_read_expression (info, pp, &offset))
1099 return FALSE;
1101 /* We have no way to record the stack space. FIXME. */
1103 if (namlen == 0)
1105 if (! debug_start_block (info->dhandle, offset))
1106 return FALSE;
1107 /* Change b to indicate that this is a block
1108 rather than a function. */
1109 b = 0x86;
1111 else
1113 /* The MRI C++ compiler will output a fake function named
1114 __XRYCPP to hold C++ debugging information. We skip
1115 that function. This is not crucial, but it makes
1116 converting from IEEE to other debug formats work
1117 better. */
1118 if (strncmp (name, "__XRYCPP", namlen) == 0)
1119 skip = TRUE;
1120 else
1122 debug_type return_type;
1124 if (typindx < 256)
1126 return_type = ieee_builtin_type (info, block_start,
1127 typindx);
1128 if (return_type == NULL)
1129 return FALSE;
1131 else
1133 typindx -= 256;
1134 if (! ieee_alloc_type (info, typindx, TRUE))
1135 return FALSE;
1136 fnindx = typindx;
1137 return_type = info->types.types[typindx].type;
1138 if (debug_get_type_kind (info->dhandle, return_type)
1139 == DEBUG_KIND_FUNCTION)
1140 return_type = debug_get_return_type (info->dhandle,
1141 return_type);
1144 namcopy = savestring (name, namlen);
1145 if (namcopy == NULL)
1146 return FALSE;
1147 if (! debug_record_function (info->dhandle, namcopy,
1148 return_type, FALSE, offset))
1149 return FALSE;
1153 break;
1155 case 10:
1156 /* BB10: Assembler module scope. In the normal case, we
1157 completely ignore all this information. FIXME. */
1159 const char *inam, *vstr;
1160 unsigned long inamlen, vstrlen;
1161 bfd_vma tool_type;
1162 bfd_boolean present;
1163 unsigned int i;
1165 if (! info->saw_filename)
1167 namcopy = savestring (name, namlen);
1168 if (namcopy == NULL)
1169 return FALSE;
1170 if (! debug_set_filename (info->dhandle, namcopy))
1171 return FALSE;
1172 info->saw_filename = TRUE;
1175 if (! ieee_read_id (info, pp, &inam, &inamlen)
1176 || ! ieee_read_number (info, pp, &tool_type)
1177 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1178 return FALSE;
1179 for (i = 0; i < 6; i++)
1181 bfd_vma ignore;
1183 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1184 return FALSE;
1185 if (! present)
1186 break;
1189 break;
1191 case 11:
1192 /* BB11: Module section. We completely ignore all this
1193 information. FIXME. */
1195 bfd_vma sectype, secindx, offset, map;
1196 bfd_boolean present;
1198 if (! ieee_read_number (info, pp, &sectype)
1199 || ! ieee_read_number (info, pp, &secindx)
1200 || ! ieee_read_expression (info, pp, &offset)
1201 || ! ieee_read_optional_number (info, pp, &map, &present))
1202 return FALSE;
1204 break;
1206 default:
1207 ieee_error (info, block_start, _("unknown BB type"));
1208 return FALSE;
1212 /* Push this block on the block stack. */
1214 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1216 ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
1217 return FALSE;
1220 info->blockstack.bsp->kind = b;
1221 if (b == 5)
1222 info->blockstack.bsp->filename = namcopy;
1223 info->blockstack.bsp->fnindx = fnindx;
1224 info->blockstack.bsp->skip = skip;
1225 ++info->blockstack.bsp;
1227 return TRUE;
1230 /* Handle an IEEE BE record. */
1232 static bfd_boolean
1233 parse_ieee_be (struct ieee_info *info, const bfd_byte **pp)
1235 bfd_vma offset;
1237 if (info->blockstack.bsp <= info->blockstack.stack)
1239 ieee_error (info, *pp, _("stack underflow"));
1240 return FALSE;
1242 --info->blockstack.bsp;
1244 switch (info->blockstack.bsp->kind)
1246 case 2:
1247 /* When we end the global typedefs block, we copy out the
1248 contents of info->vars. This is because the variable indices
1249 may be reused in the local blocks. However, we need to
1250 preserve them so that we can locate a function returning a
1251 reference variable whose type is named in the global typedef
1252 block. */
1253 info->global_vars = ((struct ieee_vars *)
1254 xmalloc (sizeof *info->global_vars));
1255 info->global_vars->alloc = info->vars.alloc;
1256 info->global_vars->vars = ((struct ieee_var *)
1257 xmalloc (info->vars.alloc
1258 * sizeof (*info->vars.vars)));
1259 memcpy (info->global_vars->vars, info->vars.vars,
1260 info->vars.alloc * sizeof (*info->vars.vars));
1262 /* We also copy out the non builtin parts of info->types, since
1263 the types are discarded when we start a new block. */
1264 info->global_types = ((struct ieee_types *)
1265 xmalloc (sizeof *info->global_types));
1266 info->global_types->alloc = info->types.alloc;
1267 info->global_types->types = ((struct ieee_type *)
1268 xmalloc (info->types.alloc
1269 * sizeof (*info->types.types)));
1270 memcpy (info->global_types->types, info->types.types,
1271 info->types.alloc * sizeof (*info->types.types));
1272 memset (info->global_types->builtins, 0,
1273 sizeof (info->global_types->builtins));
1275 break;
1277 case 4:
1278 case 6:
1279 if (! ieee_read_expression (info, pp, &offset))
1280 return FALSE;
1281 if (! info->blockstack.bsp->skip)
1283 if (! debug_end_function (info->dhandle, offset + 1))
1284 return FALSE;
1286 break;
1288 case 0x86:
1289 /* This is BE6 when BB6 started a block rather than a local
1290 function. */
1291 if (! ieee_read_expression (info, pp, &offset))
1292 return FALSE;
1293 if (! debug_end_block (info->dhandle, offset + 1))
1294 return FALSE;
1295 break;
1297 case 5:
1298 /* When we end a BB5, we look up the stack for the last BB5, if
1299 there is one, so that we can call debug_start_source. */
1300 if (info->blockstack.bsp > info->blockstack.stack)
1302 struct ieee_block *bl;
1304 bl = info->blockstack.bsp;
1307 --bl;
1308 if (bl->kind == 5)
1310 if (! debug_start_source (info->dhandle, bl->filename))
1311 return FALSE;
1312 break;
1315 while (bl != info->blockstack.stack);
1317 break;
1319 case 11:
1320 if (! ieee_read_expression (info, pp, &offset))
1321 return FALSE;
1322 /* We just ignore the module size. FIXME. */
1323 break;
1325 default:
1326 /* Other block types do not have any trailing information. */
1327 break;
1330 return TRUE;
1333 /* Parse an NN record. */
1335 static bfd_boolean
1336 parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp)
1338 const bfd_byte *nn_start;
1339 bfd_vma varindx;
1340 const char *name;
1341 unsigned long namlen;
1343 nn_start = *pp;
1345 if (! ieee_read_number (info, pp, &varindx)
1346 || ! ieee_read_id (info, pp, &name, &namlen))
1347 return FALSE;
1349 if (varindx < 32)
1351 ieee_error (info, nn_start, _("illegal variable index"));
1352 return FALSE;
1354 varindx -= 32;
1356 if (varindx >= info->vars.alloc)
1358 unsigned int alloc;
1360 alloc = info->vars.alloc;
1361 if (alloc == 0)
1362 alloc = 4;
1363 while (varindx >= alloc)
1364 alloc *= 2;
1365 info->vars.vars = ((struct ieee_var *)
1366 xrealloc (info->vars.vars,
1367 alloc * sizeof *info->vars.vars));
1368 memset (info->vars.vars + info->vars.alloc, 0,
1369 (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1370 info->vars.alloc = alloc;
1373 info->vars.vars[varindx].name = name;
1374 info->vars.vars[varindx].namlen = namlen;
1376 return TRUE;
1379 /* Parse a TY record. */
1381 static bfd_boolean
1382 parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp)
1384 const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1385 bfd_vma typeindx, varindx, tc;
1386 void *dhandle;
1387 bfd_boolean tag, typdef;
1388 debug_type *arg_slots;
1389 unsigned long type_bitsize;
1390 debug_type type;
1392 ty_start = *pp;
1394 if (! ieee_read_number (info, pp, &typeindx))
1395 return FALSE;
1397 if (typeindx < 256)
1399 ieee_error (info, ty_start, _("illegal type index"));
1400 return FALSE;
1403 typeindx -= 256;
1404 if (! ieee_alloc_type (info, typeindx, FALSE))
1405 return FALSE;
1407 if (**pp != 0xce)
1409 ieee_error (info, *pp, _("unknown TY code"));
1410 return FALSE;
1412 ++*pp;
1414 ty_var_start = *pp;
1416 if (! ieee_read_number (info, pp, &varindx))
1417 return FALSE;
1419 if (varindx < 32)
1421 ieee_error (info, ty_var_start, _("illegal variable index"));
1422 return FALSE;
1424 varindx -= 32;
1426 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1428 ieee_error (info, ty_var_start, _("undefined variable in TY"));
1429 return FALSE;
1432 ty_code_start = *pp;
1434 if (! ieee_read_number (info, pp, &tc))
1435 return FALSE;
1437 dhandle = info->dhandle;
1439 tag = FALSE;
1440 typdef = FALSE;
1441 arg_slots = NULL;
1442 type_bitsize = 0;
1443 switch (tc)
1445 default:
1446 ieee_error (info, ty_code_start, _("unknown TY code"));
1447 return FALSE;
1449 case '!':
1450 /* Unknown type, with size. We treat it as int. FIXME. */
1452 bfd_vma size;
1454 if (! ieee_read_number (info, pp, &size))
1455 return FALSE;
1456 type = debug_make_int_type (dhandle, size, FALSE);
1458 break;
1460 case 'A': /* Array. */
1461 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1462 distinguished from normal array. */
1464 debug_type ele_type;
1465 bfd_vma lower, upper;
1467 if (! ieee_read_type_index (info, pp, &ele_type)
1468 || ! ieee_read_number (info, pp, &lower)
1469 || ! ieee_read_number (info, pp, &upper))
1470 return FALSE;
1471 type = debug_make_array_type (dhandle, ele_type,
1472 ieee_builtin_type (info, ty_code_start,
1473 ((unsigned int)
1474 builtin_int)),
1475 (bfd_signed_vma) lower,
1476 (bfd_signed_vma) upper,
1477 FALSE);
1479 break;
1481 case 'E':
1482 /* Simple enumeration. */
1484 bfd_vma size;
1485 unsigned int alloc;
1486 const char **names;
1487 unsigned int c;
1488 bfd_signed_vma *vals;
1489 unsigned int i;
1491 if (! ieee_read_number (info, pp, &size))
1492 return FALSE;
1493 /* FIXME: we ignore the enumeration size. */
1495 alloc = 10;
1496 names = (const char **) xmalloc (alloc * sizeof *names);
1497 memset (names, 0, alloc * sizeof *names);
1498 c = 0;
1499 while (1)
1501 const char *name;
1502 unsigned long namlen;
1503 bfd_boolean present;
1505 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1506 return FALSE;
1507 if (! present)
1508 break;
1510 if (c + 1 >= alloc)
1512 alloc += 10;
1513 names = ((const char **)
1514 xrealloc (names, alloc * sizeof *names));
1517 names[c] = savestring (name, namlen);
1518 if (names[c] == NULL)
1519 return FALSE;
1520 ++c;
1523 names[c] = NULL;
1525 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1526 for (i = 0; i < c; i++)
1527 vals[i] = i;
1529 type = debug_make_enum_type (dhandle, names, vals);
1530 tag = TRUE;
1532 break;
1534 case 'G':
1535 /* Struct with bit fields. */
1537 bfd_vma size;
1538 unsigned int alloc;
1539 debug_field *fields;
1540 unsigned int c;
1542 if (! ieee_read_number (info, pp, &size))
1543 return FALSE;
1545 alloc = 10;
1546 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1547 c = 0;
1548 while (1)
1550 const char *name;
1551 unsigned long namlen;
1552 bfd_boolean present;
1553 debug_type ftype;
1554 bfd_vma bitpos, bitsize;
1556 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1557 return FALSE;
1558 if (! present)
1559 break;
1560 if (! ieee_read_type_index (info, pp, &ftype)
1561 || ! ieee_read_number (info, pp, &bitpos)
1562 || ! ieee_read_number (info, pp, &bitsize))
1563 return FALSE;
1565 if (c + 1 >= alloc)
1567 alloc += 10;
1568 fields = ((debug_field *)
1569 xrealloc (fields, alloc * sizeof *fields));
1572 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1573 ftype, bitpos, bitsize,
1574 DEBUG_VISIBILITY_PUBLIC);
1575 if (fields[c] == NULL)
1576 return FALSE;
1577 ++c;
1580 fields[c] = NULL;
1582 type = debug_make_struct_type (dhandle, TRUE, size, fields);
1583 tag = TRUE;
1585 break;
1587 case 'N':
1588 /* Enumeration. */
1590 unsigned int alloc;
1591 const char **names;
1592 bfd_signed_vma *vals;
1593 unsigned int c;
1595 alloc = 10;
1596 names = (const char **) xmalloc (alloc * sizeof *names);
1597 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1598 c = 0;
1599 while (1)
1601 const char *name;
1602 unsigned long namlen;
1603 bfd_boolean present;
1604 bfd_vma val;
1606 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1607 return FALSE;
1608 if (! present)
1609 break;
1610 if (! ieee_read_number (info, pp, &val))
1611 return FALSE;
1613 /* If the length of the name is zero, then the value is
1614 actually the size of the enum. We ignore this
1615 information. FIXME. */
1616 if (namlen == 0)
1617 continue;
1619 if (c + 1 >= alloc)
1621 alloc += 10;
1622 names = ((const char **)
1623 xrealloc (names, alloc * sizeof *names));
1624 vals = ((bfd_signed_vma *)
1625 xrealloc (vals, alloc * sizeof *vals));
1628 names[c] = savestring (name, namlen);
1629 if (names[c] == NULL)
1630 return FALSE;
1631 vals[c] = (bfd_signed_vma) val;
1632 ++c;
1635 names[c] = NULL;
1637 type = debug_make_enum_type (dhandle, names, vals);
1638 tag = TRUE;
1640 break;
1642 case 'O': /* Small pointer. We don't distinguish small and large
1643 pointers. FIXME. */
1644 case 'P': /* Large pointer. */
1646 debug_type t;
1648 if (! ieee_read_type_index (info, pp, &t))
1649 return FALSE;
1650 type = debug_make_pointer_type (dhandle, t);
1652 break;
1654 case 'R':
1655 /* Range. */
1657 bfd_vma low, high, signedp, size;
1659 if (! ieee_read_number (info, pp, &low)
1660 || ! ieee_read_number (info, pp, &high)
1661 || ! ieee_read_number (info, pp, &signedp)
1662 || ! ieee_read_number (info, pp, &size))
1663 return FALSE;
1665 type = debug_make_range_type (dhandle,
1666 debug_make_int_type (dhandle, size,
1667 ! signedp),
1668 (bfd_signed_vma) low,
1669 (bfd_signed_vma) high);
1671 break;
1673 case 'S': /* Struct. */
1674 case 'U': /* Union. */
1676 bfd_vma size;
1677 unsigned int alloc;
1678 debug_field *fields;
1679 unsigned int c;
1681 if (! ieee_read_number (info, pp, &size))
1682 return FALSE;
1684 alloc = 10;
1685 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1686 c = 0;
1687 while (1)
1689 const char *name;
1690 unsigned long namlen;
1691 bfd_boolean present;
1692 bfd_vma tindx;
1693 bfd_vma offset;
1694 debug_type ftype;
1695 bfd_vma bitsize;
1697 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1698 return FALSE;
1699 if (! present)
1700 break;
1701 if (! ieee_read_number (info, pp, &tindx)
1702 || ! ieee_read_number (info, pp, &offset))
1703 return FALSE;
1705 if (tindx < 256)
1707 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1708 bitsize = 0;
1709 offset *= 8;
1711 else
1713 struct ieee_type *t;
1715 tindx -= 256;
1716 if (! ieee_alloc_type (info, tindx, TRUE))
1717 return FALSE;
1718 t = info->types.types + tindx;
1719 ftype = t->type;
1720 bitsize = t->bitsize;
1721 if (bitsize == 0)
1722 offset *= 8;
1725 if (c + 1 >= alloc)
1727 alloc += 10;
1728 fields = ((debug_field *)
1729 xrealloc (fields, alloc * sizeof *fields));
1732 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1733 ftype, offset, bitsize,
1734 DEBUG_VISIBILITY_PUBLIC);
1735 if (fields[c] == NULL)
1736 return FALSE;
1737 ++c;
1740 fields[c] = NULL;
1742 type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1743 tag = TRUE;
1745 break;
1747 case 'T':
1748 /* Typedef. */
1749 if (! ieee_read_type_index (info, pp, &type))
1750 return FALSE;
1751 typdef = TRUE;
1752 break;
1754 case 'X':
1755 /* Procedure. FIXME: This is an extern declaration, which we
1756 have no way of representing. */
1758 bfd_vma attr;
1759 debug_type rtype;
1760 bfd_vma nargs;
1761 bfd_boolean present;
1762 struct ieee_var *pv;
1764 /* FIXME: We ignore the attribute and the argument names. */
1766 if (! ieee_read_number (info, pp, &attr)
1767 || ! ieee_read_type_index (info, pp, &rtype)
1768 || ! ieee_read_number (info, pp, &nargs))
1769 return FALSE;
1772 const char *name;
1773 unsigned long namlen;
1775 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1776 return FALSE;
1778 while (present);
1780 pv = info->vars.vars + varindx;
1781 pv->kind = IEEE_EXTERNAL;
1782 if (pv->namlen > 0
1783 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1785 /* Set up the return type as an indirect type pointing to
1786 the variable slot, so that we can change it to a
1787 reference later if appropriate. */
1788 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1789 *pv->pslot = rtype;
1790 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1791 (const char *) NULL);
1794 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1795 FALSE);
1797 break;
1799 case 'V':
1800 case 'v':
1801 /* Void. This is not documented, but the MRI compiler emits it. */
1802 type = debug_make_void_type (dhandle);
1803 break;
1805 case 'Z':
1806 /* Array with 0 lower bound. */
1808 debug_type etype;
1809 bfd_vma high;
1811 if (! ieee_read_type_index (info, pp, &etype)
1812 || ! ieee_read_number (info, pp, &high))
1813 return FALSE;
1815 type = debug_make_array_type (dhandle, etype,
1816 ieee_builtin_type (info, ty_code_start,
1817 ((unsigned int)
1818 builtin_int)),
1819 0, (bfd_signed_vma) high, FALSE);
1821 break;
1823 case 'c': /* Complex. */
1824 case 'd': /* Double complex. */
1826 const char *name;
1827 unsigned long namlen;
1829 /* FIXME: I don't know what the name means. */
1831 if (! ieee_read_id (info, pp, &name, &namlen))
1832 return FALSE;
1834 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1836 break;
1838 case 'f':
1839 /* Pascal file name. FIXME. */
1840 ieee_error (info, ty_code_start, _("Pascal file name not supported"));
1841 return FALSE;
1843 case 'g':
1844 /* Bitfield type. */
1846 bfd_vma signedp, bitsize, dummy;
1847 const bfd_byte *hold;
1848 bfd_boolean present;
1850 if (! ieee_read_number (info, pp, &signedp)
1851 || ! ieee_read_number (info, pp, &bitsize))
1852 return FALSE;
1854 /* I think the documentation says that there is a type index,
1855 but some actual files do not have one. */
1856 hold = *pp;
1857 if (! ieee_read_optional_number (info, pp, &dummy, &present))
1858 return FALSE;
1859 if (! present)
1861 /* FIXME: This is just a guess. */
1862 type = debug_make_int_type (dhandle, 4,
1863 signedp ? FALSE : TRUE);
1865 else
1867 *pp = hold;
1868 if (! ieee_read_type_index (info, pp, &type))
1869 return FALSE;
1871 type_bitsize = bitsize;
1873 break;
1875 case 'n':
1876 /* Qualifier. */
1878 bfd_vma kind;
1879 debug_type t;
1881 if (! ieee_read_number (info, pp, &kind)
1882 || ! ieee_read_type_index (info, pp, &t))
1883 return FALSE;
1885 switch (kind)
1887 default:
1888 ieee_error (info, ty_start, _("unsupported qualifier"));
1889 return FALSE;
1891 case 1:
1892 type = debug_make_const_type (dhandle, t);
1893 break;
1895 case 2:
1896 type = debug_make_volatile_type (dhandle, t);
1897 break;
1900 break;
1902 case 's':
1903 /* Set. */
1905 bfd_vma size;
1906 debug_type etype;
1908 if (! ieee_read_number (info, pp, &size)
1909 || ! ieee_read_type_index (info, pp, &etype))
1910 return FALSE;
1912 /* FIXME: We ignore the size. */
1914 type = debug_make_set_type (dhandle, etype, FALSE);
1916 break;
1918 case 'x':
1919 /* Procedure with compiler dependencies. */
1921 struct ieee_var *pv;
1922 bfd_vma attr, frame_type, push_mask, nargs, level, father;
1923 debug_type rtype;
1924 debug_type *arg_types;
1925 bfd_boolean varargs;
1926 bfd_boolean present;
1928 /* FIXME: We ignore some of this information. */
1930 pv = info->vars.vars + varindx;
1932 if (! ieee_read_number (info, pp, &attr)
1933 || ! ieee_read_number (info, pp, &frame_type)
1934 || ! ieee_read_number (info, pp, &push_mask)
1935 || ! ieee_read_type_index (info, pp, &rtype)
1936 || ! ieee_read_number (info, pp, &nargs))
1937 return FALSE;
1938 if (nargs == (bfd_vma) -1)
1940 arg_types = NULL;
1941 varargs = FALSE;
1943 else
1945 unsigned int i;
1947 arg_types = ((debug_type *)
1948 xmalloc ((nargs + 1) * sizeof *arg_types));
1949 for (i = 0; i < nargs; i++)
1950 if (! ieee_read_type_index (info, pp, arg_types + i))
1951 return FALSE;
1953 /* If the last type is pointer to void, this is really a
1954 varargs function. */
1955 varargs = FALSE;
1956 if (nargs > 0)
1958 debug_type last;
1960 last = arg_types[nargs - 1];
1961 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1962 && (debug_get_type_kind (dhandle,
1963 debug_get_target_type (dhandle,
1964 last))
1965 == DEBUG_KIND_VOID))
1967 --nargs;
1968 varargs = TRUE;
1972 /* If there are any pointer arguments, turn them into
1973 indirect types in case we later need to convert them to
1974 reference types. */
1975 for (i = 0; i < nargs; i++)
1977 if (debug_get_type_kind (dhandle, arg_types[i])
1978 == DEBUG_KIND_POINTER)
1980 if (arg_slots == NULL)
1982 arg_slots = ((debug_type *)
1983 xmalloc (nargs * sizeof *arg_slots));
1984 memset (arg_slots, 0, nargs * sizeof *arg_slots);
1986 arg_slots[i] = arg_types[i];
1987 arg_types[i] =
1988 debug_make_indirect_type (dhandle,
1989 arg_slots + i,
1990 (const char *) NULL);
1994 arg_types[nargs] = DEBUG_TYPE_NULL;
1996 if (! ieee_read_number (info, pp, &level)
1997 || ! ieee_read_optional_number (info, pp, &father, &present))
1998 return FALSE;
2000 /* We can't distinguish between a global function and a static
2001 function. */
2002 pv->kind = IEEE_FUNCTION;
2004 if (pv->namlen > 0
2005 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
2007 /* Set up the return type as an indirect type pointing to
2008 the variable slot, so that we can change it to a
2009 reference later if appropriate. */
2010 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
2011 *pv->pslot = rtype;
2012 rtype = debug_make_indirect_type (dhandle, pv->pslot,
2013 (const char *) NULL);
2016 type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
2018 break;
2021 /* Record the type in the table. */
2023 if (type == DEBUG_TYPE_NULL)
2024 return FALSE;
2026 info->vars.vars[varindx].type = type;
2028 if ((tag || typdef)
2029 && info->vars.vars[varindx].namlen > 0)
2031 const char *name;
2033 name = savestring (info->vars.vars[varindx].name,
2034 info->vars.vars[varindx].namlen);
2035 if (typdef)
2036 type = debug_name_type (dhandle, name, type);
2037 else if (tc == 'E' || tc == 'N')
2038 type = debug_tag_type (dhandle, name, type);
2039 else
2041 struct ieee_tag *it;
2043 /* We must allocate all struct tags as indirect types, so
2044 that if we later see a definition of the tag as a C++
2045 record we can update the indirect slot and automatically
2046 change all the existing references. */
2047 it = (struct ieee_tag *) xmalloc (sizeof *it);
2048 memset (it, 0, sizeof *it);
2049 it->next = info->tags;
2050 info->tags = it;
2051 it->name = name;
2052 it->slot = type;
2054 type = debug_make_indirect_type (dhandle, &it->slot, name);
2055 type = debug_tag_type (dhandle, name, type);
2057 it->type = type;
2059 if (type == NULL)
2060 return FALSE;
2063 info->types.types[typeindx].type = type;
2064 info->types.types[typeindx].arg_slots = arg_slots;
2065 info->types.types[typeindx].bitsize = type_bitsize;
2067 /* We may have already allocated type as an indirect type pointing
2068 to slot. It does no harm to replace the indirect type with the
2069 real type. Filling in slot as well handles the indirect types
2070 which are already hanging around. */
2071 if (info->types.types[typeindx].pslot != NULL)
2072 *info->types.types[typeindx].pslot = type;
2074 return TRUE;
2077 /* Parse an ATN record. */
2079 static bfd_boolean
2080 parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp)
2082 const bfd_byte *atn_start, *atn_code_start;
2083 bfd_vma varindx;
2084 struct ieee_var *pvar;
2085 debug_type type;
2086 bfd_vma atn_code;
2087 void *dhandle;
2088 bfd_vma v, v2, v3, v4, v5;
2089 const char *name;
2090 unsigned long namlen;
2091 char *namcopy;
2092 bfd_boolean present;
2093 int blocktype;
2095 atn_start = *pp;
2097 if (! ieee_read_number (info, pp, &varindx)
2098 || ! ieee_read_type_index (info, pp, &type))
2099 return FALSE;
2101 atn_code_start = *pp;
2103 if (! ieee_read_number (info, pp, &atn_code))
2104 return FALSE;
2106 if (varindx == 0)
2108 pvar = NULL;
2109 name = "";
2110 namlen = 0;
2112 else if (varindx < 32)
2114 /* The MRI compiler reportedly sometimes emits variable lifetime
2115 information for a register. We just ignore it. */
2116 if (atn_code == 9)
2117 return ieee_read_number (info, pp, &v);
2119 ieee_error (info, atn_start, _("illegal variable index"));
2120 return FALSE;
2122 else
2124 varindx -= 32;
2125 if (varindx >= info->vars.alloc
2126 || info->vars.vars[varindx].name == NULL)
2128 /* The MRI compiler or linker sometimes omits the NN record
2129 for a pmisc record. */
2130 if (atn_code == 62)
2132 if (varindx >= info->vars.alloc)
2134 unsigned int alloc;
2136 alloc = info->vars.alloc;
2137 if (alloc == 0)
2138 alloc = 4;
2139 while (varindx >= alloc)
2140 alloc *= 2;
2141 info->vars.vars = ((struct ieee_var *)
2142 xrealloc (info->vars.vars,
2143 (alloc
2144 * sizeof *info->vars.vars)));
2145 memset (info->vars.vars + info->vars.alloc, 0,
2146 ((alloc - info->vars.alloc)
2147 * sizeof *info->vars.vars));
2148 info->vars.alloc = alloc;
2151 pvar = info->vars.vars + varindx;
2152 pvar->name = "";
2153 pvar->namlen = 0;
2155 else
2157 ieee_error (info, atn_start, _("undefined variable in ATN"));
2158 return FALSE;
2162 pvar = info->vars.vars + varindx;
2164 pvar->type = type;
2166 name = pvar->name;
2167 namlen = pvar->namlen;
2170 dhandle = info->dhandle;
2172 /* If we are going to call debug_record_variable with a pointer
2173 type, change the type to an indirect type so that we can later
2174 change it to a reference type if we encounter a C++ pmisc 'R'
2175 record. */
2176 if (pvar != NULL
2177 && type != DEBUG_TYPE_NULL
2178 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2180 switch (atn_code)
2182 case 1:
2183 case 2:
2184 case 3:
2185 case 5:
2186 case 8:
2187 case 10:
2188 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2189 *pvar->pslot = type;
2190 type = debug_make_indirect_type (dhandle, pvar->pslot,
2191 (const char *) NULL);
2192 pvar->type = type;
2193 break;
2197 switch (atn_code)
2199 default:
2200 ieee_error (info, atn_code_start, _("unknown ATN type"));
2201 return FALSE;
2203 case 1:
2204 /* Automatic variable. */
2205 if (! ieee_read_number (info, pp, &v))
2206 return FALSE;
2207 namcopy = savestring (name, namlen);
2208 if (type == NULL)
2209 type = debug_make_void_type (dhandle);
2210 if (pvar != NULL)
2211 pvar->kind = IEEE_LOCAL;
2212 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2214 case 2:
2215 /* Register variable. */
2216 if (! ieee_read_number (info, pp, &v))
2217 return FALSE;
2218 namcopy = savestring (name, namlen);
2219 if (type == NULL)
2220 type = debug_make_void_type (dhandle);
2221 if (pvar != NULL)
2222 pvar->kind = IEEE_LOCAL;
2223 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2224 ieee_regno_to_genreg (info->abfd, v));
2226 case 3:
2227 /* Static variable. */
2228 if (! ieee_require_asn (info, pp, &v))
2229 return FALSE;
2230 namcopy = savestring (name, namlen);
2231 if (type == NULL)
2232 type = debug_make_void_type (dhandle);
2233 if (info->blockstack.bsp <= info->blockstack.stack)
2234 blocktype = 0;
2235 else
2236 blocktype = info->blockstack.bsp[-1].kind;
2237 if (pvar != NULL)
2239 if (blocktype == 4 || blocktype == 6)
2240 pvar->kind = IEEE_LOCAL;
2241 else
2242 pvar->kind = IEEE_STATIC;
2244 return debug_record_variable (dhandle, namcopy, type,
2245 (blocktype == 4 || blocktype == 6
2246 ? DEBUG_LOCAL_STATIC
2247 : DEBUG_STATIC),
2250 case 4:
2251 /* External function. We don't currently record these. FIXME. */
2252 if (pvar != NULL)
2253 pvar->kind = IEEE_EXTERNAL;
2254 return TRUE;
2256 case 5:
2257 /* External variable. We don't currently record these. FIXME. */
2258 if (pvar != NULL)
2259 pvar->kind = IEEE_EXTERNAL;
2260 return TRUE;
2262 case 7:
2263 if (! ieee_read_number (info, pp, &v)
2264 || ! ieee_read_number (info, pp, &v2)
2265 || ! ieee_read_optional_number (info, pp, &v3, &present))
2266 return FALSE;
2267 if (present)
2269 if (! ieee_read_optional_number (info, pp, &v4, &present))
2270 return FALSE;
2273 /* We just ignore the two optional fields in v3 and v4, since
2274 they are not defined. */
2276 if (! ieee_require_asn (info, pp, &v3))
2277 return FALSE;
2279 /* We have no way to record the column number. FIXME. */
2281 return debug_record_line (dhandle, v, v3);
2283 case 8:
2284 /* Global variable. */
2285 if (! ieee_require_asn (info, pp, &v))
2286 return FALSE;
2287 namcopy = savestring (name, namlen);
2288 if (type == NULL)
2289 type = debug_make_void_type (dhandle);
2290 if (pvar != NULL)
2291 pvar->kind = IEEE_GLOBAL;
2292 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2294 case 9:
2295 /* Variable lifetime information. */
2296 if (! ieee_read_number (info, pp, &v))
2297 return FALSE;
2299 /* We have no way to record this information. FIXME. */
2300 return TRUE;
2302 case 10:
2303 /* Locked register. The spec says that there are two required
2304 fields, but at least on occasion the MRI compiler only emits
2305 one. */
2306 if (! ieee_read_number (info, pp, &v)
2307 || ! ieee_read_optional_number (info, pp, &v2, &present))
2308 return FALSE;
2310 /* I think this means a variable that is both in a register and
2311 a frame slot. We ignore the frame slot. FIXME. */
2313 namcopy = savestring (name, namlen);
2314 if (type == NULL)
2315 type = debug_make_void_type (dhandle);
2316 if (pvar != NULL)
2317 pvar->kind = IEEE_LOCAL;
2318 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2320 case 11:
2321 /* Reserved for FORTRAN common. */
2322 ieee_error (info, atn_code_start, _("unsupported ATN11"));
2324 /* Return TRUE to keep going. */
2325 return TRUE;
2327 case 12:
2328 /* Based variable. */
2329 v3 = 0;
2330 v4 = 0x80;
2331 v5 = 0;
2332 if (! ieee_read_number (info, pp, &v)
2333 || ! ieee_read_number (info, pp, &v2)
2334 || ! ieee_read_optional_number (info, pp, &v3, &present))
2335 return FALSE;
2336 if (present)
2338 if (! ieee_read_optional_number (info, pp, &v4, &present))
2339 return FALSE;
2340 if (present)
2342 if (! ieee_read_optional_number (info, pp, &v5, &present))
2343 return FALSE;
2347 /* We have no way to record this information. FIXME. */
2349 ieee_error (info, atn_code_start, _("unsupported ATN12"));
2351 /* Return TRUE to keep going. */
2352 return TRUE;
2354 case 16:
2355 /* Constant. The description of this that I have is ambiguous,
2356 so I'm not going to try to implement it. */
2357 if (! ieee_read_number (info, pp, &v)
2358 || ! ieee_read_optional_number (info, pp, &v2, &present))
2359 return FALSE;
2360 if (present)
2362 if (! ieee_read_optional_number (info, pp, &v2, &present))
2363 return FALSE;
2364 if (present)
2366 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2367 return FALSE;
2371 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2373 if (! ieee_require_asn (info, pp, &v3))
2374 return FALSE;
2377 return TRUE;
2379 case 19:
2380 /* Static variable from assembler. */
2381 v2 = 0;
2382 if (! ieee_read_number (info, pp, &v)
2383 || ! ieee_read_optional_number (info, pp, &v2, &present)
2384 || ! ieee_require_asn (info, pp, &v3))
2385 return FALSE;
2386 namcopy = savestring (name, namlen);
2387 /* We don't really handle this correctly. FIXME. */
2388 return debug_record_variable (dhandle, namcopy,
2389 debug_make_void_type (dhandle),
2390 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2391 v3);
2393 case 62:
2394 /* Procedure miscellaneous information. */
2395 case 63:
2396 /* Variable miscellaneous information. */
2397 case 64:
2398 /* Module miscellaneous information. */
2399 if (! ieee_read_number (info, pp, &v)
2400 || ! ieee_read_number (info, pp, &v2)
2401 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2402 return FALSE;
2404 if (atn_code == 62 && v == 80)
2406 if (present)
2408 ieee_error (info, atn_code_start,
2409 _("unexpected string in C++ misc"));
2410 return FALSE;
2412 return ieee_read_cxx_misc (info, pp, v2);
2415 /* We just ignore all of this stuff. FIXME. */
2417 for (; v2 > 0; --v2)
2419 switch ((ieee_record_enum_type) **pp)
2421 default:
2422 ieee_error (info, *pp, _("bad misc record"));
2423 return FALSE;
2425 case ieee_at_record_enum:
2426 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2427 return FALSE;
2428 break;
2430 case ieee_e2_first_byte_enum:
2431 if (! ieee_require_asn (info, pp, &v3))
2432 return FALSE;
2433 break;
2437 return TRUE;
2440 /*NOTREACHED*/
2443 /* Handle C++ debugging miscellaneous records. This is called for
2444 procedure miscellaneous records of type 80. */
2446 static bfd_boolean
2447 ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp,
2448 unsigned long count)
2450 const bfd_byte *start;
2451 bfd_vma category;
2453 start = *pp;
2455 /* Get the category of C++ misc record. */
2456 if (! ieee_require_asn (info, pp, &category))
2457 return FALSE;
2458 --count;
2460 switch (category)
2462 default:
2463 ieee_error (info, start, _("unrecognized C++ misc record"));
2464 return FALSE;
2466 case 'T':
2467 if (! ieee_read_cxx_class (info, pp, count))
2468 return FALSE;
2469 break;
2471 case 'M':
2473 bfd_vma flags;
2474 const char *name;
2475 unsigned long namlen;
2477 /* The IEEE spec indicates that the 'M' record only has a
2478 flags field. The MRI compiler also emits the name of the
2479 function. */
2481 if (! ieee_require_asn (info, pp, &flags))
2482 return FALSE;
2483 if (*pp < info->pend
2484 && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2486 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2487 return FALSE;
2490 /* This is emitted for method functions, but I don't think we
2491 care very much. It might help if it told us useful
2492 information like the class with which this function is
2493 associated, but it doesn't, so it isn't helpful. */
2495 break;
2497 case 'B':
2498 if (! ieee_read_cxx_defaults (info, pp, count))
2499 return FALSE;
2500 break;
2502 case 'z':
2504 const char *name, *mangled, *cxx_class;
2505 unsigned long namlen, mangledlen, classlen;
2506 bfd_vma control;
2508 /* Pointer to member. */
2510 if (! ieee_require_atn65 (info, pp, &name, &namlen)
2511 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2512 || ! ieee_require_atn65 (info, pp, &cxx_class, &classlen)
2513 || ! ieee_require_asn (info, pp, &control))
2514 return FALSE;
2516 /* FIXME: We should now track down name and change its type. */
2518 break;
2520 case 'R':
2521 if (! ieee_read_reference (info, pp))
2522 return FALSE;
2523 break;
2526 return TRUE;
2529 /* Read a C++ class definition. This is a pmisc type 80 record of
2530 category 'T'. */
2532 static bfd_boolean
2533 ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp,
2534 unsigned long count)
2536 const bfd_byte *start;
2537 bfd_vma cxx_class;
2538 const char *tag;
2539 unsigned long taglen;
2540 struct ieee_tag *it;
2541 void *dhandle;
2542 debug_field *fields;
2543 unsigned int field_count, field_alloc;
2544 debug_baseclass *baseclasses;
2545 unsigned int baseclasses_count, baseclasses_alloc;
2546 const debug_field *structfields;
2547 struct ieee_method
2549 const char *name;
2550 unsigned long namlen;
2551 debug_method_variant *variants;
2552 unsigned count;
2553 unsigned int alloc;
2554 } *methods;
2555 unsigned int methods_count, methods_alloc;
2556 debug_type vptrbase;
2557 bfd_boolean ownvptr;
2558 debug_method *dmethods;
2560 start = *pp;
2562 if (! ieee_require_asn (info, pp, &cxx_class))
2563 return FALSE;
2564 --count;
2566 if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2567 return FALSE;
2568 --count;
2570 /* Find the C struct with this name. */
2571 for (it = info->tags; it != NULL; it = it->next)
2572 if (it->name[0] == tag[0]
2573 && strncmp (it->name, tag, taglen) == 0
2574 && strlen (it->name) == taglen)
2575 break;
2576 if (it == NULL)
2578 ieee_error (info, start, _("undefined C++ object"));
2579 return FALSE;
2582 dhandle = info->dhandle;
2584 fields = NULL;
2585 field_count = 0;
2586 field_alloc = 0;
2587 baseclasses = NULL;
2588 baseclasses_count = 0;
2589 baseclasses_alloc = 0;
2590 methods = NULL;
2591 methods_count = 0;
2592 methods_alloc = 0;
2593 vptrbase = DEBUG_TYPE_NULL;
2594 ownvptr = FALSE;
2596 structfields = debug_get_fields (dhandle, it->type);
2598 while (count > 0)
2600 bfd_vma id;
2601 const bfd_byte *spec_start;
2603 spec_start = *pp;
2605 if (! ieee_require_asn (info, pp, &id))
2606 return FALSE;
2607 --count;
2609 switch (id)
2611 default:
2612 ieee_error (info, spec_start, _("unrecognized C++ object spec"));
2613 return FALSE;
2615 case 'b':
2617 bfd_vma flags, cinline;
2618 const char *base, *fieldname;
2619 unsigned long baselen, fieldlen;
2620 char *basecopy;
2621 debug_type basetype;
2622 bfd_vma bitpos;
2623 bfd_boolean virtualp;
2624 enum debug_visibility visibility;
2625 debug_baseclass baseclass;
2627 /* This represents a base or friend class. */
2629 if (! ieee_require_asn (info, pp, &flags)
2630 || ! ieee_require_atn65 (info, pp, &base, &baselen)
2631 || ! ieee_require_asn (info, pp, &cinline)
2632 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2633 return FALSE;
2634 count -= 4;
2636 /* We have no way of recording friend information, so we
2637 just ignore it. */
2638 if ((flags & BASEFLAGS_FRIEND) != 0)
2639 break;
2641 /* I assume that either all of the members of the
2642 baseclass are included in the object, starting at the
2643 beginning of the object, or that none of them are
2644 included. */
2646 if ((fieldlen == 0) == (cinline == 0))
2648 ieee_error (info, start, _("unsupported C++ object type"));
2649 return FALSE;
2652 basecopy = savestring (base, baselen);
2653 basetype = debug_find_tagged_type (dhandle, basecopy,
2654 DEBUG_KIND_ILLEGAL);
2655 free (basecopy);
2656 if (basetype == DEBUG_TYPE_NULL)
2658 ieee_error (info, start, _("C++ base class not defined"));
2659 return FALSE;
2662 if (fieldlen == 0)
2663 bitpos = 0;
2664 else
2666 const debug_field *pf;
2668 if (structfields == NULL)
2670 ieee_error (info, start, _("C++ object has no fields"));
2671 return FALSE;
2674 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2676 const char *fname;
2678 fname = debug_get_field_name (dhandle, *pf);
2679 if (fname == NULL)
2680 return FALSE;
2681 if (fname[0] == fieldname[0]
2682 && strncmp (fname, fieldname, fieldlen) == 0
2683 && strlen (fname) == fieldlen)
2684 break;
2686 if (*pf == DEBUG_FIELD_NULL)
2688 ieee_error (info, start,
2689 _("C++ base class not found in container"));
2690 return FALSE;
2693 bitpos = debug_get_field_bitpos (dhandle, *pf);
2696 if ((flags & BASEFLAGS_VIRTUAL) != 0)
2697 virtualp = TRUE;
2698 else
2699 virtualp = FALSE;
2700 if ((flags & BASEFLAGS_PRIVATE) != 0)
2701 visibility = DEBUG_VISIBILITY_PRIVATE;
2702 else
2703 visibility = DEBUG_VISIBILITY_PUBLIC;
2705 baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2706 virtualp, visibility);
2707 if (baseclass == DEBUG_BASECLASS_NULL)
2708 return FALSE;
2710 if (baseclasses_count + 1 >= baseclasses_alloc)
2712 baseclasses_alloc += 10;
2713 baseclasses = ((debug_baseclass *)
2714 xrealloc (baseclasses,
2715 (baseclasses_alloc
2716 * sizeof *baseclasses)));
2719 baseclasses[baseclasses_count] = baseclass;
2720 ++baseclasses_count;
2721 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2723 break;
2725 case 'd':
2727 bfd_vma flags;
2728 const char *fieldname, *mangledname;
2729 unsigned long fieldlen, mangledlen;
2730 char *fieldcopy;
2731 bfd_boolean staticp;
2732 debug_type ftype;
2733 const debug_field *pf = NULL;
2734 enum debug_visibility visibility;
2735 debug_field field;
2737 /* This represents a data member. */
2739 if (! ieee_require_asn (info, pp, &flags)
2740 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2741 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2742 return FALSE;
2743 count -= 3;
2745 fieldcopy = savestring (fieldname, fieldlen);
2747 staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;
2749 if (staticp)
2751 struct ieee_var *pv, *pvend;
2753 /* See if we can find a definition for this variable. */
2754 pv = info->vars.vars;
2755 pvend = pv + info->vars.alloc;
2756 for (; pv < pvend; pv++)
2757 if (pv->namlen == mangledlen
2758 && strncmp (pv->name, mangledname, mangledlen) == 0)
2759 break;
2760 if (pv < pvend)
2761 ftype = pv->type;
2762 else
2764 /* This can happen if the variable is never used. */
2765 ftype = ieee_builtin_type (info, start,
2766 (unsigned int) builtin_void);
2769 else
2771 unsigned int findx;
2773 if (structfields == NULL)
2775 ieee_error (info, start, _("C++ object has no fields"));
2776 return FALSE;
2779 for (pf = structfields, findx = 0;
2780 *pf != DEBUG_FIELD_NULL;
2781 pf++, findx++)
2783 const char *fname;
2785 fname = debug_get_field_name (dhandle, *pf);
2786 if (fname == NULL)
2787 return FALSE;
2788 if (fname[0] == mangledname[0]
2789 && strncmp (fname, mangledname, mangledlen) == 0
2790 && strlen (fname) == mangledlen)
2791 break;
2793 if (*pf == DEBUG_FIELD_NULL)
2795 ieee_error (info, start,
2796 _("C++ data member not found in container"));
2797 return FALSE;
2800 ftype = debug_get_field_type (dhandle, *pf);
2802 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2804 /* We might need to convert this field into a
2805 reference type later on, so make it an indirect
2806 type. */
2807 if (it->fslots == NULL)
2809 unsigned int fcnt;
2810 const debug_field *pfcnt;
2812 fcnt = 0;
2813 for (pfcnt = structfields;
2814 *pfcnt != DEBUG_FIELD_NULL;
2815 pfcnt++)
2816 ++fcnt;
2817 it->fslots = ((debug_type *)
2818 xmalloc (fcnt * sizeof *it->fslots));
2819 memset (it->fslots, 0,
2820 fcnt * sizeof *it->fslots);
2823 if (ftype == DEBUG_TYPE_NULL)
2824 return FALSE;
2825 it->fslots[findx] = ftype;
2826 ftype = debug_make_indirect_type (dhandle,
2827 it->fslots + findx,
2828 (const char *) NULL);
2831 if (ftype == DEBUG_TYPE_NULL)
2832 return FALSE;
2834 switch (flags & CXXFLAGS_VISIBILITY)
2836 default:
2837 ieee_error (info, start, _("unknown C++ visibility"));
2838 return FALSE;
2840 case CXXFLAGS_VISIBILITY_PUBLIC:
2841 visibility = DEBUG_VISIBILITY_PUBLIC;
2842 break;
2844 case CXXFLAGS_VISIBILITY_PRIVATE:
2845 visibility = DEBUG_VISIBILITY_PRIVATE;
2846 break;
2848 case CXXFLAGS_VISIBILITY_PROTECTED:
2849 visibility = DEBUG_VISIBILITY_PROTECTED;
2850 break;
2853 if (staticp)
2855 char *mangledcopy;
2857 mangledcopy = savestring (mangledname, mangledlen);
2859 field = debug_make_static_member (dhandle, fieldcopy,
2860 ftype, mangledcopy,
2861 visibility);
2863 else
2865 bfd_vma bitpos, bitsize;
2867 bitpos = debug_get_field_bitpos (dhandle, *pf);
2868 bitsize = debug_get_field_bitsize (dhandle, *pf);
2869 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2871 ieee_error (info, start, _("bad C++ field bit pos or size"));
2872 return FALSE;
2874 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2875 bitsize, visibility);
2878 if (field == DEBUG_FIELD_NULL)
2879 return FALSE;
2881 if (field_count + 1 >= field_alloc)
2883 field_alloc += 10;
2884 fields = ((debug_field *)
2885 xrealloc (fields, field_alloc * sizeof *fields));
2888 fields[field_count] = field;
2889 ++field_count;
2890 fields[field_count] = DEBUG_FIELD_NULL;
2892 break;
2894 case 'm':
2895 case 'v':
2897 bfd_vma flags, voffset, control;
2898 const char *name, *mangled;
2899 unsigned long namlen, mangledlen;
2900 struct ieee_var *pv, *pvend;
2901 debug_type type;
2902 enum debug_visibility visibility;
2903 bfd_boolean constp, volatilep;
2904 char *mangledcopy;
2905 debug_method_variant mv;
2906 struct ieee_method *meth;
2907 unsigned int im;
2909 if (! ieee_require_asn (info, pp, &flags)
2910 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2911 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2912 return FALSE;
2913 count -= 3;
2914 if (id != 'v')
2915 voffset = 0;
2916 else
2918 if (! ieee_require_asn (info, pp, &voffset))
2919 return FALSE;
2920 --count;
2922 if (! ieee_require_asn (info, pp, &control))
2923 return FALSE;
2924 --count;
2926 /* We just ignore the control information. */
2928 /* We have no way to represent friend information, so we
2929 just ignore it. */
2930 if ((flags & CXXFLAGS_FRIEND) != 0)
2931 break;
2933 /* We should already have seen a type for the function. */
2934 pv = info->vars.vars;
2935 pvend = pv + info->vars.alloc;
2936 for (; pv < pvend; pv++)
2937 if (pv->namlen == mangledlen
2938 && strncmp (pv->name, mangled, mangledlen) == 0)
2939 break;
2941 if (pv >= pvend)
2943 /* We won't have type information for this function if
2944 it is not included in this file. We don't try to
2945 handle this case. FIXME. */
2946 type = (debug_make_function_type
2947 (dhandle,
2948 ieee_builtin_type (info, start,
2949 (unsigned int) builtin_void),
2950 (debug_type *) NULL,
2951 FALSE));
2953 else
2955 debug_type return_type;
2956 const debug_type *arg_types;
2957 bfd_boolean varargs = FALSE;
2959 if (debug_get_type_kind (dhandle, pv->type)
2960 != DEBUG_KIND_FUNCTION)
2962 ieee_error (info, start,
2963 _("bad type for C++ method function"));
2964 return FALSE;
2967 return_type = debug_get_return_type (dhandle, pv->type);
2968 arg_types = debug_get_parameter_types (dhandle, pv->type,
2969 &varargs);
2970 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
2972 ieee_error (info, start,
2973 _("no type information for C++ method function"));
2974 return FALSE;
2977 type = debug_make_method_type (dhandle, return_type, it->type,
2978 (debug_type *) arg_types,
2979 varargs);
2981 if (type == DEBUG_TYPE_NULL)
2982 return FALSE;
2984 switch (flags & CXXFLAGS_VISIBILITY)
2986 default:
2987 ieee_error (info, start, _("unknown C++ visibility"));
2988 return FALSE;
2990 case CXXFLAGS_VISIBILITY_PUBLIC:
2991 visibility = DEBUG_VISIBILITY_PUBLIC;
2992 break;
2994 case CXXFLAGS_VISIBILITY_PRIVATE:
2995 visibility = DEBUG_VISIBILITY_PRIVATE;
2996 break;
2998 case CXXFLAGS_VISIBILITY_PROTECTED:
2999 visibility = DEBUG_VISIBILITY_PROTECTED;
3000 break;
3003 constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
3004 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;
3006 mangledcopy = savestring (mangled, mangledlen);
3008 if ((flags & CXXFLAGS_STATIC) != 0)
3010 if (id == 'v')
3012 ieee_error (info, start, _("C++ static virtual method"));
3013 return FALSE;
3015 mv = debug_make_static_method_variant (dhandle, mangledcopy,
3016 type, visibility,
3017 constp, volatilep);
3019 else
3021 debug_type vcontext;
3023 if (id != 'v')
3024 vcontext = DEBUG_TYPE_NULL;
3025 else
3027 /* FIXME: How can we calculate this correctly? */
3028 vcontext = it->type;
3030 mv = debug_make_method_variant (dhandle, mangledcopy, type,
3031 visibility, constp,
3032 volatilep, voffset,
3033 vcontext);
3035 if (mv == DEBUG_METHOD_VARIANT_NULL)
3036 return FALSE;
3038 for (meth = methods, im = 0; im < methods_count; meth++, im++)
3039 if (meth->namlen == namlen
3040 && strncmp (meth->name, name, namlen) == 0)
3041 break;
3042 if (im >= methods_count)
3044 if (methods_count >= methods_alloc)
3046 methods_alloc += 10;
3047 methods = ((struct ieee_method *)
3048 xrealloc (methods,
3049 methods_alloc * sizeof *methods));
3051 methods[methods_count].name = name;
3052 methods[methods_count].namlen = namlen;
3053 methods[methods_count].variants = NULL;
3054 methods[methods_count].count = 0;
3055 methods[methods_count].alloc = 0;
3056 meth = methods + methods_count;
3057 ++methods_count;
3060 if (meth->count + 1 >= meth->alloc)
3062 meth->alloc += 10;
3063 meth->variants = ((debug_method_variant *)
3064 xrealloc (meth->variants,
3065 (meth->alloc
3066 * sizeof *meth->variants)));
3069 meth->variants[meth->count] = mv;
3070 ++meth->count;
3071 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
3073 break;
3075 case 'o':
3077 bfd_vma spec;
3079 /* We have no way to store this information, so we just
3080 ignore it. */
3081 if (! ieee_require_asn (info, pp, &spec))
3082 return FALSE;
3083 --count;
3084 if ((spec & 4) != 0)
3086 const char *filename;
3087 unsigned long filenamlen;
3088 bfd_vma lineno;
3090 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
3091 || ! ieee_require_asn (info, pp, &lineno))
3092 return FALSE;
3093 count -= 2;
3095 else if ((spec & 8) != 0)
3097 const char *mangled;
3098 unsigned long mangledlen;
3100 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
3101 return FALSE;
3102 --count;
3104 else
3106 ieee_error (info, start,
3107 _("unrecognized C++ object overhead spec"));
3108 return FALSE;
3111 break;
3113 case 'z':
3115 const char *vname, *base;
3116 unsigned long vnamelen, baselen;
3117 bfd_vma vsize, control;
3119 /* A virtual table pointer. */
3121 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3122 || ! ieee_require_asn (info, pp, &vsize)
3123 || ! ieee_require_atn65 (info, pp, &base, &baselen)
3124 || ! ieee_require_asn (info, pp, &control))
3125 return FALSE;
3126 count -= 4;
3128 /* We just ignore the control number. We don't care what
3129 the virtual table name is. We have no way to store the
3130 virtual table size, and I don't think we care anyhow. */
3132 /* FIXME: We can't handle multiple virtual table pointers. */
3134 if (baselen == 0)
3135 ownvptr = TRUE;
3136 else
3138 char *basecopy;
3140 basecopy = savestring (base, baselen);
3141 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3142 DEBUG_KIND_ILLEGAL);
3143 free (basecopy);
3144 if (vptrbase == DEBUG_TYPE_NULL)
3146 ieee_error (info, start, _("undefined C++ vtable"));
3147 return FALSE;
3151 break;
3155 /* Now that we have seen all the method variants, we can call
3156 debug_make_method for each one. */
3158 if (methods_count == 0)
3159 dmethods = NULL;
3160 else
3162 unsigned int i;
3164 dmethods = ((debug_method *)
3165 xmalloc ((methods_count + 1) * sizeof *dmethods));
3166 for (i = 0; i < methods_count; i++)
3168 char *namcopy;
3170 namcopy = savestring (methods[i].name, methods[i].namlen);
3171 dmethods[i] = debug_make_method (dhandle, namcopy,
3172 methods[i].variants);
3173 if (dmethods[i] == DEBUG_METHOD_NULL)
3174 return FALSE;
3176 dmethods[i] = DEBUG_METHOD_NULL;
3177 free (methods);
3180 /* The struct type was created as an indirect type pointing at
3181 it->slot. We update it->slot to automatically update all
3182 references to this struct. */
3183 it->slot = debug_make_object_type (dhandle,
3184 cxx_class != 'u',
3185 debug_get_type_size (dhandle,
3186 it->slot),
3187 fields, baseclasses, dmethods,
3188 vptrbase, ownvptr);
3189 if (it->slot == DEBUG_TYPE_NULL)
3190 return FALSE;
3192 return TRUE;
3195 /* Read C++ default argument value and reference type information. */
3197 static bfd_boolean
3198 ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp,
3199 unsigned long count)
3201 const bfd_byte *start;
3202 const char *fnname;
3203 unsigned long fnlen;
3204 bfd_vma defcount;
3206 start = *pp;
3208 /* Giving the function name before the argument count is an addendum
3209 to the spec. The function name is demangled, though, so this
3210 record must always refer to the current function. */
3212 if (info->blockstack.bsp <= info->blockstack.stack
3213 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3215 ieee_error (info, start, _("C++ default values not in a function"));
3216 return FALSE;
3219 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3220 || ! ieee_require_asn (info, pp, &defcount))
3221 return FALSE;
3222 count -= 2;
3224 while (defcount-- > 0)
3226 bfd_vma type, val;
3227 const char *strval;
3228 unsigned long strvallen;
3230 if (! ieee_require_asn (info, pp, &type))
3231 return FALSE;
3232 --count;
3234 switch (type)
3236 case 0:
3237 case 4:
3238 break;
3240 case 1:
3241 case 2:
3242 if (! ieee_require_asn (info, pp, &val))
3243 return FALSE;
3244 --count;
3245 break;
3247 case 3:
3248 case 7:
3249 if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3250 return FALSE;
3251 --count;
3252 break;
3254 default:
3255 ieee_error (info, start, _("unrecognized C++ default type"));
3256 return FALSE;
3259 /* We have no way to record the default argument values, so we
3260 just ignore them. FIXME. */
3263 /* Any remaining arguments are indices of parameters that are really
3264 reference type. */
3265 if (count > 0)
3267 void *dhandle;
3268 debug_type *arg_slots;
3270 dhandle = info->dhandle;
3271 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3272 while (count-- > 0)
3274 bfd_vma indx;
3275 debug_type target;
3277 if (! ieee_require_asn (info, pp, &indx))
3278 return FALSE;
3279 /* The index is 1 based. */
3280 --indx;
3281 if (arg_slots == NULL
3282 || arg_slots[indx] == DEBUG_TYPE_NULL
3283 || (debug_get_type_kind (dhandle, arg_slots[indx])
3284 != DEBUG_KIND_POINTER))
3286 ieee_error (info, start, _("reference parameter is not a pointer"));
3287 return FALSE;
3290 target = debug_get_target_type (dhandle, arg_slots[indx]);
3291 arg_slots[indx] = debug_make_reference_type (dhandle, target);
3292 if (arg_slots[indx] == DEBUG_TYPE_NULL)
3293 return FALSE;
3297 return TRUE;
3300 /* Read a C++ reference definition. */
3302 static bfd_boolean
3303 ieee_read_reference (struct ieee_info *info, const bfd_byte **pp)
3305 const bfd_byte *start;
3306 bfd_vma flags;
3307 const char *cxx_class, *name;
3308 unsigned long classlen, namlen;
3309 debug_type *pslot;
3310 debug_type target;
3312 start = *pp;
3314 if (! ieee_require_asn (info, pp, &flags))
3315 return FALSE;
3317 /* Giving the class name before the member name is in an addendum to
3318 the spec. */
3319 if (flags == 3)
3321 if (! ieee_require_atn65 (info, pp, &cxx_class, &classlen))
3322 return FALSE;
3325 if (! ieee_require_atn65 (info, pp, &name, &namlen))
3326 return FALSE;
3328 pslot = NULL;
3329 if (flags != 3)
3331 int pass;
3333 /* We search from the last variable indices to the first in
3334 hopes of finding local variables correctly. We search the
3335 local variables on the first pass, and the global variables
3336 on the second. FIXME: This probably won't work in all cases.
3337 On the other hand, I don't know what will. */
3338 for (pass = 0; pass < 2; pass++)
3340 struct ieee_vars *vars;
3341 int i;
3342 struct ieee_var *pv = NULL;
3344 if (pass == 0)
3345 vars = &info->vars;
3346 else
3348 vars = info->global_vars;
3349 if (vars == NULL)
3350 break;
3353 for (i = (int) vars->alloc - 1; i >= 0; i--)
3355 bfd_boolean found;
3357 pv = vars->vars + i;
3359 if (pv->pslot == NULL
3360 || pv->namlen != namlen
3361 || strncmp (pv->name, name, namlen) != 0)
3362 continue;
3364 found = FALSE;
3365 switch (flags)
3367 default:
3368 ieee_error (info, start,
3369 _("unrecognized C++ reference type"));
3370 return FALSE;
3372 case 0:
3373 /* Global variable or function. */
3374 if (pv->kind == IEEE_GLOBAL
3375 || pv->kind == IEEE_EXTERNAL
3376 || pv->kind == IEEE_FUNCTION)
3377 found = TRUE;
3378 break;
3380 case 1:
3381 /* Global static variable or function. */
3382 if (pv->kind == IEEE_STATIC
3383 || pv->kind == IEEE_FUNCTION)
3384 found = TRUE;
3385 break;
3387 case 2:
3388 /* Local variable. */
3389 if (pv->kind == IEEE_LOCAL)
3390 found = TRUE;
3391 break;
3394 if (found)
3395 break;
3398 if (i >= 0)
3400 pslot = pv->pslot;
3401 break;
3405 else
3407 struct ieee_tag *it;
3409 for (it = info->tags; it != NULL; it = it->next)
3411 if (it->name[0] == cxx_class[0]
3412 && strncmp (it->name, cxx_class, classlen) == 0
3413 && strlen (it->name) == classlen)
3415 if (it->fslots != NULL)
3417 const debug_field *pf;
3418 unsigned int findx;
3420 pf = debug_get_fields (info->dhandle, it->type);
3421 if (pf == NULL)
3423 ieee_error (info, start,
3424 "C++ reference in class with no fields");
3425 return FALSE;
3428 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3430 const char *fname;
3432 fname = debug_get_field_name (info->dhandle, *pf);
3433 if (fname == NULL)
3434 return FALSE;
3435 if (strncmp (fname, name, namlen) == 0
3436 && strlen (fname) == namlen)
3438 pslot = it->fslots + findx;
3439 break;
3444 break;
3449 if (pslot == NULL)
3451 ieee_error (info, start, _("C++ reference not found"));
3452 return FALSE;
3455 /* We allocated the type of the object as an indirect type pointing
3456 to *pslot, which we can now update to be a reference type. */
3457 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3459 ieee_error (info, start, _("C++ reference is not pointer"));
3460 return FALSE;
3463 target = debug_get_target_type (info->dhandle, *pslot);
3464 *pslot = debug_make_reference_type (info->dhandle, target);
3465 if (*pslot == DEBUG_TYPE_NULL)
3466 return FALSE;
3468 return TRUE;
3471 /* Require an ASN record. */
3473 static bfd_boolean
3474 ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
3476 const bfd_byte *start;
3477 ieee_record_enum_type c;
3478 bfd_vma varindx;
3480 start = *pp;
3482 c = (ieee_record_enum_type) **pp;
3483 if (c != ieee_e2_first_byte_enum)
3485 ieee_error (info, start, _("missing required ASN"));
3486 return FALSE;
3488 ++*pp;
3490 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3491 if (c != ieee_asn_record_enum)
3493 ieee_error (info, start, _("missing required ASN"));
3494 return FALSE;
3496 ++*pp;
3498 /* Just ignore the variable index. */
3499 if (! ieee_read_number (info, pp, &varindx))
3500 return FALSE;
3502 return ieee_read_expression (info, pp, pv);
3505 /* Require an ATN65 record. */
3507 static bfd_boolean
3508 ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp,
3509 const char **pname, unsigned long *pnamlen)
3511 const bfd_byte *start;
3512 ieee_record_enum_type c;
3513 bfd_vma name_indx, type_indx, atn_code;
3515 start = *pp;
3517 c = (ieee_record_enum_type) **pp;
3518 if (c != ieee_at_record_enum)
3520 ieee_error (info, start, _("missing required ATN65"));
3521 return FALSE;
3523 ++*pp;
3525 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3526 if (c != ieee_atn_record_enum)
3528 ieee_error (info, start, _("missing required ATN65"));
3529 return FALSE;
3531 ++*pp;
3533 if (! ieee_read_number (info, pp, &name_indx)
3534 || ! ieee_read_number (info, pp, &type_indx)
3535 || ! ieee_read_number (info, pp, &atn_code))
3536 return FALSE;
3538 /* Just ignore name_indx. */
3540 if (type_indx != 0 || atn_code != 65)
3542 ieee_error (info, start, _("bad ATN65 record"));
3543 return FALSE;
3546 return ieee_read_id (info, pp, pname, pnamlen);
3549 /* Convert a register number in IEEE debugging information into a
3550 generic register number. */
3552 static int
3553 ieee_regno_to_genreg (bfd *abfd, int r)
3555 switch (bfd_get_arch (abfd))
3557 case bfd_arch_m68k:
3558 /* For some reasons stabs adds 2 to the floating point register
3559 numbers. */
3560 if (r >= 16)
3561 r += 2;
3562 break;
3564 case bfd_arch_i960:
3565 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3566 32 to 35 for fp0 to fp3. */
3567 --r;
3568 break;
3570 default:
3571 break;
3574 return r;
3577 /* Convert a generic register number to an IEEE specific one. */
3579 static int
3580 ieee_genreg_to_regno (bfd *abfd, int r)
3582 switch (bfd_get_arch (abfd))
3584 case bfd_arch_m68k:
3585 /* For some reason stabs add 2 to the floating point register
3586 numbers. */
3587 if (r >= 18)
3588 r -= 2;
3589 break;
3591 case bfd_arch_i960:
3592 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3593 32 to 35 for fp0 to fp3. */
3594 ++r;
3595 break;
3597 default:
3598 break;
3601 return r;
3604 /* These routines build IEEE debugging information out of the generic
3605 debugging information. */
3607 /* We build the IEEE debugging information byte by byte. Rather than
3608 waste time copying data around, we use a linked list of buffers to
3609 hold the data. */
3611 #define IEEE_BUFSIZE (490)
3613 struct ieee_buf
3615 /* Next buffer. */
3616 struct ieee_buf *next;
3617 /* Number of data bytes in this buffer. */
3618 unsigned int c;
3619 /* Bytes. */
3620 bfd_byte buf[IEEE_BUFSIZE];
3623 /* A list of buffers. */
3625 struct ieee_buflist
3627 /* Head of list. */
3628 struct ieee_buf *head;
3629 /* Tail--last buffer on list. */
3630 struct ieee_buf *tail;
3633 /* In order to generate the BB11 blocks required by the HP emulator,
3634 we keep track of ranges of addresses which correspond to a given
3635 compilation unit. */
3637 struct ieee_range
3639 /* Next range. */
3640 struct ieee_range *next;
3641 /* Low address. */
3642 bfd_vma low;
3643 /* High address. */
3644 bfd_vma high;
3647 /* This structure holds information for a class on the type stack. */
3649 struct ieee_type_class
3651 /* The name index in the debugging information. */
3652 unsigned int indx;
3653 /* The pmisc records for the class. */
3654 struct ieee_buflist pmiscbuf;
3655 /* The number of pmisc records. */
3656 unsigned int pmisccount;
3657 /* The name of the class holding the virtual table, if not this
3658 class. */
3659 const char *vclass;
3660 /* Whether this class holds its own virtual table. */
3661 bfd_boolean ownvptr;
3662 /* The largest virtual table offset seen so far. */
3663 bfd_vma voffset;
3664 /* The current method. */
3665 const char *method;
3666 /* Additional pmisc records used to record fields of reference type. */
3667 struct ieee_buflist refs;
3670 /* This is how we store types for the writing routines. Most types
3671 are simply represented by a type index. */
3673 struct ieee_write_type
3675 /* Type index. */
3676 unsigned int indx;
3677 /* The size of the type, if known. */
3678 unsigned int size;
3679 /* The name of the type, if any. */
3680 const char *name;
3681 /* If this is a function or method type, we build the type here, and
3682 only add it to the output buffers if we need it. */
3683 struct ieee_buflist fndef;
3684 /* If this is a struct, this is where the struct definition is
3685 built. */
3686 struct ieee_buflist strdef;
3687 /* If this is a class, this is where the class information is built. */
3688 struct ieee_type_class *classdef;
3689 /* Whether the type is unsigned. */
3690 unsigned int unsignedp : 1;
3691 /* Whether this is a reference type. */
3692 unsigned int referencep : 1;
3693 /* Whether this is in the local type block. */
3694 unsigned int localp : 1;
3695 /* Whether this is a duplicate struct definition which we are
3696 ignoring. */
3697 unsigned int ignorep : 1;
3700 /* This is the type stack used by the debug writing routines. FIXME:
3701 We could generate more efficient output if we remembered when we
3702 have output a particular type before. */
3704 struct ieee_type_stack
3706 /* Next entry on stack. */
3707 struct ieee_type_stack *next;
3708 /* Type information. */
3709 struct ieee_write_type type;
3712 /* This is a list of associations between a name and some types.
3713 These are used for typedefs and tags. */
3715 struct ieee_name_type
3717 /* Next type for this name. */
3718 struct ieee_name_type *next;
3719 /* ID number. For a typedef, this is the index of the type to which
3720 this name is typedefed. */
3721 unsigned int id;
3722 /* Type. */
3723 struct ieee_write_type type;
3724 /* If this is a tag which has not yet been defined, this is the
3725 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3726 enum debug_type_kind kind;
3729 /* We use a hash table to associate names and types. */
3731 struct ieee_name_type_hash_table
3733 struct bfd_hash_table root;
3736 struct ieee_name_type_hash_entry
3738 struct bfd_hash_entry root;
3739 /* Information for this name. */
3740 struct ieee_name_type *types;
3743 /* This is a list of enums. */
3745 struct ieee_defined_enum
3747 /* Next enum. */
3748 struct ieee_defined_enum *next;
3749 /* Type index. */
3750 unsigned int indx;
3751 /* Whether this enum has been defined. */
3752 bfd_boolean defined;
3753 /* Tag. */
3754 const char *tag;
3755 /* Names. */
3756 const char **names;
3757 /* Values. */
3758 bfd_signed_vma *vals;
3761 /* We keep a list of modified versions of types, so that we don't
3762 output them more than once. */
3764 struct ieee_modified_type
3766 /* Pointer to this type. */
3767 unsigned int pointer;
3768 /* Function with unknown arguments returning this type. */
3769 unsigned int function;
3770 /* Const version of this type. */
3771 unsigned int const_qualified;
3772 /* Volatile version of this type. */
3773 unsigned int volatile_qualified;
3774 /* List of arrays of this type of various bounds. */
3775 struct ieee_modified_array_type *arrays;
3778 /* A list of arrays bounds. */
3780 struct ieee_modified_array_type
3782 /* Next array bounds. */
3783 struct ieee_modified_array_type *next;
3784 /* Type index with these bounds. */
3785 unsigned int indx;
3786 /* Low bound. */
3787 bfd_signed_vma low;
3788 /* High bound. */
3789 bfd_signed_vma high;
3792 /* This is a list of pending function parameter information. We don't
3793 output them until we see the first block. */
3795 struct ieee_pending_parm
3797 /* Next pending parameter. */
3798 struct ieee_pending_parm *next;
3799 /* Name. */
3800 const char *name;
3801 /* Type index. */
3802 unsigned int type;
3803 /* Whether the type is a reference. */
3804 bfd_boolean referencep;
3805 /* Kind. */
3806 enum debug_parm_kind kind;
3807 /* Value. */
3808 bfd_vma val;
3811 /* This is the handle passed down by debug_write. */
3813 struct ieee_handle
3815 /* BFD we are writing to. */
3816 bfd *abfd;
3817 /* Whether we got an error in a subroutine called via traverse or
3818 map_over_sections. */
3819 bfd_boolean error;
3820 /* Current data buffer list. */
3821 struct ieee_buflist *current;
3822 /* Current data buffer. */
3823 struct ieee_buf *curbuf;
3824 /* Filename of current compilation unit. */
3825 const char *filename;
3826 /* Module name of current compilation unit. */
3827 const char *modname;
3828 /* List of buffer for global types. */
3829 struct ieee_buflist global_types;
3830 /* List of finished data buffers. */
3831 struct ieee_buflist data;
3832 /* List of buffers for typedefs in the current compilation unit. */
3833 struct ieee_buflist types;
3834 /* List of buffers for variables and functions in the current
3835 compilation unit. */
3836 struct ieee_buflist vars;
3837 /* List of buffers for C++ class definitions in the current
3838 compilation unit. */
3839 struct ieee_buflist cxx;
3840 /* List of buffers for line numbers in the current compilation unit. */
3841 struct ieee_buflist linenos;
3842 /* Ranges for the current compilation unit. */
3843 struct ieee_range *ranges;
3844 /* Ranges for all debugging information. */
3845 struct ieee_range *global_ranges;
3846 /* Nested pending ranges. */
3847 struct ieee_range *pending_ranges;
3848 /* Type stack. */
3849 struct ieee_type_stack *type_stack;
3850 /* Next unallocated type index. */
3851 unsigned int type_indx;
3852 /* Next unallocated name index. */
3853 unsigned int name_indx;
3854 /* Typedefs. */
3855 struct ieee_name_type_hash_table typedefs;
3856 /* Tags. */
3857 struct ieee_name_type_hash_table tags;
3858 /* Enums. */
3859 struct ieee_defined_enum *enums;
3860 /* Modified versions of types. */
3861 struct ieee_modified_type *modified;
3862 /* Number of entries allocated in modified. */
3863 unsigned int modified_alloc;
3864 /* 4 byte complex type. */
3865 unsigned int complex_float_index;
3866 /* 8 byte complex type. */
3867 unsigned int complex_double_index;
3868 /* The depth of block nesting. This is 0 outside a function, and 1
3869 just after start_function is called. */
3870 unsigned int block_depth;
3871 /* The name of the current function. */
3872 const char *fnname;
3873 /* List of buffers for the type of the function we are currently
3874 writing out. */
3875 struct ieee_buflist fntype;
3876 /* List of buffers for the parameters of the function we are
3877 currently writing out. */
3878 struct ieee_buflist fnargs;
3879 /* Number of arguments written to fnargs. */
3880 unsigned int fnargcount;
3881 /* Pending function parameters. */
3882 struct ieee_pending_parm *pending_parms;
3883 /* Current line number filename. */
3884 const char *lineno_filename;
3885 /* Line number name index. */
3886 unsigned int lineno_name_indx;
3887 /* Filename of pending line number. */
3888 const char *pending_lineno_filename;
3889 /* Pending line number. */
3890 unsigned long pending_lineno;
3891 /* Address of pending line number. */
3892 bfd_vma pending_lineno_addr;
3893 /* Highest address seen at end of procedure. */
3894 bfd_vma highaddr;
3897 static bfd_boolean ieee_init_buffer
3898 (struct ieee_handle *, struct ieee_buflist *);
3899 static bfd_boolean ieee_change_buffer
3900 (struct ieee_handle *, struct ieee_buflist *);
3901 static bfd_boolean ieee_append_buffer
3902 (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *);
3903 static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int);
3904 static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int);
3905 static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma);
3906 static bfd_boolean ieee_write_id (struct ieee_handle *, const char *);
3907 static bfd_boolean ieee_write_asn
3908 (struct ieee_handle *, unsigned int, bfd_vma);
3909 static bfd_boolean ieee_write_atn65
3910 (struct ieee_handle *, unsigned int, const char *);
3911 static bfd_boolean ieee_push_type
3912 (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean,
3913 bfd_boolean);
3914 static unsigned int ieee_pop_type (struct ieee_handle *);
3915 static void ieee_pop_unused_type (struct ieee_handle *);
3916 static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean);
3917 static bfd_boolean ieee_add_range
3918 (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma);
3919 static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma);
3920 static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma);
3921 static bfd_boolean ieee_define_type
3922 (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean);
3923 static bfd_boolean ieee_define_named_type
3924 (struct ieee_handle *, const char *, unsigned int, unsigned int,
3925 bfd_boolean, bfd_boolean, struct ieee_buflist *);
3926 static struct ieee_modified_type *ieee_get_modified_info
3927 (struct ieee_handle *, unsigned int);
3928 static struct bfd_hash_entry *ieee_name_type_newfunc
3929 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
3930 static bfd_boolean ieee_write_undefined_tag
3931 (struct ieee_name_type_hash_entry *, void *);
3932 static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *);
3933 static void ieee_add_bb11_blocks (bfd *, asection *, void *);
3934 static bfd_boolean ieee_add_bb11
3935 (struct ieee_handle *, asection *, bfd_vma, bfd_vma);
3936 static bfd_boolean ieee_output_pending_parms (struct ieee_handle *);
3937 static unsigned int ieee_vis_to_flags (enum debug_visibility);
3938 static bfd_boolean ieee_class_method_var
3939 (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean,
3940 bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
3942 static bfd_boolean ieee_start_compilation_unit (void *, const char *);
3943 static bfd_boolean ieee_start_source (void *, const char *);
3944 static bfd_boolean ieee_empty_type (void *);
3945 static bfd_boolean ieee_void_type (void *);
3946 static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean);
3947 static bfd_boolean ieee_float_type (void *, unsigned int);
3948 static bfd_boolean ieee_complex_type (void *, unsigned int);
3949 static bfd_boolean ieee_bool_type (void *, unsigned int);
3950 static bfd_boolean ieee_enum_type
3951 (void *, const char *, const char **, bfd_signed_vma *);
3952 static bfd_boolean ieee_pointer_type (void *);
3953 static bfd_boolean ieee_function_type (void *, int, bfd_boolean);
3954 static bfd_boolean ieee_reference_type (void *);
3955 static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma);
3956 static bfd_boolean ieee_array_type
3957 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
3958 static bfd_boolean ieee_set_type (void *, bfd_boolean);
3959 static bfd_boolean ieee_offset_type (void *);
3960 static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean);
3961 static bfd_boolean ieee_const_type (void *);
3962 static bfd_boolean ieee_volatile_type (void *);
3963 static bfd_boolean ieee_start_struct_type
3964 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
3965 static bfd_boolean ieee_struct_field
3966 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
3967 static bfd_boolean ieee_end_struct_type (void *);
3968 static bfd_boolean ieee_start_class_type
3969 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean,
3970 bfd_boolean);
3971 static bfd_boolean ieee_class_static_member
3972 (void *, const char *, const char *, enum debug_visibility);
3973 static bfd_boolean ieee_class_baseclass
3974 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
3975 static bfd_boolean ieee_class_start_method (void *, const char *);
3976 static bfd_boolean ieee_class_method_variant
3977 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
3978 bfd_vma, bfd_boolean);
3979 static bfd_boolean ieee_class_static_method_variant
3980 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
3981 static bfd_boolean ieee_class_end_method (void *);
3982 static bfd_boolean ieee_end_class_type (void *);
3983 static bfd_boolean ieee_typedef_type (void *, const char *);
3984 static bfd_boolean ieee_tag_type
3985 (void *, const char *, unsigned int, enum debug_type_kind);
3986 static bfd_boolean ieee_typdef (void *, const char *);
3987 static bfd_boolean ieee_tag (void *, const char *);
3988 static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma);
3989 static bfd_boolean ieee_float_constant (void *, const char *, double);
3990 static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma);
3991 static bfd_boolean ieee_variable
3992 (void *, const char *, enum debug_var_kind, bfd_vma);
3993 static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean);
3994 static bfd_boolean ieee_function_parameter
3995 (void *, const char *, enum debug_parm_kind, bfd_vma);
3996 static bfd_boolean ieee_start_block (void *, bfd_vma);
3997 static bfd_boolean ieee_end_block (void *, bfd_vma);
3998 static bfd_boolean ieee_end_function (void *);
3999 static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma);
4001 static const struct debug_write_fns ieee_fns =
4003 ieee_start_compilation_unit,
4004 ieee_start_source,
4005 ieee_empty_type,
4006 ieee_void_type,
4007 ieee_int_type,
4008 ieee_float_type,
4009 ieee_complex_type,
4010 ieee_bool_type,
4011 ieee_enum_type,
4012 ieee_pointer_type,
4013 ieee_function_type,
4014 ieee_reference_type,
4015 ieee_range_type,
4016 ieee_array_type,
4017 ieee_set_type,
4018 ieee_offset_type,
4019 ieee_method_type,
4020 ieee_const_type,
4021 ieee_volatile_type,
4022 ieee_start_struct_type,
4023 ieee_struct_field,
4024 ieee_end_struct_type,
4025 ieee_start_class_type,
4026 ieee_class_static_member,
4027 ieee_class_baseclass,
4028 ieee_class_start_method,
4029 ieee_class_method_variant,
4030 ieee_class_static_method_variant,
4031 ieee_class_end_method,
4032 ieee_end_class_type,
4033 ieee_typedef_type,
4034 ieee_tag_type,
4035 ieee_typdef,
4036 ieee_tag,
4037 ieee_int_constant,
4038 ieee_float_constant,
4039 ieee_typed_constant,
4040 ieee_variable,
4041 ieee_start_function,
4042 ieee_function_parameter,
4043 ieee_start_block,
4044 ieee_end_block,
4045 ieee_end_function,
4046 ieee_lineno
4049 /* Initialize a buffer to be empty. */
4051 static bfd_boolean
4052 ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4053 struct ieee_buflist *buflist)
4055 buflist->head = NULL;
4056 buflist->tail = NULL;
4057 return TRUE;
4060 /* See whether a buffer list has any data. */
4062 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
4064 /* Change the current buffer to a specified buffer chain. */
4066 static bfd_boolean
4067 ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist)
4069 if (buflist->head == NULL)
4071 struct ieee_buf *buf;
4073 buf = (struct ieee_buf *) xmalloc (sizeof *buf);
4074 buf->next = NULL;
4075 buf->c = 0;
4076 buflist->head = buf;
4077 buflist->tail = buf;
4080 info->current = buflist;
4081 info->curbuf = buflist->tail;
4083 return TRUE;
4086 /* Append a buffer chain. */
4088 static bfd_boolean
4089 ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4090 struct ieee_buflist *mainbuf,
4091 struct ieee_buflist *newbuf)
4093 if (newbuf->head != NULL)
4095 if (mainbuf->head == NULL)
4096 mainbuf->head = newbuf->head;
4097 else
4098 mainbuf->tail->next = newbuf->head;
4099 mainbuf->tail = newbuf->tail;
4101 return TRUE;
4104 /* Write a byte into the buffer. We use a macro for speed and a
4105 function for the complex cases. */
4107 #define ieee_write_byte(info, b) \
4108 ((info)->curbuf->c < IEEE_BUFSIZE \
4109 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \
4110 : ieee_real_write_byte ((info), (b)))
4112 static bfd_boolean
4113 ieee_real_write_byte (struct ieee_handle *info, int b)
4115 if (info->curbuf->c >= IEEE_BUFSIZE)
4117 struct ieee_buf *n;
4119 n = (struct ieee_buf *) xmalloc (sizeof *n);
4120 n->next = NULL;
4121 n->c = 0;
4122 if (info->current->head == NULL)
4123 info->current->head = n;
4124 else
4125 info->current->tail->next = n;
4126 info->current->tail = n;
4127 info->curbuf = n;
4130 info->curbuf->buf[info->curbuf->c] = b;
4131 ++info->curbuf->c;
4133 return TRUE;
4136 /* Write out two bytes. */
4138 static bfd_boolean
4139 ieee_write_2bytes (struct ieee_handle *info, int i)
4141 return (ieee_write_byte (info, i >> 8)
4142 && ieee_write_byte (info, i & 0xff));
4145 /* Write out an integer. */
4147 static bfd_boolean
4148 ieee_write_number (struct ieee_handle *info, bfd_vma v)
4150 bfd_vma t;
4151 bfd_byte ab[20];
4152 bfd_byte *p;
4153 unsigned int c;
4155 if (v <= (bfd_vma) ieee_number_end_enum)
4156 return ieee_write_byte (info, (int) v);
4158 t = v;
4159 p = ab + sizeof ab;
4160 while (t != 0)
4162 *--p = t & 0xff;
4163 t >>= 8;
4165 c = (ab + 20) - p;
4167 if (c > (unsigned int) (ieee_number_repeat_end_enum
4168 - ieee_number_repeat_start_enum))
4170 fprintf (stderr, _("IEEE numeric overflow: 0x"));
4171 fprintf_vma (stderr, v);
4172 fprintf (stderr, "\n");
4173 return FALSE;
4176 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
4177 return FALSE;
4178 for (; c > 0; --c, ++p)
4180 if (! ieee_write_byte (info, *p))
4181 return FALSE;
4184 return TRUE;
4187 /* Write out a string. */
4189 static bfd_boolean
4190 ieee_write_id (struct ieee_handle *info, const char *s)
4192 unsigned int len;
4194 len = strlen (s);
4195 if (len <= 0x7f)
4197 if (! ieee_write_byte (info, len))
4198 return FALSE;
4200 else if (len <= 0xff)
4202 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
4203 || ! ieee_write_byte (info, len))
4204 return FALSE;
4206 else if (len <= 0xffff)
4208 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
4209 || ! ieee_write_2bytes (info, len))
4210 return FALSE;
4212 else
4214 fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
4215 return FALSE;
4218 for (; *s != '\0'; s++)
4219 if (! ieee_write_byte (info, *s))
4220 return FALSE;
4222 return TRUE;
4225 /* Write out an ASN record. */
4227 static bfd_boolean
4228 ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val)
4230 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
4231 && ieee_write_number (info, indx)
4232 && ieee_write_number (info, val));
4235 /* Write out an ATN65 record. */
4237 static bfd_boolean
4238 ieee_write_atn65 (struct ieee_handle *info, unsigned int indx, const char *s)
4240 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
4241 && ieee_write_number (info, indx)
4242 && ieee_write_number (info, 0)
4243 && ieee_write_number (info, 65)
4244 && ieee_write_id (info, s));
4247 /* Push a type index onto the type stack. */
4249 static bfd_boolean
4250 ieee_push_type (struct ieee_handle *info, unsigned int indx,
4251 unsigned int size, bfd_boolean unsignedp, bfd_boolean localp)
4253 struct ieee_type_stack *ts;
4255 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
4256 memset (ts, 0, sizeof *ts);
4258 ts->type.indx = indx;
4259 ts->type.size = size;
4260 ts->type.unsignedp = unsignedp;
4261 ts->type.localp = localp;
4263 ts->next = info->type_stack;
4264 info->type_stack = ts;
4266 return TRUE;
4269 /* Pop a type index off the type stack. */
4271 static unsigned int
4272 ieee_pop_type (struct ieee_handle *info)
4274 return ieee_pop_type_used (info, TRUE);
4277 /* Pop an unused type index off the type stack. */
4279 static void
4280 ieee_pop_unused_type (struct ieee_handle *info)
4282 (void) ieee_pop_type_used (info, FALSE);
4285 /* Pop a used or unused type index off the type stack. */
4287 static unsigned int
4288 ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used)
4290 struct ieee_type_stack *ts;
4291 unsigned int ret;
4293 ts = info->type_stack;
4294 assert (ts != NULL);
4296 /* If this is a function type, and we need it, we need to append the
4297 actual definition to the typedef block now. */
4298 if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
4300 struct ieee_buflist *buflist;
4302 if (ts->type.localp)
4304 /* Make sure we have started the types block. */
4305 if (ieee_buffer_emptyp (&info->types))
4307 if (! ieee_change_buffer (info, &info->types)
4308 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4309 || ! ieee_write_byte (info, 1)
4310 || ! ieee_write_number (info, 0)
4311 || ! ieee_write_id (info, info->modname))
4312 return FALSE;
4314 buflist = &info->types;
4316 else
4318 /* Make sure we started the global type block. */
4319 if (ieee_buffer_emptyp (&info->global_types))
4321 if (! ieee_change_buffer (info, &info->global_types)
4322 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4323 || ! ieee_write_byte (info, 2)
4324 || ! ieee_write_number (info, 0)
4325 || ! ieee_write_id (info, ""))
4326 return FALSE;
4328 buflist = &info->global_types;
4331 if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
4332 return FALSE;
4335 ret = ts->type.indx;
4336 info->type_stack = ts->next;
4337 free (ts);
4338 return ret;
4341 /* Add a range of bytes included in the current compilation unit. */
4343 static bfd_boolean
4344 ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low,
4345 bfd_vma high)
4347 struct ieee_range **plist, *r, **pr;
4349 if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
4350 return TRUE;
4352 if (global)
4353 plist = &info->global_ranges;
4354 else
4355 plist = &info->ranges;
4357 for (r = *plist; r != NULL; r = r->next)
4359 if (high >= r->low && low <= r->high)
4361 /* The new range overlaps r. */
4362 if (low < r->low)
4363 r->low = low;
4364 if (high > r->high)
4365 r->high = high;
4366 pr = &r->next;
4367 while (*pr != NULL && (*pr)->low <= r->high)
4369 struct ieee_range *n;
4371 if ((*pr)->high > r->high)
4372 r->high = (*pr)->high;
4373 n = (*pr)->next;
4374 free (*pr);
4375 *pr = n;
4377 return TRUE;
4381 r = (struct ieee_range *) xmalloc (sizeof *r);
4382 memset (r, 0, sizeof *r);
4384 r->low = low;
4385 r->high = high;
4387 /* Store the ranges sorted by address. */
4388 for (pr = plist; *pr != NULL; pr = &(*pr)->next)
4389 if ((*pr)->low > high)
4390 break;
4391 r->next = *pr;
4392 *pr = r;
4394 return TRUE;
4397 /* Start a new range for which we only have the low address. */
4399 static bfd_boolean
4400 ieee_start_range (struct ieee_handle *info, bfd_vma low)
4402 struct ieee_range *r;
4404 r = (struct ieee_range *) xmalloc (sizeof *r);
4405 memset (r, 0, sizeof *r);
4406 r->low = low;
4407 r->next = info->pending_ranges;
4408 info->pending_ranges = r;
4409 return TRUE;
4412 /* Finish a range started by ieee_start_range. */
4414 static bfd_boolean
4415 ieee_end_range (struct ieee_handle *info, bfd_vma high)
4417 struct ieee_range *r;
4418 bfd_vma low;
4420 assert (info->pending_ranges != NULL);
4421 r = info->pending_ranges;
4422 low = r->low;
4423 info->pending_ranges = r->next;
4424 free (r);
4425 return ieee_add_range (info, FALSE, low, high);
4428 /* Start defining a type. */
4430 static bfd_boolean
4431 ieee_define_type (struct ieee_handle *info, unsigned int size,
4432 bfd_boolean unsignedp, bfd_boolean localp)
4434 return ieee_define_named_type (info, (const char *) NULL,
4435 (unsigned int) -1, size, unsignedp,
4436 localp, (struct ieee_buflist *) NULL);
4439 /* Start defining a named type. */
4441 static bfd_boolean
4442 ieee_define_named_type (struct ieee_handle *info, const char *name,
4443 unsigned int indx, unsigned int size,
4444 bfd_boolean unsignedp, bfd_boolean localp,
4445 struct ieee_buflist *buflist)
4447 unsigned int type_indx;
4448 unsigned int name_indx;
4450 if (indx != (unsigned int) -1)
4451 type_indx = indx;
4452 else
4454 type_indx = info->type_indx;
4455 ++info->type_indx;
4458 name_indx = info->name_indx;
4459 ++info->name_indx;
4461 if (name == NULL)
4462 name = "";
4464 /* If we were given a buffer, use it; otherwise, use either the
4465 local or the global type information, and make sure that the type
4466 block is started. */
4467 if (buflist != NULL)
4469 if (! ieee_change_buffer (info, buflist))
4470 return FALSE;
4472 else if (localp)
4474 if (! ieee_buffer_emptyp (&info->types))
4476 if (! ieee_change_buffer (info, &info->types))
4477 return FALSE;
4479 else
4481 if (! ieee_change_buffer (info, &info->types)
4482 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4483 || ! ieee_write_byte (info, 1)
4484 || ! ieee_write_number (info, 0)
4485 || ! ieee_write_id (info, info->modname))
4486 return FALSE;
4489 else
4491 if (! ieee_buffer_emptyp (&info->global_types))
4493 if (! ieee_change_buffer (info, &info->global_types))
4494 return FALSE;
4496 else
4498 if (! ieee_change_buffer (info, &info->global_types)
4499 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4500 || ! ieee_write_byte (info, 2)
4501 || ! ieee_write_number (info, 0)
4502 || ! ieee_write_id (info, ""))
4503 return FALSE;
4507 /* Push the new type on the type stack, write out an NN record, and
4508 write out the start of a TY record. The caller will then finish
4509 the TY record. */
4510 if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
4511 return FALSE;
4513 return (ieee_write_byte (info, (int) ieee_nn_record)
4514 && ieee_write_number (info, name_indx)
4515 && ieee_write_id (info, name)
4516 && ieee_write_byte (info, (int) ieee_ty_record_enum)
4517 && ieee_write_number (info, type_indx)
4518 && ieee_write_byte (info, 0xce)
4519 && ieee_write_number (info, name_indx));
4522 /* Get an entry to the list of modified versions of a type. */
4524 static struct ieee_modified_type *
4525 ieee_get_modified_info (struct ieee_handle *info, unsigned int indx)
4527 if (indx >= info->modified_alloc)
4529 unsigned int nalloc;
4531 nalloc = info->modified_alloc;
4532 if (nalloc == 0)
4533 nalloc = 16;
4534 while (indx >= nalloc)
4535 nalloc *= 2;
4536 info->modified = ((struct ieee_modified_type *)
4537 xrealloc (info->modified,
4538 nalloc * sizeof *info->modified));
4539 memset (info->modified + info->modified_alloc, 0,
4540 (nalloc - info->modified_alloc) * sizeof *info->modified);
4541 info->modified_alloc = nalloc;
4544 return info->modified + indx;
4547 /* Routines for the hash table mapping names to types. */
4549 /* Initialize an entry in the hash table. */
4551 static struct bfd_hash_entry *
4552 ieee_name_type_newfunc (struct bfd_hash_entry *entry,
4553 struct bfd_hash_table *table, const char *string)
4555 struct ieee_name_type_hash_entry *ret =
4556 (struct ieee_name_type_hash_entry *) entry;
4558 /* Allocate the structure if it has not already been allocated by a
4559 subclass. */
4560 if (ret == NULL)
4561 ret = ((struct ieee_name_type_hash_entry *)
4562 bfd_hash_allocate (table, sizeof *ret));
4563 if (ret == NULL)
4564 return NULL;
4566 /* Call the allocation method of the superclass. */
4567 ret = ((struct ieee_name_type_hash_entry *)
4568 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
4569 if (ret)
4571 /* Set local fields. */
4572 ret->types = NULL;
4575 return (struct bfd_hash_entry *) ret;
4578 /* Look up an entry in the hash table. */
4580 #define ieee_name_type_hash_lookup(table, string, create, copy) \
4581 ((struct ieee_name_type_hash_entry *) \
4582 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4584 /* Traverse the hash table. */
4586 #define ieee_name_type_hash_traverse(table, func, info) \
4587 (bfd_hash_traverse \
4588 (&(table)->root, \
4589 (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \
4590 (info)))
4592 /* The general routine to write out IEEE debugging information. */
4594 bfd_boolean
4595 write_ieee_debugging_info (bfd *abfd, void *dhandle)
4597 struct ieee_handle info;
4598 asection *s;
4599 const char *err;
4600 struct ieee_buf *b;
4602 memset (&info, 0, sizeof info);
4603 info.abfd = abfd;
4604 info.type_indx = 256;
4605 info.name_indx = 32;
4607 if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc,
4608 sizeof (struct ieee_name_type_hash_entry))
4609 || !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc,
4610 sizeof (struct ieee_name_type_hash_entry)))
4611 return FALSE;
4613 if (! ieee_init_buffer (&info, &info.global_types)
4614 || ! ieee_init_buffer (&info, &info.data)
4615 || ! ieee_init_buffer (&info, &info.types)
4616 || ! ieee_init_buffer (&info, &info.vars)
4617 || ! ieee_init_buffer (&info, &info.cxx)
4618 || ! ieee_init_buffer (&info, &info.linenos)
4619 || ! ieee_init_buffer (&info, &info.fntype)
4620 || ! ieee_init_buffer (&info, &info.fnargs))
4621 return FALSE;
4623 if (! debug_write (dhandle, &ieee_fns, (void *) &info))
4624 return FALSE;
4626 if (info.filename != NULL)
4628 if (! ieee_finish_compilation_unit (&info))
4629 return FALSE;
4632 /* Put any undefined tags in the global typedef information. */
4633 info.error = FALSE;
4634 ieee_name_type_hash_traverse (&info.tags,
4635 ieee_write_undefined_tag,
4636 (void *) &info);
4637 if (info.error)
4638 return FALSE;
4640 /* Prepend the global typedef information to the other data. */
4641 if (! ieee_buffer_emptyp (&info.global_types))
4643 /* The HP debugger seems to have a bug in which it ignores the
4644 last entry in the global types, so we add a dummy entry. */
4645 if (! ieee_change_buffer (&info, &info.global_types)
4646 || ! ieee_write_byte (&info, (int) ieee_nn_record)
4647 || ! ieee_write_number (&info, info.name_indx)
4648 || ! ieee_write_id (&info, "")
4649 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
4650 || ! ieee_write_number (&info, info.type_indx)
4651 || ! ieee_write_byte (&info, 0xce)
4652 || ! ieee_write_number (&info, info.name_indx)
4653 || ! ieee_write_number (&info, 'P')
4654 || ! ieee_write_number (&info, (int) builtin_void + 32)
4655 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4656 return FALSE;
4658 if (! ieee_append_buffer (&info, &info.global_types, &info.data))
4659 return FALSE;
4660 info.data = info.global_types;
4663 /* Make sure that we have declare BB11 blocks for each range in the
4664 file. They are added to info->vars. */
4665 info.error = FALSE;
4666 if (! ieee_init_buffer (&info, &info.vars))
4667 return FALSE;
4668 bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info);
4669 if (info.error)
4670 return FALSE;
4671 if (! ieee_buffer_emptyp (&info.vars))
4673 if (! ieee_change_buffer (&info, &info.vars)
4674 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4675 return FALSE;
4677 if (! ieee_append_buffer (&info, &info.data, &info.vars))
4678 return FALSE;
4681 /* Now all the data is in info.data. Write it out to the BFD. We
4682 normally would need to worry about whether all the other sections
4683 are set up yet, but the IEEE backend will handle this particular
4684 case correctly regardless. */
4685 if (ieee_buffer_emptyp (&info.data))
4687 /* There is no debugging information. */
4688 return TRUE;
4690 err = NULL;
4691 s = bfd_make_section_with_flags (abfd, ".debug",
4692 SEC_DEBUGGING | SEC_HAS_CONTENTS);
4693 if (s == NULL)
4694 err = "bfd_make_section";
4695 if (err == NULL)
4697 bfd_size_type size;
4699 size = 0;
4700 for (b = info.data.head; b != NULL; b = b->next)
4701 size += b->c;
4702 if (! bfd_set_section_size (abfd, s, size))
4703 err = "bfd_set_section_size";
4705 if (err == NULL)
4707 file_ptr offset;
4709 offset = 0;
4710 for (b = info.data.head; b != NULL; b = b->next)
4712 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4714 err = "bfd_set_section_contents";
4715 break;
4717 offset += b->c;
4721 if (err != NULL)
4723 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4724 bfd_errmsg (bfd_get_error ()));
4725 return FALSE;
4728 bfd_hash_table_free (&info.typedefs.root);
4729 bfd_hash_table_free (&info.tags.root);
4731 return TRUE;
4734 /* Write out information for an undefined tag. This is called via
4735 ieee_name_type_hash_traverse. */
4737 static bfd_boolean
4738 ieee_write_undefined_tag (struct ieee_name_type_hash_entry *h, void *p)
4740 struct ieee_handle *info = (struct ieee_handle *) p;
4741 struct ieee_name_type *nt;
4743 for (nt = h->types; nt != NULL; nt = nt->next)
4745 unsigned int name_indx;
4746 char code;
4748 if (nt->kind == DEBUG_KIND_ILLEGAL)
4749 continue;
4751 if (ieee_buffer_emptyp (&info->global_types))
4753 if (! ieee_change_buffer (info, &info->global_types)
4754 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4755 || ! ieee_write_byte (info, 2)
4756 || ! ieee_write_number (info, 0)
4757 || ! ieee_write_id (info, ""))
4759 info->error = TRUE;
4760 return FALSE;
4763 else
4765 if (! ieee_change_buffer (info, &info->global_types))
4767 info->error = TRUE;
4768 return FALSE;
4772 name_indx = info->name_indx;
4773 ++info->name_indx;
4774 if (! ieee_write_byte (info, (int) ieee_nn_record)
4775 || ! ieee_write_number (info, name_indx)
4776 || ! ieee_write_id (info, nt->type.name)
4777 || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
4778 || ! ieee_write_number (info, nt->type.indx)
4779 || ! ieee_write_byte (info, 0xce)
4780 || ! ieee_write_number (info, name_indx))
4782 info->error = TRUE;
4783 return FALSE;
4786 switch (nt->kind)
4788 default:
4789 abort ();
4790 info->error = TRUE;
4791 return FALSE;
4792 case DEBUG_KIND_STRUCT:
4793 case DEBUG_KIND_CLASS:
4794 code = 'S';
4795 break;
4796 case DEBUG_KIND_UNION:
4797 case DEBUG_KIND_UNION_CLASS:
4798 code = 'U';
4799 break;
4800 case DEBUG_KIND_ENUM:
4801 code = 'E';
4802 break;
4804 if (! ieee_write_number (info, code)
4805 || ! ieee_write_number (info, 0))
4807 info->error = TRUE;
4808 return FALSE;
4812 return TRUE;
4815 /* Start writing out information for a compilation unit. */
4817 static bfd_boolean
4818 ieee_start_compilation_unit (void *p, const char *filename)
4820 struct ieee_handle *info = (struct ieee_handle *) p;
4821 const char *modname;
4822 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4823 const char *backslash;
4824 #endif
4825 char *c, *s;
4827 if (info->filename != NULL)
4829 if (! ieee_finish_compilation_unit (info))
4830 return FALSE;
4833 info->filename = filename;
4834 modname = strrchr (filename, '/');
4835 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4836 /* We could have a mixed forward/back slash case. */
4837 backslash = strrchr (filename, '\\');
4838 if (modname == NULL || (backslash != NULL && backslash > modname))
4839 modname = backslash;
4840 #endif
4842 if (modname != NULL)
4843 ++modname;
4844 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4845 else if (filename[0] && filename[1] == ':')
4846 modname = filename + 2;
4847 #endif
4848 else
4849 modname = filename;
4851 c = xstrdup (modname);
4852 s = strrchr (c, '.');
4853 if (s != NULL)
4854 *s = '\0';
4855 info->modname = c;
4857 if (! ieee_init_buffer (info, &info->types)
4858 || ! ieee_init_buffer (info, &info->vars)
4859 || ! ieee_init_buffer (info, &info->cxx)
4860 || ! ieee_init_buffer (info, &info->linenos))
4861 return FALSE;
4862 info->ranges = NULL;
4864 /* Always include a BB1 and a BB3 block. That is what the output of
4865 the MRI linker seems to look like. */
4866 if (! ieee_change_buffer (info, &info->types)
4867 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4868 || ! ieee_write_byte (info, 1)
4869 || ! ieee_write_number (info, 0)
4870 || ! ieee_write_id (info, info->modname))
4871 return FALSE;
4873 ++info->name_indx;
4874 if (! ieee_change_buffer (info, &info->vars)
4875 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4876 || ! ieee_write_byte (info, 3)
4877 || ! ieee_write_number (info, 0)
4878 || ! ieee_write_id (info, info->modname))
4879 return FALSE;
4881 return TRUE;
4884 /* Finish up a compilation unit. */
4886 static bfd_boolean
4887 ieee_finish_compilation_unit (struct ieee_handle *info)
4889 struct ieee_range *r;
4891 if (! ieee_buffer_emptyp (&info->types))
4893 if (! ieee_change_buffer (info, &info->types)
4894 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4895 return FALSE;
4898 if (! ieee_buffer_emptyp (&info->cxx))
4900 /* Append any C++ information to the global function and
4901 variable information. */
4902 assert (! ieee_buffer_emptyp (&info->vars));
4903 if (! ieee_change_buffer (info, &info->vars))
4904 return FALSE;
4906 /* We put the pmisc records in a dummy procedure, just as the
4907 MRI compiler does. */
4908 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4909 || ! ieee_write_byte (info, 6)
4910 || ! ieee_write_number (info, 0)
4911 || ! ieee_write_id (info, "__XRYCPP")
4912 || ! ieee_write_number (info, 0)
4913 || ! ieee_write_number (info, 0)
4914 || ! ieee_write_number (info, info->highaddr - 1)
4915 || ! ieee_append_buffer (info, &info->vars, &info->cxx)
4916 || ! ieee_change_buffer (info, &info->vars)
4917 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4918 || ! ieee_write_number (info, info->highaddr - 1))
4919 return FALSE;
4922 if (! ieee_buffer_emptyp (&info->vars))
4924 if (! ieee_change_buffer (info, &info->vars)
4925 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4926 return FALSE;
4929 if (info->pending_lineno_filename != NULL)
4931 /* Force out the pending line number. */
4932 if (! ieee_lineno ((void *) info, (const char *) NULL, 0, (bfd_vma) -1))
4933 return FALSE;
4935 if (! ieee_buffer_emptyp (&info->linenos))
4937 if (! ieee_change_buffer (info, &info->linenos)
4938 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4939 return FALSE;
4940 if (filename_cmp (info->filename, info->lineno_filename) != 0)
4942 /* We were not in the main file. We just closed the
4943 included line number block, and now we must close the
4944 main line number block. */
4945 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
4946 return FALSE;
4950 if (! ieee_append_buffer (info, &info->data, &info->types)
4951 || ! ieee_append_buffer (info, &info->data, &info->vars)
4952 || ! ieee_append_buffer (info, &info->data, &info->linenos))
4953 return FALSE;
4955 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4956 if (! ieee_change_buffer (info, &info->data))
4957 return FALSE;
4959 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4960 || ! ieee_write_byte (info, 10)
4961 || ! ieee_write_number (info, 0)
4962 || ! ieee_write_id (info, info->modname)
4963 || ! ieee_write_id (info, "")
4964 || ! ieee_write_number (info, 0)
4965 || ! ieee_write_id (info, "GNU objcopy"))
4966 return FALSE;
4968 for (r = info->ranges; r != NULL; r = r->next)
4970 bfd_vma low, high;
4971 asection *s;
4972 int kind;
4974 low = r->low;
4975 high = r->high;
4977 /* Find the section corresponding to this range. */
4978 for (s = info->abfd->sections; s != NULL; s = s->next)
4980 if (bfd_get_section_vma (info->abfd, s) <= low
4981 && high <= (bfd_get_section_vma (info->abfd, s)
4982 + bfd_section_size (info->abfd, s)))
4983 break;
4986 if (s == NULL)
4988 /* Just ignore this range. */
4989 continue;
4992 /* Coalesce ranges if it seems reasonable. */
4993 while (r->next != NULL
4994 && high + 0x1000 >= r->next->low
4995 && (r->next->high
4996 <= (bfd_get_section_vma (info->abfd, s)
4997 + bfd_section_size (info->abfd, s))))
4999 r = r->next;
5000 high = r->high;
5003 if ((s->flags & SEC_CODE) != 0)
5004 kind = 1;
5005 else if ((s->flags & SEC_READONLY) != 0)
5006 kind = 3;
5007 else
5008 kind = 2;
5010 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5011 || ! ieee_write_byte (info, 11)
5012 || ! ieee_write_number (info, 0)
5013 || ! ieee_write_id (info, "")
5014 || ! ieee_write_number (info, kind)
5015 || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
5016 || ! ieee_write_number (info, low)
5017 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5018 || ! ieee_write_number (info, high - low))
5019 return FALSE;
5021 /* Add this range to the list of global ranges. */
5022 if (! ieee_add_range (info, TRUE, low, high))
5023 return FALSE;
5026 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
5027 return FALSE;
5029 return TRUE;
5032 /* Add BB11 blocks describing each range that we have not already
5033 described. */
5035 static void
5036 ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data)
5038 struct ieee_handle *info = (struct ieee_handle *) data;
5039 bfd_vma low, high;
5040 struct ieee_range *r;
5042 low = bfd_get_section_vma (abfd, sec);
5043 high = low + bfd_section_size (abfd, sec);
5045 /* Find the first range at or after this section. The ranges are
5046 sorted by address. */
5047 for (r = info->global_ranges; r != NULL; r = r->next)
5048 if (r->high > low)
5049 break;
5051 while (low < high)
5053 if (r == NULL || r->low >= high)
5055 if (! ieee_add_bb11 (info, sec, low, high))
5056 info->error = TRUE;
5057 return;
5060 if (low < r->low
5061 && r->low - low > 0x100)
5063 if (! ieee_add_bb11 (info, sec, low, r->low))
5065 info->error = TRUE;
5066 return;
5069 low = r->high;
5071 r = r->next;
5075 /* Add a single BB11 block for a range. We add it to info->vars. */
5077 static bfd_boolean
5078 ieee_add_bb11 (struct ieee_handle *info, asection *sec, bfd_vma low,
5079 bfd_vma high)
5081 int kind;
5083 if (! ieee_buffer_emptyp (&info->vars))
5085 if (! ieee_change_buffer (info, &info->vars))
5086 return FALSE;
5088 else
5090 const char *filename, *modname;
5091 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5092 const char *backslash;
5093 #endif
5094 char *c, *s;
5096 /* Start the enclosing BB10 block. */
5097 filename = bfd_get_filename (info->abfd);
5098 modname = strrchr (filename, '/');
5099 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5100 backslash = strrchr (filename, '\\');
5101 if (modname == NULL || (backslash != NULL && backslash > modname))
5102 modname = backslash;
5103 #endif
5105 if (modname != NULL)
5106 ++modname;
5107 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5108 else if (filename[0] && filename[1] == ':')
5109 modname = filename + 2;
5110 #endif
5111 else
5112 modname = filename;
5114 c = xstrdup (modname);
5115 s = strrchr (c, '.');
5116 if (s != NULL)
5117 *s = '\0';
5119 if (! ieee_change_buffer (info, &info->vars)
5120 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5121 || ! ieee_write_byte (info, 10)
5122 || ! ieee_write_number (info, 0)
5123 || ! ieee_write_id (info, c)
5124 || ! ieee_write_id (info, "")
5125 || ! ieee_write_number (info, 0)
5126 || ! ieee_write_id (info, "GNU objcopy"))
5128 free (c);
5129 return FALSE;
5132 free (c);
5135 if ((sec->flags & SEC_CODE) != 0)
5136 kind = 1;
5137 else if ((sec->flags & SEC_READONLY) != 0)
5138 kind = 3;
5139 else
5140 kind = 2;
5142 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5143 || ! ieee_write_byte (info, 11)
5144 || ! ieee_write_number (info, 0)
5145 || ! ieee_write_id (info, "")
5146 || ! ieee_write_number (info, kind)
5147 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5148 || ! ieee_write_number (info, low)
5149 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5150 || ! ieee_write_number (info, high - low))
5151 return FALSE;
5153 return TRUE;
5156 /* Start recording information from a particular source file. This is
5157 used to record which file defined which types, variables, etc. It
5158 is not used for line numbers, since the lineno entry point passes
5159 down the file name anyhow. IEEE debugging information doesn't seem
5160 to store this information anywhere. */
5162 static bfd_boolean
5163 ieee_start_source (void *p ATTRIBUTE_UNUSED,
5164 const char *filename ATTRIBUTE_UNUSED)
5166 return TRUE;
5169 /* Make an empty type. */
5171 static bfd_boolean
5172 ieee_empty_type (void *p)
5174 struct ieee_handle *info = (struct ieee_handle *) p;
5176 return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
5179 /* Make a void type. */
5181 static bfd_boolean
5182 ieee_void_type (void *p)
5184 struct ieee_handle *info = (struct ieee_handle *) p;
5186 return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
5189 /* Make an integer type. */
5191 static bfd_boolean
5192 ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
5194 struct ieee_handle *info = (struct ieee_handle *) p;
5195 unsigned int indx;
5197 switch (size)
5199 case 1:
5200 indx = (int) builtin_signed_char;
5201 break;
5202 case 2:
5203 indx = (int) builtin_signed_short_int;
5204 break;
5205 case 4:
5206 indx = (int) builtin_signed_long;
5207 break;
5208 case 8:
5209 indx = (int) builtin_signed_long_long;
5210 break;
5211 default:
5212 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
5213 return FALSE;
5216 if (unsignedp)
5217 ++indx;
5219 return ieee_push_type (info, indx, size, unsignedp, FALSE);
5222 /* Make a floating point type. */
5224 static bfd_boolean
5225 ieee_float_type (void *p, unsigned int size)
5227 struct ieee_handle *info = (struct ieee_handle *) p;
5228 unsigned int indx;
5230 switch (size)
5232 case 4:
5233 indx = (int) builtin_float;
5234 break;
5235 case 8:
5236 indx = (int) builtin_double;
5237 break;
5238 case 12:
5239 /* FIXME: This size really depends upon the processor. */
5240 indx = (int) builtin_long_double;
5241 break;
5242 case 16:
5243 indx = (int) builtin_long_long_double;
5244 break;
5245 default:
5246 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
5247 return FALSE;
5250 return ieee_push_type (info, indx, size, FALSE, FALSE);
5253 /* Make a complex type. */
5255 static bfd_boolean
5256 ieee_complex_type (void *p, unsigned int size)
5258 struct ieee_handle *info = (struct ieee_handle *) p;
5259 char code;
5261 switch (size)
5263 case 4:
5264 if (info->complex_float_index != 0)
5265 return ieee_push_type (info, info->complex_float_index, size * 2,
5266 FALSE, FALSE);
5267 code = 'c';
5268 break;
5269 case 12:
5270 case 16:
5271 /* These cases can be output by gcc -gstabs. Outputting the
5272 wrong type is better than crashing. */
5273 case 8:
5274 if (info->complex_double_index != 0)
5275 return ieee_push_type (info, info->complex_double_index, size * 2,
5276 FALSE, FALSE);
5277 code = 'd';
5278 break;
5279 default:
5280 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
5281 return FALSE;
5284 /* FIXME: I don't know what the string is for. */
5285 if (! ieee_define_type (info, size * 2, FALSE, FALSE)
5286 || ! ieee_write_number (info, code)
5287 || ! ieee_write_id (info, ""))
5288 return FALSE;
5290 if (size == 4)
5291 info->complex_float_index = info->type_stack->type.indx;
5292 else
5293 info->complex_double_index = info->type_stack->type.indx;
5295 return TRUE;
5298 /* Make a boolean type. IEEE doesn't support these, so we just make
5299 an integer type instead. */
5301 static bfd_boolean
5302 ieee_bool_type (void *p, unsigned int size)
5304 return ieee_int_type (p, size, TRUE);
5307 /* Make an enumeration. */
5309 static bfd_boolean
5310 ieee_enum_type (void *p, const char *tag, const char **names,
5311 bfd_signed_vma *vals)
5313 struct ieee_handle *info = (struct ieee_handle *) p;
5314 struct ieee_defined_enum *e;
5315 bfd_boolean localp, simple;
5316 unsigned int indx;
5317 int i = 0;
5319 localp = FALSE;
5320 indx = (unsigned int) -1;
5321 for (e = info->enums; e != NULL; e = e->next)
5323 if (tag == NULL)
5325 if (e->tag != NULL)
5326 continue;
5328 else
5330 if (e->tag == NULL
5331 || tag[0] != e->tag[0]
5332 || strcmp (tag, e->tag) != 0)
5333 continue;
5336 if (! e->defined)
5338 /* This enum tag has been seen but not defined. */
5339 indx = e->indx;
5340 break;
5343 if (names != NULL && e->names != NULL)
5345 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5347 if (names[i][0] != e->names[i][0]
5348 || vals[i] != e->vals[i]
5349 || strcmp (names[i], e->names[i]) != 0)
5350 break;
5354 if ((names == NULL && e->names == NULL)
5355 || (names != NULL
5356 && e->names != NULL
5357 && names[i] == NULL
5358 && e->names[i] == NULL))
5360 /* We've seen this enum before. */
5361 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
5364 if (tag != NULL)
5366 /* We've already seen an enum of the same name, so we must make
5367 sure to output this one locally. */
5368 localp = TRUE;
5369 break;
5373 /* If this is a simple enumeration, in which the values start at 0
5374 and always increment by 1, we can use type E. Otherwise we must
5375 use type N. */
5377 simple = TRUE;
5378 if (names != NULL)
5380 for (i = 0; names[i] != NULL; i++)
5382 if (vals[i] != i)
5384 simple = FALSE;
5385 break;
5390 if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
5391 (struct ieee_buflist *) NULL)
5392 || ! ieee_write_number (info, simple ? 'E' : 'N'))
5393 return FALSE;
5394 if (simple)
5396 /* FIXME: This is supposed to be the enumeration size, but we
5397 don't store that. */
5398 if (! ieee_write_number (info, 4))
5399 return FALSE;
5401 if (names != NULL)
5403 for (i = 0; names[i] != NULL; i++)
5405 if (! ieee_write_id (info, names[i]))
5406 return FALSE;
5407 if (! simple)
5409 if (! ieee_write_number (info, vals[i]))
5410 return FALSE;
5415 if (! localp)
5417 if (indx == (unsigned int) -1)
5419 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5420 memset (e, 0, sizeof *e);
5421 e->indx = info->type_stack->type.indx;
5422 e->tag = tag;
5424 e->next = info->enums;
5425 info->enums = e;
5428 e->names = names;
5429 e->vals = vals;
5430 e->defined = TRUE;
5433 return TRUE;
5436 /* Make a pointer type. */
5438 static bfd_boolean
5439 ieee_pointer_type (void *p)
5441 struct ieee_handle *info = (struct ieee_handle *) p;
5442 bfd_boolean localp;
5443 unsigned int indx;
5444 struct ieee_modified_type *m = NULL;
5446 localp = info->type_stack->type.localp;
5447 indx = ieee_pop_type (info);
5449 /* A pointer to a simple builtin type can be obtained by adding 32.
5450 FIXME: Will this be a short pointer, and will that matter? */
5451 if (indx < 32)
5452 return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);
5454 if (! localp)
5456 m = ieee_get_modified_info ((struct ieee_handle *) p, indx);
5457 if (m == NULL)
5458 return FALSE;
5460 /* FIXME: The size should depend upon the architecture. */
5461 if (m->pointer > 0)
5462 return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
5465 if (! ieee_define_type (info, 4, TRUE, localp)
5466 || ! ieee_write_number (info, 'P')
5467 || ! ieee_write_number (info, indx))
5468 return FALSE;
5470 if (! localp)
5471 m->pointer = info->type_stack->type.indx;
5473 return TRUE;
5476 /* Make a function type. This will be called for a method, but we
5477 don't want to actually add it to the type table in that case. We
5478 handle this by defining the type in a private buffer, and only
5479 adding that buffer to the typedef block if we are going to use it. */
5481 static bfd_boolean
5482 ieee_function_type (void *p, int argcount, bfd_boolean varargs)
5484 struct ieee_handle *info = (struct ieee_handle *) p;
5485 bfd_boolean localp;
5486 unsigned int *args = NULL;
5487 int i;
5488 unsigned int retindx;
5489 struct ieee_buflist fndef;
5490 struct ieee_modified_type *m;
5492 localp = FALSE;
5494 if (argcount > 0)
5496 args = (unsigned int *) xmalloc (argcount * sizeof *args);
5497 for (i = argcount - 1; i >= 0; i--)
5499 if (info->type_stack->type.localp)
5500 localp = TRUE;
5501 args[i] = ieee_pop_type (info);
5504 else if (argcount < 0)
5505 varargs = FALSE;
5507 if (info->type_stack->type.localp)
5508 localp = TRUE;
5509 retindx = ieee_pop_type (info);
5511 m = NULL;
5512 if (argcount < 0 && ! localp)
5514 m = ieee_get_modified_info ((struct ieee_handle *) p, retindx);
5515 if (m == NULL)
5516 return FALSE;
5518 if (m->function > 0)
5519 return ieee_push_type (info, m->function, 0, TRUE, FALSE);
5522 /* An attribute of 0x41 means that the frame and push mask are
5523 unknown. */
5524 if (! ieee_init_buffer (info, &fndef)
5525 || ! ieee_define_named_type (info, (const char *) NULL,
5526 (unsigned int) -1, 0, TRUE, localp,
5527 &fndef)
5528 || ! ieee_write_number (info, 'x')
5529 || ! ieee_write_number (info, 0x41)
5530 || ! ieee_write_number (info, 0)
5531 || ! ieee_write_number (info, 0)
5532 || ! ieee_write_number (info, retindx)
5533 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5535 free (args);
5536 return FALSE;
5538 if (argcount > 0)
5540 for (i = 0; i < argcount; i++)
5541 if (! ieee_write_number (info, args[i]))
5542 return FALSE;
5543 free (args);
5545 if (varargs)
5547 /* A varargs function is represented by writing out the last
5548 argument as type void *, although this makes little sense. */
5549 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5550 return FALSE;
5553 if (! ieee_write_number (info, 0))
5554 return FALSE;
5556 /* We wrote the information into fndef, in case we don't need it.
5557 It will be appended to info->types by ieee_pop_type. */
5558 info->type_stack->type.fndef = fndef;
5560 if (m != NULL)
5561 m->function = info->type_stack->type.indx;
5563 return TRUE;
5566 /* Make a reference type. */
5568 static bfd_boolean
5569 ieee_reference_type (void *p)
5571 struct ieee_handle *info = (struct ieee_handle *) p;
5573 /* IEEE appears to record a normal pointer type, and then use a
5574 pmisc record to indicate that it is really a reference. */
5576 if (! ieee_pointer_type (p))
5577 return FALSE;
5578 info->type_stack->type.referencep = TRUE;
5579 return TRUE;
5582 /* Make a range type. */
5584 static bfd_boolean
5585 ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
5587 struct ieee_handle *info = (struct ieee_handle *) p;
5588 unsigned int size;
5589 bfd_boolean unsignedp, localp;
5591 size = info->type_stack->type.size;
5592 unsignedp = info->type_stack->type.unsignedp;
5593 localp = info->type_stack->type.localp;
5594 ieee_pop_unused_type (info);
5595 return (ieee_define_type (info, size, unsignedp, localp)
5596 && ieee_write_number (info, 'R')
5597 && ieee_write_number (info, (bfd_vma) low)
5598 && ieee_write_number (info, (bfd_vma) high)
5599 && ieee_write_number (info, unsignedp ? 0 : 1)
5600 && ieee_write_number (info, size));
5603 /* Make an array type. */
5605 static bfd_boolean
5606 ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
5607 bfd_boolean stringp ATTRIBUTE_UNUSED)
5609 struct ieee_handle *info = (struct ieee_handle *) p;
5610 unsigned int eleindx;
5611 bfd_boolean localp;
5612 unsigned int size;
5613 struct ieee_modified_type *m = NULL;
5614 struct ieee_modified_array_type *a;
5616 /* IEEE does not store the range, so we just ignore it. */
5617 ieee_pop_unused_type (info);
5618 localp = info->type_stack->type.localp;
5619 size = info->type_stack->type.size;
5620 eleindx = ieee_pop_type (info);
5622 /* If we don't know the range, treat the size as exactly one
5623 element. */
5624 if (low < high)
5625 size *= (high - low) + 1;
5627 if (! localp)
5629 m = ieee_get_modified_info (info, eleindx);
5630 if (m == NULL)
5631 return FALSE;
5633 for (a = m->arrays; a != NULL; a = a->next)
5635 if (a->low == low && a->high == high)
5636 return ieee_push_type (info, a->indx, size, FALSE, FALSE);
5640 if (! ieee_define_type (info, size, FALSE, localp)
5641 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5642 || ! ieee_write_number (info, eleindx))
5643 return FALSE;
5644 if (low != 0)
5646 if (! ieee_write_number (info, low))
5647 return FALSE;
5650 if (! ieee_write_number (info, high + 1))
5651 return FALSE;
5653 if (! localp)
5655 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5656 memset (a, 0, sizeof *a);
5658 a->indx = info->type_stack->type.indx;
5659 a->low = low;
5660 a->high = high;
5662 a->next = m->arrays;
5663 m->arrays = a;
5666 return TRUE;
5669 /* Make a set type. */
5671 static bfd_boolean
5672 ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
5674 struct ieee_handle *info = (struct ieee_handle *) p;
5675 bfd_boolean localp;
5676 unsigned int eleindx;
5678 localp = info->type_stack->type.localp;
5679 eleindx = ieee_pop_type (info);
5681 /* FIXME: We don't know the size, so we just use 4. */
5683 return (ieee_define_type (info, 0, TRUE, localp)
5684 && ieee_write_number (info, 's')
5685 && ieee_write_number (info, 4)
5686 && ieee_write_number (info, eleindx));
5689 /* Make an offset type. */
5691 static bfd_boolean
5692 ieee_offset_type (void *p)
5694 /* FIXME: The MRI C++ compiler does not appear to generate any
5695 useful type information about an offset type. It just records a
5696 pointer to member as an integer. The MRI/HP IEEE spec does
5697 describe a pmisc record which can be used for a pointer to
5698 member. Unfortunately, it does not describe the target type,
5699 which seems pretty important. I'm going to punt this for now. */
5701 return ieee_int_type (p, 4, TRUE);
5704 /* Make a method type. */
5706 static bfd_boolean
5707 ieee_method_type (void *p, bfd_boolean domain, int argcount,
5708 bfd_boolean varargs)
5710 struct ieee_handle *info = (struct ieee_handle *) p;
5712 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5713 method, but the definition is incomplete. We just output an 'x'
5714 type. */
5716 if (domain)
5717 ieee_pop_unused_type (info);
5719 return ieee_function_type (p, argcount, varargs);
5722 /* Make a const qualified type. */
5724 static bfd_boolean
5725 ieee_const_type (void *p)
5727 struct ieee_handle *info = (struct ieee_handle *) p;
5728 unsigned int size;
5729 bfd_boolean unsignedp, localp;
5730 unsigned int indx;
5731 struct ieee_modified_type *m = NULL;
5733 size = info->type_stack->type.size;
5734 unsignedp = info->type_stack->type.unsignedp;
5735 localp = info->type_stack->type.localp;
5736 indx = ieee_pop_type (info);
5738 if (! localp)
5740 m = ieee_get_modified_info (info, indx);
5741 if (m == NULL)
5742 return FALSE;
5744 if (m->const_qualified > 0)
5745 return ieee_push_type (info, m->const_qualified, size, unsignedp,
5746 FALSE);
5749 if (! ieee_define_type (info, size, unsignedp, localp)
5750 || ! ieee_write_number (info, 'n')
5751 || ! ieee_write_number (info, 1)
5752 || ! ieee_write_number (info, indx))
5753 return FALSE;
5755 if (! localp)
5756 m->const_qualified = info->type_stack->type.indx;
5758 return TRUE;
5761 /* Make a volatile qualified type. */
5763 static bfd_boolean
5764 ieee_volatile_type (void *p)
5766 struct ieee_handle *info = (struct ieee_handle *) p;
5767 unsigned int size;
5768 bfd_boolean unsignedp, localp;
5769 unsigned int indx;
5770 struct ieee_modified_type *m = NULL;
5772 size = info->type_stack->type.size;
5773 unsignedp = info->type_stack->type.unsignedp;
5774 localp = info->type_stack->type.localp;
5775 indx = ieee_pop_type (info);
5777 if (! localp)
5779 m = ieee_get_modified_info (info, indx);
5780 if (m == NULL)
5781 return FALSE;
5783 if (m->volatile_qualified > 0)
5784 return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
5785 FALSE);
5788 if (! ieee_define_type (info, size, unsignedp, localp)
5789 || ! ieee_write_number (info, 'n')
5790 || ! ieee_write_number (info, 2)
5791 || ! ieee_write_number (info, indx))
5792 return FALSE;
5794 if (! localp)
5795 m->volatile_qualified = info->type_stack->type.indx;
5797 return TRUE;
5800 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5802 static unsigned int
5803 ieee_vis_to_flags (enum debug_visibility visibility)
5805 switch (visibility)
5807 default:
5808 abort ();
5809 case DEBUG_VISIBILITY_PUBLIC:
5810 return CXXFLAGS_VISIBILITY_PUBLIC;
5811 case DEBUG_VISIBILITY_PRIVATE:
5812 return CXXFLAGS_VISIBILITY_PRIVATE;
5813 case DEBUG_VISIBILITY_PROTECTED:
5814 return CXXFLAGS_VISIBILITY_PROTECTED;
5816 /*NOTREACHED*/
5819 /* Start defining a struct type. We build it in the strdef field on
5820 the stack, to avoid confusing type definitions required by the
5821 fields with the struct type itself. */
5823 static bfd_boolean
5824 ieee_start_struct_type (void *p, const char *tag, unsigned int id,
5825 bfd_boolean structp, unsigned int size)
5827 struct ieee_handle *info = (struct ieee_handle *) p;
5828 bfd_boolean localp, ignorep;
5829 bfd_boolean copy;
5830 char ab[20];
5831 const char *look;
5832 struct ieee_name_type_hash_entry *h;
5833 struct ieee_name_type *nt, *ntlook;
5834 struct ieee_buflist strdef;
5836 localp = FALSE;
5837 ignorep = FALSE;
5839 /* We need to create a tag for internal use even if we don't want
5840 one for external use. This will let us refer to an anonymous
5841 struct. */
5842 if (tag != NULL)
5844 look = tag;
5845 copy = FALSE;
5847 else
5849 sprintf (ab, "__anon%u", id);
5850 look = ab;
5851 copy = TRUE;
5854 /* If we already have references to the tag, we must use the
5855 existing type index. */
5856 h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy);
5857 if (h == NULL)
5858 return FALSE;
5860 nt = NULL;
5861 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
5863 if (ntlook->id == id)
5864 nt = ntlook;
5865 else if (! ntlook->type.localp)
5867 /* We are creating a duplicate definition of a globally
5868 defined tag. Force it to be local to avoid
5869 confusion. */
5870 localp = TRUE;
5874 if (nt != NULL)
5876 assert (localp == nt->type.localp);
5877 if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
5879 /* We've already seen a global definition of the type.
5880 Ignore this new definition. */
5881 ignorep = TRUE;
5884 else
5886 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5887 memset (nt, 0, sizeof *nt);
5888 nt->id = id;
5889 nt->type.name = h->root.string;
5890 nt->next = h->types;
5891 h->types = nt;
5892 nt->type.indx = info->type_indx;
5893 ++info->type_indx;
5896 nt->kind = DEBUG_KIND_ILLEGAL;
5898 if (! ieee_init_buffer (info, &strdef)
5899 || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE,
5900 localp, &strdef)
5901 || ! ieee_write_number (info, structp ? 'S' : 'U')
5902 || ! ieee_write_number (info, size))
5903 return FALSE;
5905 if (! ignorep)
5907 const char *hold;
5909 /* We never want nt->type.name to be NULL. We want the rest of
5910 the type to be the object set up on the type stack; it will
5911 have a NULL name if tag is NULL. */
5912 hold = nt->type.name;
5913 nt->type = info->type_stack->type;
5914 nt->type.name = hold;
5917 info->type_stack->type.name = tag;
5918 info->type_stack->type.strdef = strdef;
5919 info->type_stack->type.ignorep = ignorep;
5921 return TRUE;
5924 /* Add a field to a struct. */
5926 static bfd_boolean
5927 ieee_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
5928 enum debug_visibility visibility)
5930 struct ieee_handle *info = (struct ieee_handle *) p;
5931 unsigned int size;
5932 bfd_boolean unsignedp;
5933 bfd_boolean referencep;
5934 bfd_boolean localp;
5935 unsigned int indx;
5936 bfd_vma offset;
5938 assert (info->type_stack != NULL
5939 && info->type_stack->next != NULL
5940 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
5942 /* If we are ignoring this struct definition, just pop and ignore
5943 the type. */
5944 if (info->type_stack->next->type.ignorep)
5946 ieee_pop_unused_type (info);
5947 return TRUE;
5950 size = info->type_stack->type.size;
5951 unsignedp = info->type_stack->type.unsignedp;
5952 referencep = info->type_stack->type.referencep;
5953 localp = info->type_stack->type.localp;
5954 indx = ieee_pop_type (info);
5956 if (localp)
5957 info->type_stack->type.localp = TRUE;
5959 if (info->type_stack->type.classdef != NULL)
5961 unsigned int flags;
5962 unsigned int nindx;
5964 /* This is a class. We must add a description of this field to
5965 the class records we are building. */
5967 flags = ieee_vis_to_flags (visibility);
5968 nindx = info->type_stack->type.classdef->indx;
5969 if (! ieee_change_buffer (info,
5970 &info->type_stack->type.classdef->pmiscbuf)
5971 || ! ieee_write_asn (info, nindx, 'd')
5972 || ! ieee_write_asn (info, nindx, flags)
5973 || ! ieee_write_atn65 (info, nindx, name)
5974 || ! ieee_write_atn65 (info, nindx, name))
5975 return FALSE;
5976 info->type_stack->type.classdef->pmisccount += 4;
5978 if (referencep)
5980 /* We need to output a record recording that this field is
5981 really of reference type. We put this on the refs field
5982 of classdef, so that it can be appended to the C++
5983 records after the class is defined. */
5985 nindx = info->name_indx;
5986 ++info->name_indx;
5988 if (! ieee_change_buffer (info,
5989 &info->type_stack->type.classdef->refs)
5990 || ! ieee_write_byte (info, (int) ieee_nn_record)
5991 || ! ieee_write_number (info, nindx)
5992 || ! ieee_write_id (info, "")
5993 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5994 || ! ieee_write_number (info, nindx)
5995 || ! ieee_write_number (info, 0)
5996 || ! ieee_write_number (info, 62)
5997 || ! ieee_write_number (info, 80)
5998 || ! ieee_write_number (info, 4)
5999 || ! ieee_write_asn (info, nindx, 'R')
6000 || ! ieee_write_asn (info, nindx, 3)
6001 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
6002 || ! ieee_write_atn65 (info, nindx, name))
6003 return FALSE;
6007 /* If the bitsize doesn't match the expected size, we need to output
6008 a bitfield type. */
6009 if (size == 0 || bitsize == 0 || bitsize == size * 8)
6010 offset = bitpos / 8;
6011 else
6013 if (! ieee_define_type (info, 0, unsignedp,
6014 info->type_stack->type.localp)
6015 || ! ieee_write_number (info, 'g')
6016 || ! ieee_write_number (info, unsignedp ? 0 : 1)
6017 || ! ieee_write_number (info, bitsize)
6018 || ! ieee_write_number (info, indx))
6019 return FALSE;
6020 indx = ieee_pop_type (info);
6021 offset = bitpos;
6024 /* Switch to the struct we are building in order to output this
6025 field definition. */
6026 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
6027 && ieee_write_id (info, name)
6028 && ieee_write_number (info, indx)
6029 && ieee_write_number (info, offset));
6032 /* Finish up a struct type. */
6034 static bfd_boolean
6035 ieee_end_struct_type (void *p)
6037 struct ieee_handle *info = (struct ieee_handle *) p;
6038 struct ieee_buflist *pb;
6040 assert (info->type_stack != NULL
6041 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
6043 /* If we were ignoring this struct definition because it was a
6044 duplicate definition, just through away whatever bytes we have
6045 accumulated. Leave the type on the stack. */
6046 if (info->type_stack->type.ignorep)
6047 return TRUE;
6049 /* If this is not a duplicate definition of this tag, then localp
6050 will be FALSE, and we can put it in the global type block.
6051 FIXME: We should avoid outputting duplicate definitions which are
6052 the same. */
6053 if (! info->type_stack->type.localp)
6055 /* Make sure we have started the global type block. */
6056 if (ieee_buffer_emptyp (&info->global_types))
6058 if (! ieee_change_buffer (info, &info->global_types)
6059 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6060 || ! ieee_write_byte (info, 2)
6061 || ! ieee_write_number (info, 0)
6062 || ! ieee_write_id (info, ""))
6063 return FALSE;
6065 pb = &info->global_types;
6067 else
6069 /* Make sure we have started the types block. */
6070 if (ieee_buffer_emptyp (&info->types))
6072 if (! ieee_change_buffer (info, &info->types)
6073 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6074 || ! ieee_write_byte (info, 1)
6075 || ! ieee_write_number (info, 0)
6076 || ! ieee_write_id (info, info->modname))
6077 return FALSE;
6079 pb = &info->types;
6082 /* Append the struct definition to the types. */
6083 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6084 || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6085 return FALSE;
6087 /* Leave the struct on the type stack. */
6089 return TRUE;
6092 /* Start a class type. */
6094 static bfd_boolean
6095 ieee_start_class_type (void *p, const char *tag, unsigned int id,
6096 bfd_boolean structp, unsigned int size,
6097 bfd_boolean vptr, bfd_boolean ownvptr)
6099 struct ieee_handle *info = (struct ieee_handle *) p;
6100 const char *vclass;
6101 struct ieee_buflist pmiscbuf;
6102 unsigned int indx;
6103 struct ieee_type_class *classdef;
6105 /* A C++ class is output as a C++ struct along with a set of pmisc
6106 records describing the class. */
6108 /* We need to have a name so that we can associate the struct and
6109 the class. */
6110 if (tag == NULL)
6112 char *t;
6114 t = (char *) xmalloc (20);
6115 sprintf (t, "__anon%u", id);
6116 tag = t;
6119 /* We can't write out the virtual table information until we have
6120 finished the class, because we don't know the virtual table size.
6121 We get the size from the largest voffset we see. */
6122 vclass = NULL;
6123 if (vptr && ! ownvptr)
6125 vclass = info->type_stack->type.name;
6126 assert (vclass != NULL);
6127 /* We don't call ieee_pop_unused_type, since the class should
6128 get defined. */
6129 (void) ieee_pop_type (info);
6132 if (! ieee_start_struct_type (p, tag, id, structp, size))
6133 return FALSE;
6135 indx = info->name_indx;
6136 ++info->name_indx;
6138 /* We write out pmisc records into the classdef field. We will
6139 write out the pmisc start after we know the number of records we
6140 need. */
6141 if (! ieee_init_buffer (info, &pmiscbuf)
6142 || ! ieee_change_buffer (info, &pmiscbuf)
6143 || ! ieee_write_asn (info, indx, 'T')
6144 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6145 || ! ieee_write_atn65 (info, indx, tag))
6146 return FALSE;
6148 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6149 memset (classdef, 0, sizeof *classdef);
6151 classdef->indx = indx;
6152 classdef->pmiscbuf = pmiscbuf;
6153 classdef->pmisccount = 3;
6154 classdef->vclass = vclass;
6155 classdef->ownvptr = ownvptr;
6157 info->type_stack->type.classdef = classdef;
6159 return TRUE;
6162 /* Add a static member to a class. */
6164 static bfd_boolean
6165 ieee_class_static_member (void *p, const char *name, const char *physname,
6166 enum debug_visibility visibility)
6168 struct ieee_handle *info = (struct ieee_handle *) p;
6169 unsigned int flags;
6170 unsigned int nindx;
6172 /* We don't care about the type. Hopefully there will be a call to
6173 ieee_variable declaring the physical name and the type, since
6174 that is where an IEEE consumer must get the type. */
6175 ieee_pop_unused_type (info);
6177 assert (info->type_stack != NULL
6178 && info->type_stack->type.classdef != NULL);
6180 flags = ieee_vis_to_flags (visibility);
6181 flags |= CXXFLAGS_STATIC;
6183 nindx = info->type_stack->type.classdef->indx;
6185 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6186 || ! ieee_write_asn (info, nindx, 'd')
6187 || ! ieee_write_asn (info, nindx, flags)
6188 || ! ieee_write_atn65 (info, nindx, name)
6189 || ! ieee_write_atn65 (info, nindx, physname))
6190 return FALSE;
6191 info->type_stack->type.classdef->pmisccount += 4;
6193 return TRUE;
6196 /* Add a base class to a class. */
6198 static bfd_boolean
6199 ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
6200 enum debug_visibility visibility)
6202 struct ieee_handle *info = (struct ieee_handle *) p;
6203 const char *bname;
6204 bfd_boolean localp;
6205 unsigned int bindx;
6206 char *fname;
6207 unsigned int flags;
6208 unsigned int nindx;
6210 assert (info->type_stack != NULL
6211 && info->type_stack->type.name != NULL
6212 && info->type_stack->next != NULL
6213 && info->type_stack->next->type.classdef != NULL
6214 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6216 bname = info->type_stack->type.name;
6217 localp = info->type_stack->type.localp;
6218 bindx = ieee_pop_type (info);
6220 /* We are currently defining both a struct and a class. We must
6221 write out a field definition in the struct which holds the base
6222 class. The stabs debugging reader will create a field named
6223 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6224 we should not depend upon a detail of stabs debugging. */
6225 if (is_virtual)
6227 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6228 sprintf (fname, "_vb$%s", bname);
6229 flags = BASEFLAGS_VIRTUAL;
6231 else
6233 if (localp)
6234 info->type_stack->type.localp = TRUE;
6236 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6237 sprintf (fname, "_b$%s", bname);
6239 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6240 || ! ieee_write_id (info, fname)
6241 || ! ieee_write_number (info, bindx)
6242 || ! ieee_write_number (info, bitpos / 8))
6244 free (fname);
6245 return FALSE;
6247 flags = 0;
6250 if (visibility == DEBUG_VISIBILITY_PRIVATE)
6251 flags |= BASEFLAGS_PRIVATE;
6253 nindx = info->type_stack->type.classdef->indx;
6255 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6256 || ! ieee_write_asn (info, nindx, 'b')
6257 || ! ieee_write_asn (info, nindx, flags)
6258 || ! ieee_write_atn65 (info, nindx, bname)
6259 || ! ieee_write_asn (info, nindx, 0)
6260 || ! ieee_write_atn65 (info, nindx, fname))
6262 free (fname);
6263 return FALSE;
6265 info->type_stack->type.classdef->pmisccount += 5;
6267 free (fname);
6269 return TRUE;
6272 /* Start building a method for a class. */
6274 static bfd_boolean
6275 ieee_class_start_method (void *p, const char *name)
6277 struct ieee_handle *info = (struct ieee_handle *) p;
6279 assert (info->type_stack != NULL
6280 && info->type_stack->type.classdef != NULL
6281 && info->type_stack->type.classdef->method == NULL);
6283 info->type_stack->type.classdef->method = name;
6285 return TRUE;
6288 /* Define a new method variant, either static or not. */
6290 static bfd_boolean
6291 ieee_class_method_var (struct ieee_handle *info, const char *physname,
6292 enum debug_visibility visibility,
6293 bfd_boolean staticp, bfd_boolean constp,
6294 bfd_boolean volatilep, bfd_vma voffset,
6295 bfd_boolean context)
6297 unsigned int flags;
6298 unsigned int nindx;
6299 bfd_boolean is_virtual;
6301 /* We don't need the type of the method. An IEEE consumer which
6302 wants the type must track down the function by the physical name
6303 and get the type from that. */
6304 ieee_pop_unused_type (info);
6306 /* We don't use the context. FIXME: We probably ought to use it to
6307 adjust the voffset somehow, but I don't really know how. */
6308 if (context)
6309 ieee_pop_unused_type (info);
6311 assert (info->type_stack != NULL
6312 && info->type_stack->type.classdef != NULL
6313 && info->type_stack->type.classdef->method != NULL);
6315 flags = ieee_vis_to_flags (visibility);
6317 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6318 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6320 if (staticp)
6321 flags |= CXXFLAGS_STATIC;
6322 if (constp)
6323 flags |= CXXFLAGS_CONST;
6324 if (volatilep)
6325 flags |= CXXFLAGS_VOLATILE;
6327 nindx = info->type_stack->type.classdef->indx;
6329 is_virtual = context || voffset > 0;
6331 if (! ieee_change_buffer (info,
6332 &info->type_stack->type.classdef->pmiscbuf)
6333 || ! ieee_write_asn (info, nindx, is_virtual ? 'v' : 'm')
6334 || ! ieee_write_asn (info, nindx, flags)
6335 || ! ieee_write_atn65 (info, nindx,
6336 info->type_stack->type.classdef->method)
6337 || ! ieee_write_atn65 (info, nindx, physname))
6338 return FALSE;
6340 if (is_virtual)
6342 if (voffset > info->type_stack->type.classdef->voffset)
6343 info->type_stack->type.classdef->voffset = voffset;
6344 if (! ieee_write_asn (info, nindx, voffset))
6345 return FALSE;
6346 ++info->type_stack->type.classdef->pmisccount;
6349 if (! ieee_write_asn (info, nindx, 0))
6350 return FALSE;
6352 info->type_stack->type.classdef->pmisccount += 5;
6354 return TRUE;
6357 /* Define a new method variant. */
6359 static bfd_boolean
6360 ieee_class_method_variant (void *p, const char *physname,
6361 enum debug_visibility visibility,
6362 bfd_boolean constp, bfd_boolean volatilep,
6363 bfd_vma voffset, bfd_boolean context)
6365 struct ieee_handle *info = (struct ieee_handle *) p;
6367 return ieee_class_method_var (info, physname, visibility, FALSE, constp,
6368 volatilep, voffset, context);
6371 /* Define a new static method variant. */
6373 static bfd_boolean
6374 ieee_class_static_method_variant (void *p, const char *physname,
6375 enum debug_visibility visibility,
6376 bfd_boolean constp, bfd_boolean volatilep)
6378 struct ieee_handle *info = (struct ieee_handle *) p;
6380 return ieee_class_method_var (info, physname, visibility, TRUE, constp,
6381 volatilep, 0, FALSE);
6384 /* Finish up a method. */
6386 static bfd_boolean
6387 ieee_class_end_method (void *p)
6389 struct ieee_handle *info = (struct ieee_handle *) p;
6391 assert (info->type_stack != NULL
6392 && info->type_stack->type.classdef != NULL
6393 && info->type_stack->type.classdef->method != NULL);
6395 info->type_stack->type.classdef->method = NULL;
6397 return TRUE;
6400 /* Finish up a class. */
6402 static bfd_boolean
6403 ieee_end_class_type (void *p)
6405 struct ieee_handle *info = (struct ieee_handle *) p;
6406 unsigned int nindx;
6408 assert (info->type_stack != NULL
6409 && info->type_stack->type.classdef != NULL);
6411 /* If we were ignoring this class definition because it was a
6412 duplicate definition, just through away whatever bytes we have
6413 accumulated. Leave the type on the stack. */
6414 if (info->type_stack->type.ignorep)
6415 return TRUE;
6417 nindx = info->type_stack->type.classdef->indx;
6419 /* If we have a virtual table, we can write out the information now. */
6420 if (info->type_stack->type.classdef->vclass != NULL
6421 || info->type_stack->type.classdef->ownvptr)
6423 if (! ieee_change_buffer (info,
6424 &info->type_stack->type.classdef->pmiscbuf)
6425 || ! ieee_write_asn (info, nindx, 'z')
6426 || ! ieee_write_atn65 (info, nindx, "")
6427 || ! ieee_write_asn (info, nindx,
6428 info->type_stack->type.classdef->voffset))
6429 return FALSE;
6430 if (info->type_stack->type.classdef->ownvptr)
6432 if (! ieee_write_atn65 (info, nindx, ""))
6433 return FALSE;
6435 else
6437 if (! ieee_write_atn65 (info, nindx,
6438 info->type_stack->type.classdef->vclass))
6439 return FALSE;
6441 if (! ieee_write_asn (info, nindx, 0))
6442 return FALSE;
6443 info->type_stack->type.classdef->pmisccount += 5;
6446 /* Now that we know the number of pmisc records, we can write out
6447 the atn62 which starts the pmisc records, and append them to the
6448 C++ buffers. */
6450 if (! ieee_change_buffer (info, &info->cxx)
6451 || ! ieee_write_byte (info, (int) ieee_nn_record)
6452 || ! ieee_write_number (info, nindx)
6453 || ! ieee_write_id (info, "")
6454 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6455 || ! ieee_write_number (info, nindx)
6456 || ! ieee_write_number (info, 0)
6457 || ! ieee_write_number (info, 62)
6458 || ! ieee_write_number (info, 80)
6459 || ! ieee_write_number (info,
6460 info->type_stack->type.classdef->pmisccount))
6461 return FALSE;
6463 if (! ieee_append_buffer (info, &info->cxx,
6464 &info->type_stack->type.classdef->pmiscbuf))
6465 return FALSE;
6466 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6468 if (! ieee_append_buffer (info, &info->cxx,
6469 &info->type_stack->type.classdef->refs))
6470 return FALSE;
6473 return ieee_end_struct_type (p);
6476 /* Push a previously seen typedef onto the type stack. */
6478 static bfd_boolean
6479 ieee_typedef_type (void *p, const char *name)
6481 struct ieee_handle *info = (struct ieee_handle *) p;
6482 struct ieee_name_type_hash_entry *h;
6483 struct ieee_name_type *nt;
6485 h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);
6487 /* h should never be NULL, since that would imply that the generic
6488 debugging code has asked for a typedef which it has not yet
6489 defined. */
6490 assert (h != NULL);
6492 /* We always use the most recently defined type for this name, which
6493 will be the first one on the list. */
6495 nt = h->types;
6496 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6497 nt->type.unsignedp, nt->type.localp))
6498 return FALSE;
6500 /* Copy over any other type information we may have. */
6501 info->type_stack->type = nt->type;
6503 return TRUE;
6506 /* Push a tagged type onto the type stack. */
6508 static bfd_boolean
6509 ieee_tag_type (void *p, const char *name, unsigned int id,
6510 enum debug_type_kind kind)
6512 struct ieee_handle *info = (struct ieee_handle *) p;
6513 bfd_boolean localp;
6514 bfd_boolean copy;
6515 char ab[20];
6516 struct ieee_name_type_hash_entry *h;
6517 struct ieee_name_type *nt;
6519 if (kind == DEBUG_KIND_ENUM)
6521 struct ieee_defined_enum *e;
6523 if (name == NULL)
6524 abort ();
6525 for (e = info->enums; e != NULL; e = e->next)
6526 if (e->tag != NULL && strcmp (e->tag, name) == 0)
6527 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6529 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
6530 memset (e, 0, sizeof *e);
6532 e->indx = info->type_indx;
6533 ++info->type_indx;
6534 e->tag = name;
6535 e->defined = FALSE;
6537 e->next = info->enums;
6538 info->enums = e;
6540 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6543 localp = FALSE;
6545 copy = FALSE;
6546 if (name == NULL)
6548 sprintf (ab, "__anon%u", id);
6549 name = ab;
6550 copy = TRUE;
6553 h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
6554 if (h == NULL)
6555 return FALSE;
6557 for (nt = h->types; nt != NULL; nt = nt->next)
6559 if (nt->id == id)
6561 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6562 nt->type.unsignedp, nt->type.localp))
6563 return FALSE;
6564 /* Copy over any other type information we may have. */
6565 info->type_stack->type = nt->type;
6566 return TRUE;
6569 if (! nt->type.localp)
6571 /* This is a duplicate of a global type, so it must be
6572 local. */
6573 localp = TRUE;
6577 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6578 memset (nt, 0, sizeof *nt);
6580 nt->id = id;
6581 nt->type.name = h->root.string;
6582 nt->type.indx = info->type_indx;
6583 nt->type.localp = localp;
6584 ++info->type_indx;
6585 nt->kind = kind;
6587 nt->next = h->types;
6588 h->types = nt;
6590 if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
6591 return FALSE;
6593 info->type_stack->type.name = h->root.string;
6595 return TRUE;
6598 /* Output a typedef. */
6600 static bfd_boolean
6601 ieee_typdef (void *p, const char *name)
6603 struct ieee_handle *info = (struct ieee_handle *) p;
6604 struct ieee_write_type type;
6605 unsigned int indx;
6606 bfd_boolean found;
6607 bfd_boolean localp;
6608 struct ieee_name_type_hash_entry *h;
6609 struct ieee_name_type *nt;
6611 type = info->type_stack->type;
6612 indx = type.indx;
6614 /* If this is a simple builtin type using a builtin name, we don't
6615 want to output the typedef itself. We also want to change the
6616 type index to correspond to the name being used. We recognize
6617 names used in stabs debugging output even if they don't exactly
6618 correspond to the names used for the IEEE builtin types. */
6619 found = FALSE;
6620 if (indx <= (unsigned int) builtin_bcd_float)
6622 switch ((enum builtin_types) indx)
6624 default:
6625 break;
6627 case builtin_void:
6628 if (strcmp (name, "void") == 0)
6629 found = TRUE;
6630 break;
6632 case builtin_signed_char:
6633 case builtin_char:
6634 if (strcmp (name, "signed char") == 0)
6636 indx = (unsigned int) builtin_signed_char;
6637 found = TRUE;
6639 else if (strcmp (name, "char") == 0)
6641 indx = (unsigned int) builtin_char;
6642 found = TRUE;
6644 break;
6646 case builtin_unsigned_char:
6647 if (strcmp (name, "unsigned char") == 0)
6648 found = TRUE;
6649 break;
6651 case builtin_signed_short_int:
6652 case builtin_short:
6653 case builtin_short_int:
6654 case builtin_signed_short:
6655 if (strcmp (name, "signed short int") == 0)
6657 indx = (unsigned int) builtin_signed_short_int;
6658 found = TRUE;
6660 else if (strcmp (name, "short") == 0)
6662 indx = (unsigned int) builtin_short;
6663 found = TRUE;
6665 else if (strcmp (name, "short int") == 0)
6667 indx = (unsigned int) builtin_short_int;
6668 found = TRUE;
6670 else if (strcmp (name, "signed short") == 0)
6672 indx = (unsigned int) builtin_signed_short;
6673 found = TRUE;
6675 break;
6677 case builtin_unsigned_short_int:
6678 case builtin_unsigned_short:
6679 if (strcmp (name, "unsigned short int") == 0
6680 || strcmp (name, "short unsigned int") == 0)
6682 indx = builtin_unsigned_short_int;
6683 found = TRUE;
6685 else if (strcmp (name, "unsigned short") == 0)
6687 indx = builtin_unsigned_short;
6688 found = TRUE;
6690 break;
6692 case builtin_signed_long:
6693 case builtin_int: /* FIXME: Size depends upon architecture. */
6694 case builtin_long:
6695 if (strcmp (name, "signed long") == 0)
6697 indx = builtin_signed_long;
6698 found = TRUE;
6700 else if (strcmp (name, "int") == 0)
6702 indx = builtin_int;
6703 found = TRUE;
6705 else if (strcmp (name, "long") == 0
6706 || strcmp (name, "long int") == 0)
6708 indx = builtin_long;
6709 found = TRUE;
6711 break;
6713 case builtin_unsigned_long:
6714 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
6715 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
6716 if (strcmp (name, "unsigned long") == 0
6717 || strcmp (name, "long unsigned int") == 0)
6719 indx = builtin_unsigned_long;
6720 found = TRUE;
6722 else if (strcmp (name, "unsigned") == 0)
6724 indx = builtin_unsigned;
6725 found = TRUE;
6727 else if (strcmp (name, "unsigned int") == 0)
6729 indx = builtin_unsigned_int;
6730 found = TRUE;
6732 break;
6734 case builtin_signed_long_long:
6735 if (strcmp (name, "signed long long") == 0
6736 || strcmp (name, "long long int") == 0)
6737 found = TRUE;
6738 break;
6740 case builtin_unsigned_long_long:
6741 if (strcmp (name, "unsigned long long") == 0
6742 || strcmp (name, "long long unsigned int") == 0)
6743 found = TRUE;
6744 break;
6746 case builtin_float:
6747 if (strcmp (name, "float") == 0)
6748 found = TRUE;
6749 break;
6751 case builtin_double:
6752 if (strcmp (name, "double") == 0)
6753 found = TRUE;
6754 break;
6756 case builtin_long_double:
6757 if (strcmp (name, "long double") == 0)
6758 found = TRUE;
6759 break;
6761 case builtin_long_long_double:
6762 if (strcmp (name, "long long double") == 0)
6763 found = TRUE;
6764 break;
6767 if (found)
6768 type.indx = indx;
6771 h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
6772 if (h == NULL)
6773 return FALSE;
6775 /* See if we have already defined this type with this name. */
6776 localp = type.localp;
6777 for (nt = h->types; nt != NULL; nt = nt->next)
6779 if (nt->id == indx)
6781 /* If this is a global definition, then we don't need to
6782 do anything here. */
6783 if (! nt->type.localp)
6785 ieee_pop_unused_type (info);
6786 return TRUE;
6789 else
6791 /* This is a duplicate definition, so make this one local. */
6792 localp = TRUE;
6796 /* We need to add a new typedef for this type. */
6798 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6799 memset (nt, 0, sizeof *nt);
6800 nt->id = indx;
6801 nt->type = type;
6802 nt->type.name = name;
6803 nt->type.localp = localp;
6804 nt->kind = DEBUG_KIND_ILLEGAL;
6806 nt->next = h->types;
6807 h->types = nt;
6809 if (found)
6811 /* This is one of the builtin typedefs, so we don't need to
6812 actually define it. */
6813 ieee_pop_unused_type (info);
6814 return TRUE;
6817 indx = ieee_pop_type (info);
6819 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
6820 type.unsignedp, localp,
6821 (struct ieee_buflist *) NULL)
6822 || ! ieee_write_number (info, 'T')
6823 || ! ieee_write_number (info, indx))
6824 return FALSE;
6826 /* Remove the type we just added to the type stack. This should not
6827 be ieee_pop_unused_type, since the type is used, we just don't
6828 need it now. */
6829 (void) ieee_pop_type (info);
6831 return TRUE;
6834 /* Output a tag for a type. We don't have to do anything here. */
6836 static bfd_boolean
6837 ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED)
6839 struct ieee_handle *info = (struct ieee_handle *) p;
6841 /* This should not be ieee_pop_unused_type, since we want the type
6842 to be defined. */
6843 (void) ieee_pop_type (info);
6844 return TRUE;
6847 /* Output an integer constant. */
6849 static bfd_boolean
6850 ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED,
6851 bfd_vma val ATTRIBUTE_UNUSED)
6853 /* FIXME. */
6854 return TRUE;
6857 /* Output a floating point constant. */
6859 static bfd_boolean
6860 ieee_float_constant (void *p ATTRIBUTE_UNUSED,
6861 const char *name ATTRIBUTE_UNUSED,
6862 double val ATTRIBUTE_UNUSED)
6864 /* FIXME. */
6865 return TRUE;
6868 /* Output a typed constant. */
6870 static bfd_boolean
6871 ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED,
6872 bfd_vma val ATTRIBUTE_UNUSED)
6874 struct ieee_handle *info = (struct ieee_handle *) p;
6876 /* FIXME. */
6877 ieee_pop_unused_type (info);
6878 return TRUE;
6881 /* Output a variable. */
6883 static bfd_boolean
6884 ieee_variable (void *p, const char *name, enum debug_var_kind kind,
6885 bfd_vma val)
6887 struct ieee_handle *info = (struct ieee_handle *) p;
6888 unsigned int name_indx;
6889 unsigned int size;
6890 bfd_boolean referencep;
6891 unsigned int type_indx;
6892 bfd_boolean asn;
6893 int refflag;
6895 size = info->type_stack->type.size;
6896 referencep = info->type_stack->type.referencep;
6897 type_indx = ieee_pop_type (info);
6899 assert (! ieee_buffer_emptyp (&info->vars));
6900 if (! ieee_change_buffer (info, &info->vars))
6901 return FALSE;
6903 name_indx = info->name_indx;
6904 ++info->name_indx;
6906 /* Write out an NN and an ATN record for this variable. */
6907 if (! ieee_write_byte (info, (int) ieee_nn_record)
6908 || ! ieee_write_number (info, name_indx)
6909 || ! ieee_write_id (info, name)
6910 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6911 || ! ieee_write_number (info, name_indx)
6912 || ! ieee_write_number (info, type_indx))
6913 return FALSE;
6914 switch (kind)
6916 default:
6917 abort ();
6918 return FALSE;
6919 case DEBUG_GLOBAL:
6920 if (! ieee_write_number (info, 8)
6921 || ! ieee_add_range (info, FALSE, val, val + size))
6922 return FALSE;
6923 refflag = 0;
6924 asn = TRUE;
6925 break;
6926 case DEBUG_STATIC:
6927 if (! ieee_write_number (info, 3)
6928 || ! ieee_add_range (info, FALSE, val, val + size))
6929 return FALSE;
6930 refflag = 1;
6931 asn = TRUE;
6932 break;
6933 case DEBUG_LOCAL_STATIC:
6934 if (! ieee_write_number (info, 3)
6935 || ! ieee_add_range (info, FALSE, val, val + size))
6936 return FALSE;
6937 refflag = 2;
6938 asn = TRUE;
6939 break;
6940 case DEBUG_LOCAL:
6941 if (! ieee_write_number (info, 1)
6942 || ! ieee_write_number (info, val))
6943 return FALSE;
6944 refflag = 2;
6945 asn = FALSE;
6946 break;
6947 case DEBUG_REGISTER:
6948 if (! ieee_write_number (info, 2)
6949 || ! ieee_write_number (info,
6950 ieee_genreg_to_regno (info->abfd, val)))
6951 return FALSE;
6952 refflag = 2;
6953 asn = FALSE;
6954 break;
6957 if (asn)
6959 if (! ieee_write_asn (info, name_indx, val))
6960 return FALSE;
6963 /* If this is really a reference type, then we just output it with
6964 pointer type, and must now output a C++ record indicating that it
6965 is really reference type. */
6966 if (referencep)
6968 unsigned int nindx;
6970 nindx = info->name_indx;
6971 ++info->name_indx;
6973 /* If this is a global variable, we want to output the misc
6974 record in the C++ misc record block. Otherwise, we want to
6975 output it just after the variable definition, which is where
6976 the current buffer is. */
6977 if (refflag != 2)
6979 if (! ieee_change_buffer (info, &info->cxx))
6980 return FALSE;
6983 if (! ieee_write_byte (info, (int) ieee_nn_record)
6984 || ! ieee_write_number (info, nindx)
6985 || ! ieee_write_id (info, "")
6986 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6987 || ! ieee_write_number (info, nindx)
6988 || ! ieee_write_number (info, 0)
6989 || ! ieee_write_number (info, 62)
6990 || ! ieee_write_number (info, 80)
6991 || ! ieee_write_number (info, 3)
6992 || ! ieee_write_asn (info, nindx, 'R')
6993 || ! ieee_write_asn (info, nindx, refflag)
6994 || ! ieee_write_atn65 (info, nindx, name))
6995 return FALSE;
6998 return TRUE;
7001 /* Start outputting information for a function. */
7003 static bfd_boolean
7004 ieee_start_function (void *p, const char *name, bfd_boolean global)
7006 struct ieee_handle *info = (struct ieee_handle *) p;
7007 bfd_boolean referencep;
7008 unsigned int retindx, typeindx;
7010 referencep = info->type_stack->type.referencep;
7011 retindx = ieee_pop_type (info);
7013 /* Besides recording a BB4 or BB6 block, we record the type of the
7014 function in the BB1 typedef block. We can't write out the full
7015 type until we have seen all the parameters, so we accumulate it
7016 in info->fntype and info->fnargs. */
7017 if (! ieee_buffer_emptyp (&info->fntype))
7019 /* FIXME: This might happen someday if we support nested
7020 functions. */
7021 abort ();
7024 info->fnname = name;
7026 /* An attribute of 0x40 means that the push mask is unknown. */
7027 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
7028 &info->fntype)
7029 || ! ieee_write_number (info, 'x')
7030 || ! ieee_write_number (info, 0x40)
7031 || ! ieee_write_number (info, 0)
7032 || ! ieee_write_number (info, 0)
7033 || ! ieee_write_number (info, retindx))
7034 return FALSE;
7036 typeindx = ieee_pop_type (info);
7038 if (! ieee_init_buffer (info, &info->fnargs))
7039 return FALSE;
7040 info->fnargcount = 0;
7042 /* If the function return value is actually a reference type, we
7043 must add a record indicating that. */
7044 if (referencep)
7046 unsigned int nindx;
7048 nindx = info->name_indx;
7049 ++info->name_indx;
7050 if (! ieee_change_buffer (info, &info->cxx)
7051 || ! ieee_write_byte (info, (int) ieee_nn_record)
7052 || ! ieee_write_number (info, nindx)
7053 || ! ieee_write_id (info, "")
7054 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7055 || ! ieee_write_number (info, nindx)
7056 || ! ieee_write_number (info, 0)
7057 || ! ieee_write_number (info, 62)
7058 || ! ieee_write_number (info, 80)
7059 || ! ieee_write_number (info, 3)
7060 || ! ieee_write_asn (info, nindx, 'R')
7061 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7062 || ! ieee_write_atn65 (info, nindx, name))
7063 return FALSE;
7066 assert (! ieee_buffer_emptyp (&info->vars));
7067 if (! ieee_change_buffer (info, &info->vars))
7068 return FALSE;
7070 /* The address is written out as the first block. */
7072 ++info->block_depth;
7074 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7075 && ieee_write_byte (info, global ? 4 : 6)
7076 && ieee_write_number (info, 0)
7077 && ieee_write_id (info, name)
7078 && ieee_write_number (info, 0)
7079 && ieee_write_number (info, typeindx));
7082 /* Add a function parameter. This will normally be called before the
7083 first block, so we postpone them until we see the block. */
7085 static bfd_boolean
7086 ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
7087 bfd_vma val)
7089 struct ieee_handle *info = (struct ieee_handle *) p;
7090 struct ieee_pending_parm *m, **pm;
7092 assert (info->block_depth == 1);
7094 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7095 memset (m, 0, sizeof *m);
7097 m->next = NULL;
7098 m->name = name;
7099 m->referencep = info->type_stack->type.referencep;
7100 m->type = ieee_pop_type (info);
7101 m->kind = kind;
7102 m->val = val;
7104 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7106 *pm = m;
7108 /* Add the type to the fnargs list. */
7109 if (! ieee_change_buffer (info, &info->fnargs)
7110 || ! ieee_write_number (info, m->type))
7111 return FALSE;
7112 ++info->fnargcount;
7114 return TRUE;
7117 /* Output pending function parameters. */
7119 static bfd_boolean
7120 ieee_output_pending_parms (struct ieee_handle *info)
7122 struct ieee_pending_parm *m;
7123 unsigned int refcount;
7125 refcount = 0;
7126 for (m = info->pending_parms; m != NULL; m = m->next)
7128 enum debug_var_kind vkind;
7130 switch (m->kind)
7132 default:
7133 abort ();
7134 return FALSE;
7135 case DEBUG_PARM_STACK:
7136 case DEBUG_PARM_REFERENCE:
7137 vkind = DEBUG_LOCAL;
7138 break;
7139 case DEBUG_PARM_REG:
7140 case DEBUG_PARM_REF_REG:
7141 vkind = DEBUG_REGISTER;
7142 break;
7145 if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
7146 return FALSE;
7147 info->type_stack->type.referencep = m->referencep;
7148 if (m->referencep)
7149 ++refcount;
7150 if (! ieee_variable ((void *) info, m->name, vkind, m->val))
7151 return FALSE;
7154 /* If there are any reference parameters, we need to output a
7155 miscellaneous record indicating them. */
7156 if (refcount > 0)
7158 unsigned int nindx, varindx;
7160 /* FIXME: The MRI compiler outputs the demangled function name
7161 here, but we are outputting the mangled name. */
7162 nindx = info->name_indx;
7163 ++info->name_indx;
7164 if (! ieee_change_buffer (info, &info->vars)
7165 || ! ieee_write_byte (info, (int) ieee_nn_record)
7166 || ! ieee_write_number (info, nindx)
7167 || ! ieee_write_id (info, "")
7168 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7169 || ! ieee_write_number (info, nindx)
7170 || ! ieee_write_number (info, 0)
7171 || ! ieee_write_number (info, 62)
7172 || ! ieee_write_number (info, 80)
7173 || ! ieee_write_number (info, refcount + 3)
7174 || ! ieee_write_asn (info, nindx, 'B')
7175 || ! ieee_write_atn65 (info, nindx, info->fnname)
7176 || ! ieee_write_asn (info, nindx, 0))
7177 return FALSE;
7178 for (m = info->pending_parms, varindx = 1;
7179 m != NULL;
7180 m = m->next, varindx++)
7182 if (m->referencep)
7184 if (! ieee_write_asn (info, nindx, varindx))
7185 return FALSE;
7190 m = info->pending_parms;
7191 while (m != NULL)
7193 struct ieee_pending_parm *next;
7195 next = m->next;
7196 free (m);
7197 m = next;
7200 info->pending_parms = NULL;
7202 return TRUE;
7205 /* Start a block. If this is the first block, we output the address
7206 to finish the BB4 or BB6, and then output the function parameters. */
7208 static bfd_boolean
7209 ieee_start_block (void *p, bfd_vma addr)
7211 struct ieee_handle *info = (struct ieee_handle *) p;
7213 if (! ieee_change_buffer (info, &info->vars))
7214 return FALSE;
7216 if (info->block_depth == 1)
7218 if (! ieee_write_number (info, addr)
7219 || ! ieee_output_pending_parms (info))
7220 return FALSE;
7222 else
7224 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7225 || ! ieee_write_byte (info, 6)
7226 || ! ieee_write_number (info, 0)
7227 || ! ieee_write_id (info, "")
7228 || ! ieee_write_number (info, 0)
7229 || ! ieee_write_number (info, 0)
7230 || ! ieee_write_number (info, addr))
7231 return FALSE;
7234 if (! ieee_start_range (info, addr))
7235 return FALSE;
7237 ++info->block_depth;
7239 return TRUE;
7242 /* End a block. */
7244 static bfd_boolean
7245 ieee_end_block (void *p, bfd_vma addr)
7247 struct ieee_handle *info = (struct ieee_handle *) p;
7249 /* The address we are given is the end of the block, but IEEE seems
7250 to want to the address of the last byte in the block, so we
7251 subtract one. */
7252 if (! ieee_change_buffer (info, &info->vars)
7253 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7254 || ! ieee_write_number (info, addr - 1))
7255 return FALSE;
7257 if (! ieee_end_range (info, addr))
7258 return FALSE;
7260 --info->block_depth;
7262 if (addr > info->highaddr)
7263 info->highaddr = addr;
7265 return TRUE;
7268 /* End a function. */
7270 static bfd_boolean
7271 ieee_end_function (void *p)
7273 struct ieee_handle *info = (struct ieee_handle *) p;
7275 assert (info->block_depth == 1);
7277 --info->block_depth;
7279 /* Now we can finish up fntype, and add it to the typdef section.
7280 At this point, fntype is the 'x' type up to the argument count,
7281 and fnargs is the argument types. We must add the argument
7282 count, and we must add the level. FIXME: We don't record varargs
7283 functions correctly. In fact, stabs debugging does not give us
7284 enough information to do so. */
7285 if (! ieee_change_buffer (info, &info->fntype)
7286 || ! ieee_write_number (info, info->fnargcount)
7287 || ! ieee_change_buffer (info, &info->fnargs)
7288 || ! ieee_write_number (info, 0))
7289 return FALSE;
7291 /* Make sure the typdef block has been started. */
7292 if (ieee_buffer_emptyp (&info->types))
7294 if (! ieee_change_buffer (info, &info->types)
7295 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7296 || ! ieee_write_byte (info, 1)
7297 || ! ieee_write_number (info, 0)
7298 || ! ieee_write_id (info, info->modname))
7299 return FALSE;
7302 if (! ieee_append_buffer (info, &info->types, &info->fntype)
7303 || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7304 return FALSE;
7306 info->fnname = NULL;
7307 if (! ieee_init_buffer (info, &info->fntype)
7308 || ! ieee_init_buffer (info, &info->fnargs))
7309 return FALSE;
7310 info->fnargcount = 0;
7312 return TRUE;
7315 /* Record line number information. */
7317 static bfd_boolean
7318 ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
7320 struct ieee_handle *info = (struct ieee_handle *) p;
7322 assert (info->filename != NULL);
7324 /* The HP simulator seems to get confused when more than one line is
7325 listed for the same address, at least if they are in different
7326 files. We handle this by always listing the last line for a
7327 given address, since that seems to be the one that gdb uses. */
7328 if (info->pending_lineno_filename != NULL
7329 && addr != info->pending_lineno_addr)
7331 /* Make sure we have a line number block. */
7332 if (! ieee_buffer_emptyp (&info->linenos))
7334 if (! ieee_change_buffer (info, &info->linenos))
7335 return FALSE;
7337 else
7339 info->lineno_name_indx = info->name_indx;
7340 ++info->name_indx;
7341 if (! ieee_change_buffer (info, &info->linenos)
7342 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7343 || ! ieee_write_byte (info, 5)
7344 || ! ieee_write_number (info, 0)
7345 || ! ieee_write_id (info, info->filename)
7346 || ! ieee_write_byte (info, (int) ieee_nn_record)
7347 || ! ieee_write_number (info, info->lineno_name_indx)
7348 || ! ieee_write_id (info, ""))
7349 return FALSE;
7350 info->lineno_filename = info->filename;
7353 if (filename_cmp (info->pending_lineno_filename,
7354 info->lineno_filename) != 0)
7356 if (filename_cmp (info->filename, info->lineno_filename) != 0)
7358 /* We were not in the main file. Close the block for the
7359 included file. */
7360 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7361 return FALSE;
7362 if (filename_cmp (info->filename,
7363 info->pending_lineno_filename) == 0)
7365 /* We need a new NN record, and we aren't about to
7366 output one. */
7367 info->lineno_name_indx = info->name_indx;
7368 ++info->name_indx;
7369 if (! ieee_write_byte (info, (int) ieee_nn_record)
7370 || ! ieee_write_number (info, info->lineno_name_indx)
7371 || ! ieee_write_id (info, ""))
7372 return FALSE;
7375 if (filename_cmp (info->filename,
7376 info->pending_lineno_filename) != 0)
7378 /* We are not changing to the main file. Open a block for
7379 the new included file. */
7380 info->lineno_name_indx = info->name_indx;
7381 ++info->name_indx;
7382 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7383 || ! ieee_write_byte (info, 5)
7384 || ! ieee_write_number (info, 0)
7385 || ! ieee_write_id (info, info->pending_lineno_filename)
7386 || ! ieee_write_byte (info, (int) ieee_nn_record)
7387 || ! ieee_write_number (info, info->lineno_name_indx)
7388 || ! ieee_write_id (info, ""))
7389 return FALSE;
7391 info->lineno_filename = info->pending_lineno_filename;
7394 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7395 || ! ieee_write_number (info, info->lineno_name_indx)
7396 || ! ieee_write_number (info, 0)
7397 || ! ieee_write_number (info, 7)
7398 || ! ieee_write_number (info, info->pending_lineno)
7399 || ! ieee_write_number (info, 0)
7400 || ! ieee_write_asn (info, info->lineno_name_indx,
7401 info->pending_lineno_addr))
7402 return FALSE;
7405 info->pending_lineno_filename = filename;
7406 info->pending_lineno = lineno;
7407 info->pending_lineno_addr = addr;
7409 return TRUE;