daily update
[binutils.git] / binutils / ieee.c
blob34b937342e0ee4b8d6ee8dd1c2d0daf9af90ddcb
1 /* ieee.c -- Read and write IEEE-695 debugging information.
2 Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* This file reads and writes IEEE-695 debugging information. */
25 #include "sysdep.h"
26 #include <assert.h>
27 #include "bfd.h"
28 #include "ieee.h"
29 #include "libiberty.h"
30 #include "debug.h"
31 #include "budbg.h"
32 #include "filenames.h"
34 /* This structure holds an entry on the block stack. */
36 struct ieee_block
38 /* The kind of block. */
39 int kind;
40 /* The source file name, for a BB5 block. */
41 const char *filename;
42 /* The index of the function type, for a BB4 or BB6 block. */
43 unsigned int fnindx;
44 /* TRUE if this function is being skipped. */
45 bfd_boolean skip;
48 /* This structure is the block stack. */
50 #define BLOCKSTACK_SIZE (16)
52 struct ieee_blockstack
54 /* The stack pointer. */
55 struct ieee_block *bsp;
56 /* The stack. */
57 struct ieee_block stack[BLOCKSTACK_SIZE];
60 /* This structure holds information for a variable. */
62 enum ieee_var_kind
64 IEEE_UNKNOWN,
65 IEEE_EXTERNAL,
66 IEEE_GLOBAL,
67 IEEE_STATIC,
68 IEEE_LOCAL,
69 IEEE_FUNCTION
72 struct ieee_var
74 /* Start of name. */
75 const char *name;
76 /* Length of name. */
77 unsigned long namlen;
78 /* Type. */
79 debug_type type;
80 /* Slot if we make an indirect type. */
81 debug_type *pslot;
82 /* Kind of variable or function. */
83 enum ieee_var_kind kind;
86 /* This structure holds all the variables. */
88 struct ieee_vars
90 /* Number of slots allocated. */
91 unsigned int alloc;
92 /* Variables. */
93 struct ieee_var *vars;
96 /* This structure holds information for a type. We need this because
97 we don't want to represent bitfields as real types. */
99 struct ieee_type
101 /* Type. */
102 debug_type type;
103 /* Slot if this is type is referenced before it is defined. */
104 debug_type *pslot;
105 /* Slots for arguments if we make indirect types for them. */
106 debug_type *arg_slots;
107 /* If this is a bitfield, this is the size in bits. If this is not
108 a bitfield, this is zero. */
109 unsigned long bitsize;
112 /* This structure holds all the type information. */
114 struct ieee_types
116 /* Number of slots allocated. */
117 unsigned int alloc;
118 /* Types. */
119 struct ieee_type *types;
120 /* Builtin types. */
121 #define BUILTIN_TYPE_COUNT (60)
122 debug_type builtins[BUILTIN_TYPE_COUNT];
125 /* This structure holds a linked last of structs with their tag names,
126 so that we can convert them to C++ classes if necessary. */
128 struct ieee_tag
130 /* Next tag. */
131 struct ieee_tag *next;
132 /* This tag name. */
133 const char *name;
134 /* The type of the tag. */
135 debug_type type;
136 /* The tagged type is an indirect type pointing at this slot. */
137 debug_type slot;
138 /* This is an array of slots used when a field type is converted
139 into a indirect type, in case it needs to be later converted into
140 a reference type. */
141 debug_type *fslots;
144 /* This structure holds the information we pass around to the parsing
145 functions. */
147 struct ieee_info
149 /* The debugging handle. */
150 void *dhandle;
151 /* The BFD. */
152 bfd *abfd;
153 /* The start of the bytes to be parsed. */
154 const bfd_byte *bytes;
155 /* The end of the bytes to be parsed. */
156 const bfd_byte *pend;
157 /* The block stack. */
158 struct ieee_blockstack blockstack;
159 /* Whether we have seen a BB1 or BB2. */
160 bfd_boolean saw_filename;
161 /* The variables. */
162 struct ieee_vars vars;
163 /* The global variables, after a global typedef block. */
164 struct ieee_vars *global_vars;
165 /* The types. */
166 struct ieee_types types;
167 /* The global types, after a global typedef block. */
168 struct ieee_types *global_types;
169 /* The list of tagged structs. */
170 struct ieee_tag *tags;
173 /* Basic builtin types, not including the pointers. */
175 enum builtin_types
177 builtin_unknown = 0,
178 builtin_void = 1,
179 builtin_signed_char = 2,
180 builtin_unsigned_char = 3,
181 builtin_signed_short_int = 4,
182 builtin_unsigned_short_int = 5,
183 builtin_signed_long = 6,
184 builtin_unsigned_long = 7,
185 builtin_signed_long_long = 8,
186 builtin_unsigned_long_long = 9,
187 builtin_float = 10,
188 builtin_double = 11,
189 builtin_long_double = 12,
190 builtin_long_long_double = 13,
191 builtin_quoted_string = 14,
192 builtin_instruction_address = 15,
193 builtin_int = 16,
194 builtin_unsigned = 17,
195 builtin_unsigned_int = 18,
196 builtin_char = 19,
197 builtin_long = 20,
198 builtin_short = 21,
199 builtin_unsigned_short = 22,
200 builtin_short_int = 23,
201 builtin_signed_short = 24,
202 builtin_bcd_float = 25
205 /* These are the values found in the derivation flags of a 'b'
206 component record of a 'T' type extension record in a C++ pmisc
207 record. These are bitmasks. */
209 /* Set for a private base class, clear for a public base class.
210 Protected base classes are not supported. */
211 #define BASEFLAGS_PRIVATE (0x1)
212 /* Set for a virtual base class. */
213 #define BASEFLAGS_VIRTUAL (0x2)
214 /* Set for a friend class, clear for a base class. */
215 #define BASEFLAGS_FRIEND (0x10)
217 /* These are the values found in the specs flags of a 'd', 'm', or 'v'
218 component record of a 'T' type extension record in a C++ pmisc
219 record. The same flags are used for a 'M' record in a C++ pmisc
220 record. */
222 /* The lower two bits hold visibility information. */
223 #define CXXFLAGS_VISIBILITY (0x3)
224 /* This value in the lower two bits indicates a public member. */
225 #define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
226 /* This value in the lower two bits indicates a private member. */
227 #define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
228 /* This value in the lower two bits indicates a protected member. */
229 #define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
230 /* Set for a static member. */
231 #define CXXFLAGS_STATIC (0x4)
232 /* Set for a virtual override. */
233 #define CXXFLAGS_OVERRIDE (0x8)
234 /* Set for a friend function. */
235 #define CXXFLAGS_FRIEND (0x10)
236 /* Set for a const function. */
237 #define CXXFLAGS_CONST (0x20)
238 /* Set for a volatile function. */
239 #define CXXFLAGS_VOLATILE (0x40)
240 /* Set for an overloaded function. */
241 #define CXXFLAGS_OVERLOADED (0x80)
242 /* Set for an operator function. */
243 #define CXXFLAGS_OPERATOR (0x100)
244 /* Set for a constructor or destructor. */
245 #define CXXFLAGS_CTORDTOR (0x400)
246 /* Set for a constructor. */
247 #define CXXFLAGS_CTOR (0x200)
248 /* Set for an inline function. */
249 #define CXXFLAGS_INLINE (0x800)
251 /* Local functions. */
253 static void ieee_error (struct ieee_info *, const bfd_byte *, const char *);
254 static void ieee_eof (struct ieee_info *);
255 static char *savestring (const char *, unsigned long);
256 static bfd_boolean ieee_read_number
257 (struct ieee_info *, const bfd_byte **, bfd_vma *);
258 static bfd_boolean ieee_read_optional_number
259 (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *);
260 static bfd_boolean ieee_read_id
261 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
262 static bfd_boolean ieee_read_optional_id
263 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *,
264 bfd_boolean *);
265 static bfd_boolean ieee_read_expression
266 (struct ieee_info *, const bfd_byte **, bfd_vma *);
267 static debug_type ieee_builtin_type
268 (struct ieee_info *, const bfd_byte *, unsigned int);
269 static bfd_boolean ieee_alloc_type
270 (struct ieee_info *, unsigned int, bfd_boolean);
271 static bfd_boolean ieee_read_type_index
272 (struct ieee_info *, const bfd_byte **, debug_type *);
273 static int ieee_regno_to_genreg (bfd *, int);
274 static int ieee_genreg_to_regno (bfd *, int);
275 static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **);
276 static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **);
277 static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **);
278 static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **);
279 static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **);
280 static bfd_boolean ieee_read_cxx_misc
281 (struct ieee_info *, const bfd_byte **, unsigned long);
282 static bfd_boolean ieee_read_cxx_class
283 (struct ieee_info *, const bfd_byte **, unsigned long);
284 static bfd_boolean ieee_read_cxx_defaults
285 (struct ieee_info *, const bfd_byte **, unsigned long);
286 static bfd_boolean ieee_read_reference
287 (struct ieee_info *, const bfd_byte **);
288 static bfd_boolean ieee_require_asn
289 (struct ieee_info *, const bfd_byte **, bfd_vma *);
290 static bfd_boolean ieee_require_atn65
291 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
293 /* Report an error in the IEEE debugging information. */
295 static void
296 ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s)
298 if (p != NULL)
299 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
300 (unsigned long) (p - info->bytes), s, *p);
301 else
302 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
305 /* Report an unexpected EOF in the IEEE debugging information. */
307 static void
308 ieee_eof (struct ieee_info *info)
310 ieee_error (info, (const bfd_byte *) NULL,
311 _("unexpected end of debugging information"));
314 /* Save a string in memory. */
316 static char *
317 savestring (const char *start, unsigned long len)
319 char *ret;
321 ret = (char *) xmalloc (len + 1);
322 memcpy (ret, start, len);
323 ret[len] = '\0';
324 return ret;
327 /* Read a number which must be present in an IEEE file. */
329 static bfd_boolean
330 ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
332 return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
335 /* Read a number in an IEEE file. If ppresent is not NULL, the number
336 need not be there. */
338 static bfd_boolean
339 ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp,
340 bfd_vma *pv, bfd_boolean *ppresent)
342 ieee_record_enum_type b;
344 if (*pp >= info->pend)
346 if (ppresent != NULL)
348 *ppresent = FALSE;
349 return TRUE;
351 ieee_eof (info);
352 return FALSE;
355 b = (ieee_record_enum_type) **pp;
356 ++*pp;
358 if (b <= ieee_number_end_enum)
360 *pv = (bfd_vma) b;
361 if (ppresent != NULL)
362 *ppresent = TRUE;
363 return TRUE;
366 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
368 unsigned int i;
370 i = (int) b - (int) ieee_number_repeat_start_enum;
371 if (*pp + i - 1 >= info->pend)
373 ieee_eof (info);
374 return FALSE;
377 *pv = 0;
378 for (; i > 0; i--)
380 *pv <<= 8;
381 *pv += **pp;
382 ++*pp;
385 if (ppresent != NULL)
386 *ppresent = TRUE;
388 return TRUE;
391 if (ppresent != NULL)
393 --*pp;
394 *ppresent = FALSE;
395 return TRUE;
398 ieee_error (info, *pp - 1, _("invalid number"));
399 return FALSE;
402 /* Read a required string from an IEEE file. */
404 static bfd_boolean
405 ieee_read_id (struct ieee_info *info, const bfd_byte **pp,
406 const char **pname, unsigned long *pnamlen)
408 return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
411 /* Read a string from an IEEE file. If ppresent is not NULL, the
412 string is optional. */
414 static bfd_boolean
415 ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp,
416 const char **pname, unsigned long *pnamlen,
417 bfd_boolean *ppresent)
419 bfd_byte b;
420 unsigned long len;
422 if (*pp >= info->pend)
424 ieee_eof (info);
425 return FALSE;
428 b = **pp;
429 ++*pp;
431 if (b <= 0x7f)
432 len = b;
433 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
435 len = **pp;
436 ++*pp;
438 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
440 len = (**pp << 8) + (*pp)[1];
441 *pp += 2;
443 else
445 if (ppresent != NULL)
447 --*pp;
448 *ppresent = FALSE;
449 return TRUE;
451 ieee_error (info, *pp - 1, _("invalid string length"));
452 return FALSE;
455 if ((unsigned long) (info->pend - *pp) < len)
457 ieee_eof (info);
458 return FALSE;
461 *pname = (const char *) *pp;
462 *pnamlen = len;
463 *pp += len;
465 if (ppresent != NULL)
466 *ppresent = TRUE;
468 return TRUE;
471 /* Read an expression from an IEEE file. Since this code is only used
472 to parse debugging information, I haven't bothered to write a full
473 blown IEEE expression parser. I've only thrown in the things I've
474 seen in debugging information. This can be easily extended if
475 necessary. */
477 static bfd_boolean
478 ieee_read_expression (struct ieee_info *info, const bfd_byte **pp,
479 bfd_vma *pv)
481 const bfd_byte *expr_start;
482 #define EXPR_STACK_SIZE (10)
483 bfd_vma expr_stack[EXPR_STACK_SIZE];
484 bfd_vma *esp;
486 expr_start = *pp;
488 esp = expr_stack;
490 while (1)
492 const bfd_byte *start;
493 bfd_vma val;
494 bfd_boolean present;
495 ieee_record_enum_type c;
497 start = *pp;
499 if (! ieee_read_optional_number (info, pp, &val, &present))
500 return FALSE;
502 if (present)
504 if (esp - expr_stack >= EXPR_STACK_SIZE)
506 ieee_error (info, start, _("expression stack overflow"));
507 return FALSE;
509 *esp++ = val;
510 continue;
513 c = (ieee_record_enum_type) **pp;
515 if (c >= ieee_module_beginning_enum)
516 break;
518 ++*pp;
520 if (c == ieee_comma)
521 break;
523 switch (c)
525 default:
526 ieee_error (info, start, _("unsupported IEEE expression operator"));
527 break;
529 case ieee_variable_R_enum:
531 bfd_vma indx;
532 asection *s;
534 if (! ieee_read_number (info, pp, &indx))
535 return FALSE;
536 for (s = info->abfd->sections; s != NULL; s = s->next)
537 if ((bfd_vma) s->target_index == indx)
538 break;
539 if (s == NULL)
541 ieee_error (info, start, _("unknown section"));
542 return FALSE;
545 if (esp - expr_stack >= EXPR_STACK_SIZE)
547 ieee_error (info, start, _("expression stack overflow"));
548 return FALSE;
551 *esp++ = bfd_get_section_vma (info->abfd, s);
553 break;
555 case ieee_function_plus_enum:
556 case ieee_function_minus_enum:
558 bfd_vma v1, v2;
560 if (esp - expr_stack < 2)
562 ieee_error (info, start, _("expression stack underflow"));
563 return FALSE;
566 v1 = *--esp;
567 v2 = *--esp;
568 *esp++ = v1 + v2;
570 break;
574 if (esp - 1 != expr_stack)
576 ieee_error (info, expr_start, _("expression stack mismatch"));
577 return FALSE;
580 *pv = *--esp;
582 return TRUE;
585 /* Return an IEEE builtin type. */
587 static debug_type
588 ieee_builtin_type (struct ieee_info *info, const bfd_byte *p,
589 unsigned int indx)
591 void *dhandle;
592 debug_type type;
593 const char *name;
595 if (indx < BUILTIN_TYPE_COUNT
596 && info->types.builtins[indx] != DEBUG_TYPE_NULL)
597 return info->types.builtins[indx];
599 dhandle = info->dhandle;
601 if (indx >= 32 && indx < 64)
603 type = debug_make_pointer_type (dhandle,
604 ieee_builtin_type (info, p, indx - 32));
605 assert (indx < BUILTIN_TYPE_COUNT);
606 info->types.builtins[indx] = type;
607 return type;
610 switch ((enum builtin_types) indx)
612 default:
613 ieee_error (info, p, _("unknown builtin type"));
614 return NULL;
616 case builtin_unknown:
617 type = debug_make_void_type (dhandle);
618 name = NULL;
619 break;
621 case builtin_void:
622 type = debug_make_void_type (dhandle);
623 name = "void";
624 break;
626 case builtin_signed_char:
627 type = debug_make_int_type (dhandle, 1, FALSE);
628 name = "signed char";
629 break;
631 case builtin_unsigned_char:
632 type = debug_make_int_type (dhandle, 1, TRUE);
633 name = "unsigned char";
634 break;
636 case builtin_signed_short_int:
637 type = debug_make_int_type (dhandle, 2, FALSE);
638 name = "signed short int";
639 break;
641 case builtin_unsigned_short_int:
642 type = debug_make_int_type (dhandle, 2, TRUE);
643 name = "unsigned short int";
644 break;
646 case builtin_signed_long:
647 type = debug_make_int_type (dhandle, 4, FALSE);
648 name = "signed long";
649 break;
651 case builtin_unsigned_long:
652 type = debug_make_int_type (dhandle, 4, TRUE);
653 name = "unsigned long";
654 break;
656 case builtin_signed_long_long:
657 type = debug_make_int_type (dhandle, 8, FALSE);
658 name = "signed long long";
659 break;
661 case builtin_unsigned_long_long:
662 type = debug_make_int_type (dhandle, 8, TRUE);
663 name = "unsigned long long";
664 break;
666 case builtin_float:
667 type = debug_make_float_type (dhandle, 4);
668 name = "float";
669 break;
671 case builtin_double:
672 type = debug_make_float_type (dhandle, 8);
673 name = "double";
674 break;
676 case builtin_long_double:
677 /* FIXME: The size for this type should depend upon the
678 processor. */
679 type = debug_make_float_type (dhandle, 12);
680 name = "long double";
681 break;
683 case builtin_long_long_double:
684 type = debug_make_float_type (dhandle, 16);
685 name = "long long double";
686 break;
688 case builtin_quoted_string:
689 type = debug_make_array_type (dhandle,
690 ieee_builtin_type (info, p,
691 ((unsigned int)
692 builtin_char)),
693 ieee_builtin_type (info, p,
694 ((unsigned int)
695 builtin_int)),
696 0, -1, TRUE);
697 name = "QUOTED STRING";
698 break;
700 case builtin_instruction_address:
701 /* FIXME: This should be a code address. */
702 type = debug_make_int_type (dhandle, 4, TRUE);
703 name = "instruction address";
704 break;
706 case builtin_int:
707 /* FIXME: The size for this type should depend upon the
708 processor. */
709 type = debug_make_int_type (dhandle, 4, FALSE);
710 name = "int";
711 break;
713 case builtin_unsigned:
714 /* FIXME: The size for this type should depend upon the
715 processor. */
716 type = debug_make_int_type (dhandle, 4, TRUE);
717 name = "unsigned";
718 break;
720 case builtin_unsigned_int:
721 /* FIXME: The size for this type should depend upon the
722 processor. */
723 type = debug_make_int_type (dhandle, 4, TRUE);
724 name = "unsigned int";
725 break;
727 case builtin_char:
728 type = debug_make_int_type (dhandle, 1, FALSE);
729 name = "char";
730 break;
732 case builtin_long:
733 type = debug_make_int_type (dhandle, 4, FALSE);
734 name = "long";
735 break;
737 case builtin_short:
738 type = debug_make_int_type (dhandle, 2, FALSE);
739 name = "short";
740 break;
742 case builtin_unsigned_short:
743 type = debug_make_int_type (dhandle, 2, TRUE);
744 name = "unsigned short";
745 break;
747 case builtin_short_int:
748 type = debug_make_int_type (dhandle, 2, FALSE);
749 name = "short int";
750 break;
752 case builtin_signed_short:
753 type = debug_make_int_type (dhandle, 2, FALSE);
754 name = "signed short";
755 break;
757 case builtin_bcd_float:
758 ieee_error (info, p, _("BCD float type not supported"));
759 return DEBUG_TYPE_NULL;
762 if (name != NULL)
763 type = debug_name_type (dhandle, name, type);
765 assert (indx < BUILTIN_TYPE_COUNT);
767 info->types.builtins[indx] = type;
769 return type;
772 /* Allocate more space in the type table. If ref is TRUE, this is a
773 reference to the type; if it is not already defined, we should set
774 up an indirect type. */
776 static bfd_boolean
777 ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref)
779 unsigned int nalloc;
780 register struct ieee_type *t;
781 struct ieee_type *tend;
783 if (indx >= info->types.alloc)
785 nalloc = info->types.alloc;
786 if (nalloc == 0)
787 nalloc = 4;
788 while (indx >= nalloc)
789 nalloc *= 2;
791 info->types.types = ((struct ieee_type *)
792 xrealloc (info->types.types,
793 nalloc * sizeof *info->types.types));
795 memset (info->types.types + info->types.alloc, 0,
796 (nalloc - info->types.alloc) * sizeof *info->types.types);
798 tend = info->types.types + nalloc;
799 for (t = info->types.types + info->types.alloc; t < tend; t++)
800 t->type = DEBUG_TYPE_NULL;
802 info->types.alloc = nalloc;
805 if (ref)
807 t = info->types.types + indx;
808 if (t->type == NULL)
810 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
811 *t->pslot = DEBUG_TYPE_NULL;
812 t->type = debug_make_indirect_type (info->dhandle, t->pslot,
813 (const char *) NULL);
814 if (t->type == NULL)
815 return FALSE;
819 return TRUE;
822 /* Read a type index and return the corresponding type. */
824 static bfd_boolean
825 ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp,
826 debug_type *ptype)
828 const bfd_byte *start;
829 bfd_vma indx;
831 start = *pp;
833 if (! ieee_read_number (info, pp, &indx))
834 return FALSE;
836 if (indx < 256)
838 *ptype = ieee_builtin_type (info, start, indx);
839 if (*ptype == NULL)
840 return FALSE;
841 return TRUE;
844 indx -= 256;
845 if (! ieee_alloc_type (info, indx, TRUE))
846 return FALSE;
848 *ptype = info->types.types[indx].type;
850 return TRUE;
853 /* Parse IEEE debugging information for a file. This is passed the
854 bytes which compose the Debug Information Part of an IEEE file. */
856 bfd_boolean
857 parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len)
859 struct ieee_info info;
860 unsigned int i;
861 const bfd_byte *p, *pend;
863 info.dhandle = dhandle;
864 info.abfd = abfd;
865 info.bytes = bytes;
866 info.pend = bytes + len;
867 info.blockstack.bsp = info.blockstack.stack;
868 info.saw_filename = FALSE;
869 info.vars.alloc = 0;
870 info.vars.vars = NULL;
871 info.global_vars = NULL;
872 info.types.alloc = 0;
873 info.types.types = NULL;
874 info.global_types = NULL;
875 info.tags = NULL;
876 for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
877 info.types.builtins[i] = DEBUG_TYPE_NULL;
879 p = bytes;
880 pend = info.pend;
881 while (p < pend)
883 const bfd_byte *record_start;
884 ieee_record_enum_type c;
886 record_start = p;
888 c = (ieee_record_enum_type) *p++;
890 if (c == ieee_at_record_enum)
891 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
893 if (c <= ieee_number_repeat_end_enum)
895 ieee_error (&info, record_start, _("unexpected number"));
896 return FALSE;
899 switch (c)
901 default:
902 ieee_error (&info, record_start, _("unexpected record type"));
903 return FALSE;
905 case ieee_bb_record_enum:
906 if (! parse_ieee_bb (&info, &p))
907 return FALSE;
908 break;
910 case ieee_be_record_enum:
911 if (! parse_ieee_be (&info, &p))
912 return FALSE;
913 break;
915 case ieee_nn_record:
916 if (! parse_ieee_nn (&info, &p))
917 return FALSE;
918 break;
920 case ieee_ty_record_enum:
921 if (! parse_ieee_ty (&info, &p))
922 return FALSE;
923 break;
925 case ieee_atn_record_enum:
926 if (! parse_ieee_atn (&info, &p))
927 return FALSE;
928 break;
932 if (info.blockstack.bsp != info.blockstack.stack)
934 ieee_error (&info, (const bfd_byte *) NULL,
935 _("blocks left on stack at end"));
936 return FALSE;
939 return TRUE;
942 /* Handle an IEEE BB record. */
944 static bfd_boolean
945 parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp)
947 const bfd_byte *block_start;
948 bfd_byte b;
949 bfd_vma size;
950 const char *name;
951 unsigned long namlen;
952 char *namcopy = NULL;
953 unsigned int fnindx;
954 bfd_boolean skip;
956 block_start = *pp;
958 b = **pp;
959 ++*pp;
961 if (! ieee_read_number (info, pp, &size)
962 || ! ieee_read_id (info, pp, &name, &namlen))
963 return FALSE;
965 fnindx = (unsigned int) -1;
966 skip = FALSE;
968 switch (b)
970 case 1:
971 /* BB1: Type definitions local to a module. */
972 namcopy = savestring (name, namlen);
973 if (namcopy == NULL)
974 return FALSE;
975 if (! debug_set_filename (info->dhandle, namcopy))
976 return FALSE;
977 info->saw_filename = TRUE;
979 /* Discard any variables or types we may have seen before. */
980 if (info->vars.vars != NULL)
981 free (info->vars.vars);
982 info->vars.vars = NULL;
983 info->vars.alloc = 0;
984 if (info->types.types != NULL)
985 free (info->types.types);
986 info->types.types = NULL;
987 info->types.alloc = 0;
989 /* Initialize the types to the global types. */
990 if (info->global_types != NULL)
992 info->types.alloc = info->global_types->alloc;
993 info->types.types = ((struct ieee_type *)
994 xmalloc (info->types.alloc
995 * sizeof (*info->types.types)));
996 memcpy (info->types.types, info->global_types->types,
997 info->types.alloc * sizeof (*info->types.types));
1000 break;
1002 case 2:
1003 /* BB2: Global type definitions. The name is supposed to be
1004 empty, but we don't check. */
1005 if (! debug_set_filename (info->dhandle, "*global*"))
1006 return FALSE;
1007 info->saw_filename = TRUE;
1008 break;
1010 case 3:
1011 /* BB3: High level module block begin. We don't have to do
1012 anything here. The name is supposed to be the same as for
1013 the BB1, but we don't check. */
1014 break;
1016 case 4:
1017 /* BB4: Global function. */
1019 bfd_vma stackspace, typindx, offset;
1020 debug_type return_type;
1022 if (! ieee_read_number (info, pp, &stackspace)
1023 || ! ieee_read_number (info, pp, &typindx)
1024 || ! ieee_read_expression (info, pp, &offset))
1025 return FALSE;
1027 /* We have no way to record the stack space. FIXME. */
1029 if (typindx < 256)
1031 return_type = ieee_builtin_type (info, block_start, typindx);
1032 if (return_type == DEBUG_TYPE_NULL)
1033 return FALSE;
1035 else
1037 typindx -= 256;
1038 if (! ieee_alloc_type (info, typindx, TRUE))
1039 return FALSE;
1040 fnindx = typindx;
1041 return_type = info->types.types[typindx].type;
1042 if (debug_get_type_kind (info->dhandle, return_type)
1043 == DEBUG_KIND_FUNCTION)
1044 return_type = debug_get_return_type (info->dhandle,
1045 return_type);
1048 namcopy = savestring (name, namlen);
1049 if (namcopy == NULL)
1050 return FALSE;
1051 if (! debug_record_function (info->dhandle, namcopy, return_type,
1052 TRUE, offset))
1053 return FALSE;
1055 break;
1057 case 5:
1058 /* BB5: File name for source line numbers. */
1060 unsigned int i;
1062 /* We ignore the date and time. FIXME. */
1063 for (i = 0; i < 6; i++)
1065 bfd_vma ignore;
1066 bfd_boolean present;
1068 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1069 return FALSE;
1070 if (! present)
1071 break;
1074 if (! info->saw_filename)
1076 namcopy = savestring (name, namlen);
1077 if (namcopy == NULL)
1078 return FALSE;
1079 if (! debug_set_filename (info->dhandle, namcopy))
1080 return FALSE;
1081 info->saw_filename = TRUE;
1084 namcopy = savestring (name, namlen);
1085 if (namcopy == NULL)
1086 return FALSE;
1087 if (! debug_start_source (info->dhandle, namcopy))
1088 return FALSE;
1090 break;
1092 case 6:
1093 /* BB6: Local function or block. */
1095 bfd_vma stackspace, typindx, offset;
1097 if (! ieee_read_number (info, pp, &stackspace)
1098 || ! ieee_read_number (info, pp, &typindx)
1099 || ! ieee_read_expression (info, pp, &offset))
1100 return FALSE;
1102 /* We have no way to record the stack space. FIXME. */
1104 if (namlen == 0)
1106 if (! debug_start_block (info->dhandle, offset))
1107 return FALSE;
1108 /* Change b to indicate that this is a block
1109 rather than a function. */
1110 b = 0x86;
1112 else
1114 /* The MRI C++ compiler will output a fake function named
1115 __XRYCPP to hold C++ debugging information. We skip
1116 that function. This is not crucial, but it makes
1117 converting from IEEE to other debug formats work
1118 better. */
1119 if (strncmp (name, "__XRYCPP", namlen) == 0)
1120 skip = TRUE;
1121 else
1123 debug_type return_type;
1125 if (typindx < 256)
1127 return_type = ieee_builtin_type (info, block_start,
1128 typindx);
1129 if (return_type == NULL)
1130 return FALSE;
1132 else
1134 typindx -= 256;
1135 if (! ieee_alloc_type (info, typindx, TRUE))
1136 return FALSE;
1137 fnindx = typindx;
1138 return_type = info->types.types[typindx].type;
1139 if (debug_get_type_kind (info->dhandle, return_type)
1140 == DEBUG_KIND_FUNCTION)
1141 return_type = debug_get_return_type (info->dhandle,
1142 return_type);
1145 namcopy = savestring (name, namlen);
1146 if (namcopy == NULL)
1147 return FALSE;
1148 if (! debug_record_function (info->dhandle, namcopy,
1149 return_type, FALSE, offset))
1150 return FALSE;
1154 break;
1156 case 10:
1157 /* BB10: Assembler module scope. In the normal case, we
1158 completely ignore all this information. FIXME. */
1160 const char *inam, *vstr;
1161 unsigned long inamlen, vstrlen;
1162 bfd_vma tool_type;
1163 bfd_boolean present;
1164 unsigned int i;
1166 if (! info->saw_filename)
1168 namcopy = savestring (name, namlen);
1169 if (namcopy == NULL)
1170 return FALSE;
1171 if (! debug_set_filename (info->dhandle, namcopy))
1172 return FALSE;
1173 info->saw_filename = TRUE;
1176 if (! ieee_read_id (info, pp, &inam, &inamlen)
1177 || ! ieee_read_number (info, pp, &tool_type)
1178 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1179 return FALSE;
1180 for (i = 0; i < 6; i++)
1182 bfd_vma ignore;
1184 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1185 return FALSE;
1186 if (! present)
1187 break;
1190 break;
1192 case 11:
1193 /* BB11: Module section. We completely ignore all this
1194 information. FIXME. */
1196 bfd_vma sectype, secindx, offset, map;
1197 bfd_boolean present;
1199 if (! ieee_read_number (info, pp, &sectype)
1200 || ! ieee_read_number (info, pp, &secindx)
1201 || ! ieee_read_expression (info, pp, &offset)
1202 || ! ieee_read_optional_number (info, pp, &map, &present))
1203 return FALSE;
1205 break;
1207 default:
1208 ieee_error (info, block_start, _("unknown BB type"));
1209 return FALSE;
1213 /* Push this block on the block stack. */
1215 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1217 ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
1218 return FALSE;
1221 info->blockstack.bsp->kind = b;
1222 if (b == 5)
1223 info->blockstack.bsp->filename = namcopy;
1224 info->blockstack.bsp->fnindx = fnindx;
1225 info->blockstack.bsp->skip = skip;
1226 ++info->blockstack.bsp;
1228 return TRUE;
1231 /* Handle an IEEE BE record. */
1233 static bfd_boolean
1234 parse_ieee_be (struct ieee_info *info, const bfd_byte **pp)
1236 bfd_vma offset;
1238 if (info->blockstack.bsp <= info->blockstack.stack)
1240 ieee_error (info, *pp, _("stack underflow"));
1241 return FALSE;
1243 --info->blockstack.bsp;
1245 switch (info->blockstack.bsp->kind)
1247 case 2:
1248 /* When we end the global typedefs block, we copy out the
1249 contents of info->vars. This is because the variable indices
1250 may be reused in the local blocks. However, we need to
1251 preserve them so that we can locate a function returning a
1252 reference variable whose type is named in the global typedef
1253 block. */
1254 info->global_vars = ((struct ieee_vars *)
1255 xmalloc (sizeof *info->global_vars));
1256 info->global_vars->alloc = info->vars.alloc;
1257 info->global_vars->vars = ((struct ieee_var *)
1258 xmalloc (info->vars.alloc
1259 * sizeof (*info->vars.vars)));
1260 memcpy (info->global_vars->vars, info->vars.vars,
1261 info->vars.alloc * sizeof (*info->vars.vars));
1263 /* We also copy out the non builtin parts of info->types, since
1264 the types are discarded when we start a new block. */
1265 info->global_types = ((struct ieee_types *)
1266 xmalloc (sizeof *info->global_types));
1267 info->global_types->alloc = info->types.alloc;
1268 info->global_types->types = ((struct ieee_type *)
1269 xmalloc (info->types.alloc
1270 * sizeof (*info->types.types)));
1271 memcpy (info->global_types->types, info->types.types,
1272 info->types.alloc * sizeof (*info->types.types));
1273 memset (info->global_types->builtins, 0,
1274 sizeof (info->global_types->builtins));
1276 break;
1278 case 4:
1279 case 6:
1280 if (! ieee_read_expression (info, pp, &offset))
1281 return FALSE;
1282 if (! info->blockstack.bsp->skip)
1284 if (! debug_end_function (info->dhandle, offset + 1))
1285 return FALSE;
1287 break;
1289 case 0x86:
1290 /* This is BE6 when BB6 started a block rather than a local
1291 function. */
1292 if (! ieee_read_expression (info, pp, &offset))
1293 return FALSE;
1294 if (! debug_end_block (info->dhandle, offset + 1))
1295 return FALSE;
1296 break;
1298 case 5:
1299 /* When we end a BB5, we look up the stack for the last BB5, if
1300 there is one, so that we can call debug_start_source. */
1301 if (info->blockstack.bsp > info->blockstack.stack)
1303 struct ieee_block *bl;
1305 bl = info->blockstack.bsp;
1308 --bl;
1309 if (bl->kind == 5)
1311 if (! debug_start_source (info->dhandle, bl->filename))
1312 return FALSE;
1313 break;
1316 while (bl != info->blockstack.stack);
1318 break;
1320 case 11:
1321 if (! ieee_read_expression (info, pp, &offset))
1322 return FALSE;
1323 /* We just ignore the module size. FIXME. */
1324 break;
1326 default:
1327 /* Other block types do not have any trailing information. */
1328 break;
1331 return TRUE;
1334 /* Parse an NN record. */
1336 static bfd_boolean
1337 parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp)
1339 const bfd_byte *nn_start;
1340 bfd_vma varindx;
1341 const char *name;
1342 unsigned long namlen;
1344 nn_start = *pp;
1346 if (! ieee_read_number (info, pp, &varindx)
1347 || ! ieee_read_id (info, pp, &name, &namlen))
1348 return FALSE;
1350 if (varindx < 32)
1352 ieee_error (info, nn_start, _("illegal variable index"));
1353 return FALSE;
1355 varindx -= 32;
1357 if (varindx >= info->vars.alloc)
1359 unsigned int alloc;
1361 alloc = info->vars.alloc;
1362 if (alloc == 0)
1363 alloc = 4;
1364 while (varindx >= alloc)
1365 alloc *= 2;
1366 info->vars.vars = ((struct ieee_var *)
1367 xrealloc (info->vars.vars,
1368 alloc * sizeof *info->vars.vars));
1369 memset (info->vars.vars + info->vars.alloc, 0,
1370 (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1371 info->vars.alloc = alloc;
1374 info->vars.vars[varindx].name = name;
1375 info->vars.vars[varindx].namlen = namlen;
1377 return TRUE;
1380 /* Parse a TY record. */
1382 static bfd_boolean
1383 parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp)
1385 const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1386 bfd_vma typeindx, varindx, tc;
1387 void *dhandle;
1388 bfd_boolean tag, typdef;
1389 debug_type *arg_slots;
1390 unsigned long type_bitsize;
1391 debug_type type;
1393 ty_start = *pp;
1395 if (! ieee_read_number (info, pp, &typeindx))
1396 return FALSE;
1398 if (typeindx < 256)
1400 ieee_error (info, ty_start, _("illegal type index"));
1401 return FALSE;
1404 typeindx -= 256;
1405 if (! ieee_alloc_type (info, typeindx, FALSE))
1406 return FALSE;
1408 if (**pp != 0xce)
1410 ieee_error (info, *pp, _("unknown TY code"));
1411 return FALSE;
1413 ++*pp;
1415 ty_var_start = *pp;
1417 if (! ieee_read_number (info, pp, &varindx))
1418 return FALSE;
1420 if (varindx < 32)
1422 ieee_error (info, ty_var_start, _("illegal variable index"));
1423 return FALSE;
1425 varindx -= 32;
1427 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1429 ieee_error (info, ty_var_start, _("undefined variable in TY"));
1430 return FALSE;
1433 ty_code_start = *pp;
1435 if (! ieee_read_number (info, pp, &tc))
1436 return FALSE;
1438 dhandle = info->dhandle;
1440 tag = FALSE;
1441 typdef = FALSE;
1442 arg_slots = NULL;
1443 type_bitsize = 0;
1444 switch (tc)
1446 default:
1447 ieee_error (info, ty_code_start, _("unknown TY code"));
1448 return FALSE;
1450 case '!':
1451 /* Unknown type, with size. We treat it as int. FIXME. */
1453 bfd_vma size;
1455 if (! ieee_read_number (info, pp, &size))
1456 return FALSE;
1457 type = debug_make_int_type (dhandle, size, FALSE);
1459 break;
1461 case 'A': /* Array. */
1462 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1463 distinguished from normal array. */
1465 debug_type ele_type;
1466 bfd_vma lower, upper;
1468 if (! ieee_read_type_index (info, pp, &ele_type)
1469 || ! ieee_read_number (info, pp, &lower)
1470 || ! ieee_read_number (info, pp, &upper))
1471 return FALSE;
1472 type = debug_make_array_type (dhandle, ele_type,
1473 ieee_builtin_type (info, ty_code_start,
1474 ((unsigned int)
1475 builtin_int)),
1476 (bfd_signed_vma) lower,
1477 (bfd_signed_vma) upper,
1478 FALSE);
1480 break;
1482 case 'E':
1483 /* Simple enumeration. */
1485 bfd_vma size;
1486 unsigned int alloc;
1487 const char **names;
1488 unsigned int c;
1489 bfd_signed_vma *vals;
1490 unsigned int i;
1492 if (! ieee_read_number (info, pp, &size))
1493 return FALSE;
1494 /* FIXME: we ignore the enumeration size. */
1496 alloc = 10;
1497 names = (const char **) xmalloc (alloc * sizeof *names);
1498 memset (names, 0, alloc * sizeof *names);
1499 c = 0;
1500 while (1)
1502 const char *name;
1503 unsigned long namlen;
1504 bfd_boolean present;
1506 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1507 return FALSE;
1508 if (! present)
1509 break;
1511 if (c + 1 >= alloc)
1513 alloc += 10;
1514 names = ((const char **)
1515 xrealloc (names, alloc * sizeof *names));
1518 names[c] = savestring (name, namlen);
1519 if (names[c] == NULL)
1520 return FALSE;
1521 ++c;
1524 names[c] = NULL;
1526 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1527 for (i = 0; i < c; i++)
1528 vals[i] = i;
1530 type = debug_make_enum_type (dhandle, names, vals);
1531 tag = TRUE;
1533 break;
1535 case 'G':
1536 /* Struct with bit fields. */
1538 bfd_vma size;
1539 unsigned int alloc;
1540 debug_field *fields;
1541 unsigned int c;
1543 if (! ieee_read_number (info, pp, &size))
1544 return FALSE;
1546 alloc = 10;
1547 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1548 c = 0;
1549 while (1)
1551 const char *name;
1552 unsigned long namlen;
1553 bfd_boolean present;
1554 debug_type ftype;
1555 bfd_vma bitpos, bitsize;
1557 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1558 return FALSE;
1559 if (! present)
1560 break;
1561 if (! ieee_read_type_index (info, pp, &ftype)
1562 || ! ieee_read_number (info, pp, &bitpos)
1563 || ! ieee_read_number (info, pp, &bitsize))
1564 return FALSE;
1566 if (c + 1 >= alloc)
1568 alloc += 10;
1569 fields = ((debug_field *)
1570 xrealloc (fields, alloc * sizeof *fields));
1573 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1574 ftype, bitpos, bitsize,
1575 DEBUG_VISIBILITY_PUBLIC);
1576 if (fields[c] == NULL)
1577 return FALSE;
1578 ++c;
1581 fields[c] = NULL;
1583 type = debug_make_struct_type (dhandle, TRUE, size, fields);
1584 tag = TRUE;
1586 break;
1588 case 'N':
1589 /* Enumeration. */
1591 unsigned int alloc;
1592 const char **names;
1593 bfd_signed_vma *vals;
1594 unsigned int c;
1596 alloc = 10;
1597 names = (const char **) xmalloc (alloc * sizeof *names);
1598 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1599 c = 0;
1600 while (1)
1602 const char *name;
1603 unsigned long namlen;
1604 bfd_boolean present;
1605 bfd_vma val;
1607 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1608 return FALSE;
1609 if (! present)
1610 break;
1611 if (! ieee_read_number (info, pp, &val))
1612 return FALSE;
1614 /* If the length of the name is zero, then the value is
1615 actually the size of the enum. We ignore this
1616 information. FIXME. */
1617 if (namlen == 0)
1618 continue;
1620 if (c + 1 >= alloc)
1622 alloc += 10;
1623 names = ((const char **)
1624 xrealloc (names, alloc * sizeof *names));
1625 vals = ((bfd_signed_vma *)
1626 xrealloc (vals, alloc * sizeof *vals));
1629 names[c] = savestring (name, namlen);
1630 if (names[c] == NULL)
1631 return FALSE;
1632 vals[c] = (bfd_signed_vma) val;
1633 ++c;
1636 names[c] = NULL;
1638 type = debug_make_enum_type (dhandle, names, vals);
1639 tag = TRUE;
1641 break;
1643 case 'O': /* Small pointer. We don't distinguish small and large
1644 pointers. FIXME. */
1645 case 'P': /* Large pointer. */
1647 debug_type t;
1649 if (! ieee_read_type_index (info, pp, &t))
1650 return FALSE;
1651 type = debug_make_pointer_type (dhandle, t);
1653 break;
1655 case 'R':
1656 /* Range. */
1658 bfd_vma low, high, signedp, size;
1660 if (! ieee_read_number (info, pp, &low)
1661 || ! ieee_read_number (info, pp, &high)
1662 || ! ieee_read_number (info, pp, &signedp)
1663 || ! ieee_read_number (info, pp, &size))
1664 return FALSE;
1666 type = debug_make_range_type (dhandle,
1667 debug_make_int_type (dhandle, size,
1668 ! signedp),
1669 (bfd_signed_vma) low,
1670 (bfd_signed_vma) high);
1672 break;
1674 case 'S': /* Struct. */
1675 case 'U': /* Union. */
1677 bfd_vma size;
1678 unsigned int alloc;
1679 debug_field *fields;
1680 unsigned int c;
1682 if (! ieee_read_number (info, pp, &size))
1683 return FALSE;
1685 alloc = 10;
1686 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1687 c = 0;
1688 while (1)
1690 const char *name;
1691 unsigned long namlen;
1692 bfd_boolean present;
1693 bfd_vma tindx;
1694 bfd_vma offset;
1695 debug_type ftype;
1696 bfd_vma bitsize;
1698 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1699 return FALSE;
1700 if (! present)
1701 break;
1702 if (! ieee_read_number (info, pp, &tindx)
1703 || ! ieee_read_number (info, pp, &offset))
1704 return FALSE;
1706 if (tindx < 256)
1708 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1709 bitsize = 0;
1710 offset *= 8;
1712 else
1714 struct ieee_type *t;
1716 tindx -= 256;
1717 if (! ieee_alloc_type (info, tindx, TRUE))
1718 return FALSE;
1719 t = info->types.types + tindx;
1720 ftype = t->type;
1721 bitsize = t->bitsize;
1722 if (bitsize == 0)
1723 offset *= 8;
1726 if (c + 1 >= alloc)
1728 alloc += 10;
1729 fields = ((debug_field *)
1730 xrealloc (fields, alloc * sizeof *fields));
1733 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1734 ftype, offset, bitsize,
1735 DEBUG_VISIBILITY_PUBLIC);
1736 if (fields[c] == NULL)
1737 return FALSE;
1738 ++c;
1741 fields[c] = NULL;
1743 type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1744 tag = TRUE;
1746 break;
1748 case 'T':
1749 /* Typedef. */
1750 if (! ieee_read_type_index (info, pp, &type))
1751 return FALSE;
1752 typdef = TRUE;
1753 break;
1755 case 'X':
1756 /* Procedure. FIXME: This is an extern declaration, which we
1757 have no way of representing. */
1759 bfd_vma attr;
1760 debug_type rtype;
1761 bfd_vma nargs;
1762 bfd_boolean present;
1763 struct ieee_var *pv;
1765 /* FIXME: We ignore the attribute and the argument names. */
1767 if (! ieee_read_number (info, pp, &attr)
1768 || ! ieee_read_type_index (info, pp, &rtype)
1769 || ! ieee_read_number (info, pp, &nargs))
1770 return FALSE;
1773 const char *name;
1774 unsigned long namlen;
1776 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1777 return FALSE;
1779 while (present);
1781 pv = info->vars.vars + varindx;
1782 pv->kind = IEEE_EXTERNAL;
1783 if (pv->namlen > 0
1784 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1786 /* Set up the return type as an indirect type pointing to
1787 the variable slot, so that we can change it to a
1788 reference later if appropriate. */
1789 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1790 *pv->pslot = rtype;
1791 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1792 (const char *) NULL);
1795 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1796 FALSE);
1798 break;
1800 case 'V':
1801 case 'v':
1802 /* Void. This is not documented, but the MRI compiler emits it. */
1803 type = debug_make_void_type (dhandle);
1804 break;
1806 case 'Z':
1807 /* Array with 0 lower bound. */
1809 debug_type etype;
1810 bfd_vma high;
1812 if (! ieee_read_type_index (info, pp, &etype)
1813 || ! ieee_read_number (info, pp, &high))
1814 return FALSE;
1816 type = debug_make_array_type (dhandle, etype,
1817 ieee_builtin_type (info, ty_code_start,
1818 ((unsigned int)
1819 builtin_int)),
1820 0, (bfd_signed_vma) high, FALSE);
1822 break;
1824 case 'c': /* Complex. */
1825 case 'd': /* Double complex. */
1827 const char *name;
1828 unsigned long namlen;
1830 /* FIXME: I don't know what the name means. */
1832 if (! ieee_read_id (info, pp, &name, &namlen))
1833 return FALSE;
1835 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1837 break;
1839 case 'f':
1840 /* Pascal file name. FIXME. */
1841 ieee_error (info, ty_code_start, _("Pascal file name not supported"));
1842 return FALSE;
1844 case 'g':
1845 /* Bitfield type. */
1847 bfd_vma signedp, bitsize, dummy;
1848 const bfd_byte *hold;
1849 bfd_boolean present;
1851 if (! ieee_read_number (info, pp, &signedp)
1852 || ! ieee_read_number (info, pp, &bitsize))
1853 return FALSE;
1855 /* I think the documentation says that there is a type index,
1856 but some actual files do not have one. */
1857 hold = *pp;
1858 if (! ieee_read_optional_number (info, pp, &dummy, &present))
1859 return FALSE;
1860 if (! present)
1862 /* FIXME: This is just a guess. */
1863 type = debug_make_int_type (dhandle, 4,
1864 signedp ? FALSE : TRUE);
1866 else
1868 *pp = hold;
1869 if (! ieee_read_type_index (info, pp, &type))
1870 return FALSE;
1872 type_bitsize = bitsize;
1874 break;
1876 case 'n':
1877 /* Qualifier. */
1879 bfd_vma kind;
1880 debug_type t;
1882 if (! ieee_read_number (info, pp, &kind)
1883 || ! ieee_read_type_index (info, pp, &t))
1884 return FALSE;
1886 switch (kind)
1888 default:
1889 ieee_error (info, ty_start, _("unsupported qualifier"));
1890 return FALSE;
1892 case 1:
1893 type = debug_make_const_type (dhandle, t);
1894 break;
1896 case 2:
1897 type = debug_make_volatile_type (dhandle, t);
1898 break;
1901 break;
1903 case 's':
1904 /* Set. */
1906 bfd_vma size;
1907 debug_type etype;
1909 if (! ieee_read_number (info, pp, &size)
1910 || ! ieee_read_type_index (info, pp, &etype))
1911 return FALSE;
1913 /* FIXME: We ignore the size. */
1915 type = debug_make_set_type (dhandle, etype, FALSE);
1917 break;
1919 case 'x':
1920 /* Procedure with compiler dependencies. */
1922 struct ieee_var *pv;
1923 bfd_vma attr, frame_type, push_mask, nargs, level, father;
1924 debug_type rtype;
1925 debug_type *arg_types;
1926 bfd_boolean varargs;
1927 bfd_boolean present;
1929 /* FIXME: We ignore some of this information. */
1931 pv = info->vars.vars + varindx;
1933 if (! ieee_read_number (info, pp, &attr)
1934 || ! ieee_read_number (info, pp, &frame_type)
1935 || ! ieee_read_number (info, pp, &push_mask)
1936 || ! ieee_read_type_index (info, pp, &rtype)
1937 || ! ieee_read_number (info, pp, &nargs))
1938 return FALSE;
1939 if (nargs == (bfd_vma) -1)
1941 arg_types = NULL;
1942 varargs = FALSE;
1944 else
1946 unsigned int i;
1948 arg_types = ((debug_type *)
1949 xmalloc ((nargs + 1) * sizeof *arg_types));
1950 for (i = 0; i < nargs; i++)
1951 if (! ieee_read_type_index (info, pp, arg_types + i))
1952 return FALSE;
1954 /* If the last type is pointer to void, this is really a
1955 varargs function. */
1956 varargs = FALSE;
1957 if (nargs > 0)
1959 debug_type last;
1961 last = arg_types[nargs - 1];
1962 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1963 && (debug_get_type_kind (dhandle,
1964 debug_get_target_type (dhandle,
1965 last))
1966 == DEBUG_KIND_VOID))
1968 --nargs;
1969 varargs = TRUE;
1973 /* If there are any pointer arguments, turn them into
1974 indirect types in case we later need to convert them to
1975 reference types. */
1976 for (i = 0; i < nargs; i++)
1978 if (debug_get_type_kind (dhandle, arg_types[i])
1979 == DEBUG_KIND_POINTER)
1981 if (arg_slots == NULL)
1983 arg_slots = ((debug_type *)
1984 xmalloc (nargs * sizeof *arg_slots));
1985 memset (arg_slots, 0, nargs * sizeof *arg_slots);
1987 arg_slots[i] = arg_types[i];
1988 arg_types[i] =
1989 debug_make_indirect_type (dhandle,
1990 arg_slots + i,
1991 (const char *) NULL);
1995 arg_types[nargs] = DEBUG_TYPE_NULL;
1997 if (! ieee_read_number (info, pp, &level)
1998 || ! ieee_read_optional_number (info, pp, &father, &present))
1999 return FALSE;
2001 /* We can't distinguish between a global function and a static
2002 function. */
2003 pv->kind = IEEE_FUNCTION;
2005 if (pv->namlen > 0
2006 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
2008 /* Set up the return type as an indirect type pointing to
2009 the variable slot, so that we can change it to a
2010 reference later if appropriate. */
2011 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
2012 *pv->pslot = rtype;
2013 rtype = debug_make_indirect_type (dhandle, pv->pslot,
2014 (const char *) NULL);
2017 type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
2019 break;
2022 /* Record the type in the table. */
2024 if (type == DEBUG_TYPE_NULL)
2025 return FALSE;
2027 info->vars.vars[varindx].type = type;
2029 if ((tag || typdef)
2030 && info->vars.vars[varindx].namlen > 0)
2032 const char *name;
2034 name = savestring (info->vars.vars[varindx].name,
2035 info->vars.vars[varindx].namlen);
2036 if (typdef)
2037 type = debug_name_type (dhandle, name, type);
2038 else if (tc == 'E' || tc == 'N')
2039 type = debug_tag_type (dhandle, name, type);
2040 else
2042 struct ieee_tag *it;
2044 /* We must allocate all struct tags as indirect types, so
2045 that if we later see a definition of the tag as a C++
2046 record we can update the indirect slot and automatically
2047 change all the existing references. */
2048 it = (struct ieee_tag *) xmalloc (sizeof *it);
2049 memset (it, 0, sizeof *it);
2050 it->next = info->tags;
2051 info->tags = it;
2052 it->name = name;
2053 it->slot = type;
2055 type = debug_make_indirect_type (dhandle, &it->slot, name);
2056 type = debug_tag_type (dhandle, name, type);
2058 it->type = type;
2060 if (type == NULL)
2061 return FALSE;
2064 info->types.types[typeindx].type = type;
2065 info->types.types[typeindx].arg_slots = arg_slots;
2066 info->types.types[typeindx].bitsize = type_bitsize;
2068 /* We may have already allocated type as an indirect type pointing
2069 to slot. It does no harm to replace the indirect type with the
2070 real type. Filling in slot as well handles the indirect types
2071 which are already hanging around. */
2072 if (info->types.types[typeindx].pslot != NULL)
2073 *info->types.types[typeindx].pslot = type;
2075 return TRUE;
2078 /* Parse an ATN record. */
2080 static bfd_boolean
2081 parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp)
2083 const bfd_byte *atn_start, *atn_code_start;
2084 bfd_vma varindx;
2085 struct ieee_var *pvar;
2086 debug_type type;
2087 bfd_vma atn_code;
2088 void *dhandle;
2089 bfd_vma v, v2, v3, v4, v5;
2090 const char *name;
2091 unsigned long namlen;
2092 char *namcopy;
2093 bfd_boolean present;
2094 int blocktype;
2096 atn_start = *pp;
2098 if (! ieee_read_number (info, pp, &varindx)
2099 || ! ieee_read_type_index (info, pp, &type))
2100 return FALSE;
2102 atn_code_start = *pp;
2104 if (! ieee_read_number (info, pp, &atn_code))
2105 return FALSE;
2107 if (varindx == 0)
2109 pvar = NULL;
2110 name = "";
2111 namlen = 0;
2113 else if (varindx < 32)
2115 /* The MRI compiler reportedly sometimes emits variable lifetime
2116 information for a register. We just ignore it. */
2117 if (atn_code == 9)
2118 return ieee_read_number (info, pp, &v);
2120 ieee_error (info, atn_start, _("illegal variable index"));
2121 return FALSE;
2123 else
2125 varindx -= 32;
2126 if (varindx >= info->vars.alloc
2127 || info->vars.vars[varindx].name == NULL)
2129 /* The MRI compiler or linker sometimes omits the NN record
2130 for a pmisc record. */
2131 if (atn_code == 62)
2133 if (varindx >= info->vars.alloc)
2135 unsigned int alloc;
2137 alloc = info->vars.alloc;
2138 if (alloc == 0)
2139 alloc = 4;
2140 while (varindx >= alloc)
2141 alloc *= 2;
2142 info->vars.vars = ((struct ieee_var *)
2143 xrealloc (info->vars.vars,
2144 (alloc
2145 * sizeof *info->vars.vars)));
2146 memset (info->vars.vars + info->vars.alloc, 0,
2147 ((alloc - info->vars.alloc)
2148 * sizeof *info->vars.vars));
2149 info->vars.alloc = alloc;
2152 pvar = info->vars.vars + varindx;
2153 pvar->name = "";
2154 pvar->namlen = 0;
2156 else
2158 ieee_error (info, atn_start, _("undefined variable in ATN"));
2159 return FALSE;
2163 pvar = info->vars.vars + varindx;
2165 pvar->type = type;
2167 name = pvar->name;
2168 namlen = pvar->namlen;
2171 dhandle = info->dhandle;
2173 /* If we are going to call debug_record_variable with a pointer
2174 type, change the type to an indirect type so that we can later
2175 change it to a reference type if we encounter a C++ pmisc 'R'
2176 record. */
2177 if (pvar != NULL
2178 && type != DEBUG_TYPE_NULL
2179 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2181 switch (atn_code)
2183 case 1:
2184 case 2:
2185 case 3:
2186 case 5:
2187 case 8:
2188 case 10:
2189 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2190 *pvar->pslot = type;
2191 type = debug_make_indirect_type (dhandle, pvar->pslot,
2192 (const char *) NULL);
2193 pvar->type = type;
2194 break;
2198 switch (atn_code)
2200 default:
2201 ieee_error (info, atn_code_start, _("unknown ATN type"));
2202 return FALSE;
2204 case 1:
2205 /* Automatic variable. */
2206 if (! ieee_read_number (info, pp, &v))
2207 return FALSE;
2208 namcopy = savestring (name, namlen);
2209 if (type == NULL)
2210 type = debug_make_void_type (dhandle);
2211 if (pvar != NULL)
2212 pvar->kind = IEEE_LOCAL;
2213 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2215 case 2:
2216 /* Register variable. */
2217 if (! ieee_read_number (info, pp, &v))
2218 return FALSE;
2219 namcopy = savestring (name, namlen);
2220 if (type == NULL)
2221 type = debug_make_void_type (dhandle);
2222 if (pvar != NULL)
2223 pvar->kind = IEEE_LOCAL;
2224 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2225 ieee_regno_to_genreg (info->abfd, v));
2227 case 3:
2228 /* Static variable. */
2229 if (! ieee_require_asn (info, pp, &v))
2230 return FALSE;
2231 namcopy = savestring (name, namlen);
2232 if (type == NULL)
2233 type = debug_make_void_type (dhandle);
2234 if (info->blockstack.bsp <= info->blockstack.stack)
2235 blocktype = 0;
2236 else
2237 blocktype = info->blockstack.bsp[-1].kind;
2238 if (pvar != NULL)
2240 if (blocktype == 4 || blocktype == 6)
2241 pvar->kind = IEEE_LOCAL;
2242 else
2243 pvar->kind = IEEE_STATIC;
2245 return debug_record_variable (dhandle, namcopy, type,
2246 (blocktype == 4 || blocktype == 6
2247 ? DEBUG_LOCAL_STATIC
2248 : DEBUG_STATIC),
2251 case 4:
2252 /* External function. We don't currently record these. FIXME. */
2253 if (pvar != NULL)
2254 pvar->kind = IEEE_EXTERNAL;
2255 return TRUE;
2257 case 5:
2258 /* External variable. We don't currently record these. FIXME. */
2259 if (pvar != NULL)
2260 pvar->kind = IEEE_EXTERNAL;
2261 return TRUE;
2263 case 7:
2264 if (! ieee_read_number (info, pp, &v)
2265 || ! ieee_read_number (info, pp, &v2)
2266 || ! ieee_read_optional_number (info, pp, &v3, &present))
2267 return FALSE;
2268 if (present)
2270 if (! ieee_read_optional_number (info, pp, &v4, &present))
2271 return FALSE;
2274 /* We just ignore the two optional fields in v3 and v4, since
2275 they are not defined. */
2277 if (! ieee_require_asn (info, pp, &v3))
2278 return FALSE;
2280 /* We have no way to record the column number. FIXME. */
2282 return debug_record_line (dhandle, v, v3);
2284 case 8:
2285 /* Global variable. */
2286 if (! ieee_require_asn (info, pp, &v))
2287 return FALSE;
2288 namcopy = savestring (name, namlen);
2289 if (type == NULL)
2290 type = debug_make_void_type (dhandle);
2291 if (pvar != NULL)
2292 pvar->kind = IEEE_GLOBAL;
2293 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2295 case 9:
2296 /* Variable lifetime information. */
2297 if (! ieee_read_number (info, pp, &v))
2298 return FALSE;
2300 /* We have no way to record this information. FIXME. */
2301 return TRUE;
2303 case 10:
2304 /* Locked register. The spec says that there are two required
2305 fields, but at least on occasion the MRI compiler only emits
2306 one. */
2307 if (! ieee_read_number (info, pp, &v)
2308 || ! ieee_read_optional_number (info, pp, &v2, &present))
2309 return FALSE;
2311 /* I think this means a variable that is both in a register and
2312 a frame slot. We ignore the frame slot. FIXME. */
2314 namcopy = savestring (name, namlen);
2315 if (type == NULL)
2316 type = debug_make_void_type (dhandle);
2317 if (pvar != NULL)
2318 pvar->kind = IEEE_LOCAL;
2319 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2321 case 11:
2322 /* Reserved for FORTRAN common. */
2323 ieee_error (info, atn_code_start, _("unsupported ATN11"));
2325 /* Return TRUE to keep going. */
2326 return TRUE;
2328 case 12:
2329 /* Based variable. */
2330 v3 = 0;
2331 v4 = 0x80;
2332 v5 = 0;
2333 if (! ieee_read_number (info, pp, &v)
2334 || ! ieee_read_number (info, pp, &v2)
2335 || ! ieee_read_optional_number (info, pp, &v3, &present))
2336 return FALSE;
2337 if (present)
2339 if (! ieee_read_optional_number (info, pp, &v4, &present))
2340 return FALSE;
2341 if (present)
2343 if (! ieee_read_optional_number (info, pp, &v5, &present))
2344 return FALSE;
2348 /* We have no way to record this information. FIXME. */
2350 ieee_error (info, atn_code_start, _("unsupported ATN12"));
2352 /* Return TRUE to keep going. */
2353 return TRUE;
2355 case 16:
2356 /* Constant. The description of this that I have is ambiguous,
2357 so I'm not going to try to implement it. */
2358 if (! ieee_read_number (info, pp, &v)
2359 || ! ieee_read_optional_number (info, pp, &v2, &present))
2360 return FALSE;
2361 if (present)
2363 if (! ieee_read_optional_number (info, pp, &v2, &present))
2364 return FALSE;
2365 if (present)
2367 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2368 return FALSE;
2372 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2374 if (! ieee_require_asn (info, pp, &v3))
2375 return FALSE;
2378 return TRUE;
2380 case 19:
2381 /* Static variable from assembler. */
2382 v2 = 0;
2383 if (! ieee_read_number (info, pp, &v)
2384 || ! ieee_read_optional_number (info, pp, &v2, &present)
2385 || ! ieee_require_asn (info, pp, &v3))
2386 return FALSE;
2387 namcopy = savestring (name, namlen);
2388 /* We don't really handle this correctly. FIXME. */
2389 return debug_record_variable (dhandle, namcopy,
2390 debug_make_void_type (dhandle),
2391 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2392 v3);
2394 case 62:
2395 /* Procedure miscellaneous information. */
2396 case 63:
2397 /* Variable miscellaneous information. */
2398 case 64:
2399 /* Module miscellaneous information. */
2400 if (! ieee_read_number (info, pp, &v)
2401 || ! ieee_read_number (info, pp, &v2)
2402 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2403 return FALSE;
2405 if (atn_code == 62 && v == 80)
2407 if (present)
2409 ieee_error (info, atn_code_start,
2410 _("unexpected string in C++ misc"));
2411 return FALSE;
2413 return ieee_read_cxx_misc (info, pp, v2);
2416 /* We just ignore all of this stuff. FIXME. */
2418 for (; v2 > 0; --v2)
2420 switch ((ieee_record_enum_type) **pp)
2422 default:
2423 ieee_error (info, *pp, _("bad misc record"));
2424 return FALSE;
2426 case ieee_at_record_enum:
2427 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2428 return FALSE;
2429 break;
2431 case ieee_e2_first_byte_enum:
2432 if (! ieee_require_asn (info, pp, &v3))
2433 return FALSE;
2434 break;
2438 return TRUE;
2441 /*NOTREACHED*/
2444 /* Handle C++ debugging miscellaneous records. This is called for
2445 procedure miscellaneous records of type 80. */
2447 static bfd_boolean
2448 ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp,
2449 unsigned long count)
2451 const bfd_byte *start;
2452 bfd_vma category;
2454 start = *pp;
2456 /* Get the category of C++ misc record. */
2457 if (! ieee_require_asn (info, pp, &category))
2458 return FALSE;
2459 --count;
2461 switch (category)
2463 default:
2464 ieee_error (info, start, _("unrecognized C++ misc record"));
2465 return FALSE;
2467 case 'T':
2468 if (! ieee_read_cxx_class (info, pp, count))
2469 return FALSE;
2470 break;
2472 case 'M':
2474 bfd_vma flags;
2475 const char *name;
2476 unsigned long namlen;
2478 /* The IEEE spec indicates that the 'M' record only has a
2479 flags field. The MRI compiler also emits the name of the
2480 function. */
2482 if (! ieee_require_asn (info, pp, &flags))
2483 return FALSE;
2484 if (*pp < info->pend
2485 && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2487 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2488 return FALSE;
2491 /* This is emitted for method functions, but I don't think we
2492 care very much. It might help if it told us useful
2493 information like the class with which this function is
2494 associated, but it doesn't, so it isn't helpful. */
2496 break;
2498 case 'B':
2499 if (! ieee_read_cxx_defaults (info, pp, count))
2500 return FALSE;
2501 break;
2503 case 'z':
2505 const char *name, *mangled, *cxx_class;
2506 unsigned long namlen, mangledlen, classlen;
2507 bfd_vma control;
2509 /* Pointer to member. */
2511 if (! ieee_require_atn65 (info, pp, &name, &namlen)
2512 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2513 || ! ieee_require_atn65 (info, pp, &cxx_class, &classlen)
2514 || ! ieee_require_asn (info, pp, &control))
2515 return FALSE;
2517 /* FIXME: We should now track down name and change its type. */
2519 break;
2521 case 'R':
2522 if (! ieee_read_reference (info, pp))
2523 return FALSE;
2524 break;
2527 return TRUE;
2530 /* Read a C++ class definition. This is a pmisc type 80 record of
2531 category 'T'. */
2533 static bfd_boolean
2534 ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp,
2535 unsigned long count)
2537 const bfd_byte *start;
2538 bfd_vma cxx_class;
2539 const char *tag;
2540 unsigned long taglen;
2541 struct ieee_tag *it;
2542 void *dhandle;
2543 debug_field *fields;
2544 unsigned int field_count, field_alloc;
2545 debug_baseclass *baseclasses;
2546 unsigned int baseclasses_count, baseclasses_alloc;
2547 const debug_field *structfields;
2548 struct ieee_method
2550 const char *name;
2551 unsigned long namlen;
2552 debug_method_variant *variants;
2553 unsigned count;
2554 unsigned int alloc;
2555 } *methods;
2556 unsigned int methods_count, methods_alloc;
2557 debug_type vptrbase;
2558 bfd_boolean ownvptr;
2559 debug_method *dmethods;
2561 start = *pp;
2563 if (! ieee_require_asn (info, pp, &cxx_class))
2564 return FALSE;
2565 --count;
2567 if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2568 return FALSE;
2569 --count;
2571 /* Find the C struct with this name. */
2572 for (it = info->tags; it != NULL; it = it->next)
2573 if (it->name[0] == tag[0]
2574 && strncmp (it->name, tag, taglen) == 0
2575 && strlen (it->name) == taglen)
2576 break;
2577 if (it == NULL)
2579 ieee_error (info, start, _("undefined C++ object"));
2580 return FALSE;
2583 dhandle = info->dhandle;
2585 fields = NULL;
2586 field_count = 0;
2587 field_alloc = 0;
2588 baseclasses = NULL;
2589 baseclasses_count = 0;
2590 baseclasses_alloc = 0;
2591 methods = NULL;
2592 methods_count = 0;
2593 methods_alloc = 0;
2594 vptrbase = DEBUG_TYPE_NULL;
2595 ownvptr = FALSE;
2597 structfields = debug_get_fields (dhandle, it->type);
2599 while (count > 0)
2601 bfd_vma id;
2602 const bfd_byte *spec_start;
2604 spec_start = *pp;
2606 if (! ieee_require_asn (info, pp, &id))
2607 return FALSE;
2608 --count;
2610 switch (id)
2612 default:
2613 ieee_error (info, spec_start, _("unrecognized C++ object spec"));
2614 return FALSE;
2616 case 'b':
2618 bfd_vma flags, cinline;
2619 const char *base, *fieldname;
2620 unsigned long baselen, fieldlen;
2621 char *basecopy;
2622 debug_type basetype;
2623 bfd_vma bitpos;
2624 bfd_boolean virtualp;
2625 enum debug_visibility visibility;
2626 debug_baseclass baseclass;
2628 /* This represents a base or friend class. */
2630 if (! ieee_require_asn (info, pp, &flags)
2631 || ! ieee_require_atn65 (info, pp, &base, &baselen)
2632 || ! ieee_require_asn (info, pp, &cinline)
2633 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2634 return FALSE;
2635 count -= 4;
2637 /* We have no way of recording friend information, so we
2638 just ignore it. */
2639 if ((flags & BASEFLAGS_FRIEND) != 0)
2640 break;
2642 /* I assume that either all of the members of the
2643 baseclass are included in the object, starting at the
2644 beginning of the object, or that none of them are
2645 included. */
2647 if ((fieldlen == 0) == (cinline == 0))
2649 ieee_error (info, start, _("unsupported C++ object type"));
2650 return FALSE;
2653 basecopy = savestring (base, baselen);
2654 basetype = debug_find_tagged_type (dhandle, basecopy,
2655 DEBUG_KIND_ILLEGAL);
2656 free (basecopy);
2657 if (basetype == DEBUG_TYPE_NULL)
2659 ieee_error (info, start, _("C++ base class not defined"));
2660 return FALSE;
2663 if (fieldlen == 0)
2664 bitpos = 0;
2665 else
2667 const debug_field *pf;
2669 if (structfields == NULL)
2671 ieee_error (info, start, _("C++ object has no fields"));
2672 return FALSE;
2675 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2677 const char *fname;
2679 fname = debug_get_field_name (dhandle, *pf);
2680 if (fname == NULL)
2681 return FALSE;
2682 if (fname[0] == fieldname[0]
2683 && strncmp (fname, fieldname, fieldlen) == 0
2684 && strlen (fname) == fieldlen)
2685 break;
2687 if (*pf == DEBUG_FIELD_NULL)
2689 ieee_error (info, start,
2690 _("C++ base class not found in container"));
2691 return FALSE;
2694 bitpos = debug_get_field_bitpos (dhandle, *pf);
2697 if ((flags & BASEFLAGS_VIRTUAL) != 0)
2698 virtualp = TRUE;
2699 else
2700 virtualp = FALSE;
2701 if ((flags & BASEFLAGS_PRIVATE) != 0)
2702 visibility = DEBUG_VISIBILITY_PRIVATE;
2703 else
2704 visibility = DEBUG_VISIBILITY_PUBLIC;
2706 baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2707 virtualp, visibility);
2708 if (baseclass == DEBUG_BASECLASS_NULL)
2709 return FALSE;
2711 if (baseclasses_count + 1 >= baseclasses_alloc)
2713 baseclasses_alloc += 10;
2714 baseclasses = ((debug_baseclass *)
2715 xrealloc (baseclasses,
2716 (baseclasses_alloc
2717 * sizeof *baseclasses)));
2720 baseclasses[baseclasses_count] = baseclass;
2721 ++baseclasses_count;
2722 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2724 break;
2726 case 'd':
2728 bfd_vma flags;
2729 const char *fieldname, *mangledname;
2730 unsigned long fieldlen, mangledlen;
2731 char *fieldcopy;
2732 bfd_boolean staticp;
2733 debug_type ftype;
2734 const debug_field *pf = NULL;
2735 enum debug_visibility visibility;
2736 debug_field field;
2738 /* This represents a data member. */
2740 if (! ieee_require_asn (info, pp, &flags)
2741 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2742 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2743 return FALSE;
2744 count -= 3;
2746 fieldcopy = savestring (fieldname, fieldlen);
2748 staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;
2750 if (staticp)
2752 struct ieee_var *pv, *pvend;
2754 /* See if we can find a definition for this variable. */
2755 pv = info->vars.vars;
2756 pvend = pv + info->vars.alloc;
2757 for (; pv < pvend; pv++)
2758 if (pv->namlen == mangledlen
2759 && strncmp (pv->name, mangledname, mangledlen) == 0)
2760 break;
2761 if (pv < pvend)
2762 ftype = pv->type;
2763 else
2765 /* This can happen if the variable is never used. */
2766 ftype = ieee_builtin_type (info, start,
2767 (unsigned int) builtin_void);
2770 else
2772 unsigned int findx;
2774 if (structfields == NULL)
2776 ieee_error (info, start, _("C++ object has no fields"));
2777 return FALSE;
2780 for (pf = structfields, findx = 0;
2781 *pf != DEBUG_FIELD_NULL;
2782 pf++, findx++)
2784 const char *fname;
2786 fname = debug_get_field_name (dhandle, *pf);
2787 if (fname == NULL)
2788 return FALSE;
2789 if (fname[0] == mangledname[0]
2790 && strncmp (fname, mangledname, mangledlen) == 0
2791 && strlen (fname) == mangledlen)
2792 break;
2794 if (*pf == DEBUG_FIELD_NULL)
2796 ieee_error (info, start,
2797 _("C++ data member not found in container"));
2798 return FALSE;
2801 ftype = debug_get_field_type (dhandle, *pf);
2803 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2805 /* We might need to convert this field into a
2806 reference type later on, so make it an indirect
2807 type. */
2808 if (it->fslots == NULL)
2810 unsigned int fcnt;
2811 const debug_field *pfcnt;
2813 fcnt = 0;
2814 for (pfcnt = structfields;
2815 *pfcnt != DEBUG_FIELD_NULL;
2816 pfcnt++)
2817 ++fcnt;
2818 it->fslots = ((debug_type *)
2819 xmalloc (fcnt * sizeof *it->fslots));
2820 memset (it->fslots, 0,
2821 fcnt * sizeof *it->fslots);
2824 if (ftype == DEBUG_TYPE_NULL)
2825 return FALSE;
2826 it->fslots[findx] = ftype;
2827 ftype = debug_make_indirect_type (dhandle,
2828 it->fslots + findx,
2829 (const char *) NULL);
2832 if (ftype == DEBUG_TYPE_NULL)
2833 return FALSE;
2835 switch (flags & CXXFLAGS_VISIBILITY)
2837 default:
2838 ieee_error (info, start, _("unknown C++ visibility"));
2839 return FALSE;
2841 case CXXFLAGS_VISIBILITY_PUBLIC:
2842 visibility = DEBUG_VISIBILITY_PUBLIC;
2843 break;
2845 case CXXFLAGS_VISIBILITY_PRIVATE:
2846 visibility = DEBUG_VISIBILITY_PRIVATE;
2847 break;
2849 case CXXFLAGS_VISIBILITY_PROTECTED:
2850 visibility = DEBUG_VISIBILITY_PROTECTED;
2851 break;
2854 if (staticp)
2856 char *mangledcopy;
2858 mangledcopy = savestring (mangledname, mangledlen);
2860 field = debug_make_static_member (dhandle, fieldcopy,
2861 ftype, mangledcopy,
2862 visibility);
2864 else
2866 bfd_vma bitpos, bitsize;
2868 bitpos = debug_get_field_bitpos (dhandle, *pf);
2869 bitsize = debug_get_field_bitsize (dhandle, *pf);
2870 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2872 ieee_error (info, start, _("bad C++ field bit pos or size"));
2873 return FALSE;
2875 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2876 bitsize, visibility);
2879 if (field == DEBUG_FIELD_NULL)
2880 return FALSE;
2882 if (field_count + 1 >= field_alloc)
2884 field_alloc += 10;
2885 fields = ((debug_field *)
2886 xrealloc (fields, field_alloc * sizeof *fields));
2889 fields[field_count] = field;
2890 ++field_count;
2891 fields[field_count] = DEBUG_FIELD_NULL;
2893 break;
2895 case 'm':
2896 case 'v':
2898 bfd_vma flags, voffset, control;
2899 const char *name, *mangled;
2900 unsigned long namlen, mangledlen;
2901 struct ieee_var *pv, *pvend;
2902 debug_type type;
2903 enum debug_visibility visibility;
2904 bfd_boolean constp, volatilep;
2905 char *mangledcopy;
2906 debug_method_variant mv;
2907 struct ieee_method *meth;
2908 unsigned int im;
2910 if (! ieee_require_asn (info, pp, &flags)
2911 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2912 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2913 return FALSE;
2914 count -= 3;
2915 if (id != 'v')
2916 voffset = 0;
2917 else
2919 if (! ieee_require_asn (info, pp, &voffset))
2920 return FALSE;
2921 --count;
2923 if (! ieee_require_asn (info, pp, &control))
2924 return FALSE;
2925 --count;
2927 /* We just ignore the control information. */
2929 /* We have no way to represent friend information, so we
2930 just ignore it. */
2931 if ((flags & CXXFLAGS_FRIEND) != 0)
2932 break;
2934 /* We should already have seen a type for the function. */
2935 pv = info->vars.vars;
2936 pvend = pv + info->vars.alloc;
2937 for (; pv < pvend; pv++)
2938 if (pv->namlen == mangledlen
2939 && strncmp (pv->name, mangled, mangledlen) == 0)
2940 break;
2942 if (pv >= pvend)
2944 /* We won't have type information for this function if
2945 it is not included in this file. We don't try to
2946 handle this case. FIXME. */
2947 type = (debug_make_function_type
2948 (dhandle,
2949 ieee_builtin_type (info, start,
2950 (unsigned int) builtin_void),
2951 (debug_type *) NULL,
2952 FALSE));
2954 else
2956 debug_type return_type;
2957 const debug_type *arg_types;
2958 bfd_boolean varargs;
2960 if (debug_get_type_kind (dhandle, pv->type)
2961 != DEBUG_KIND_FUNCTION)
2963 ieee_error (info, start,
2964 _("bad type for C++ method function"));
2965 return FALSE;
2968 return_type = debug_get_return_type (dhandle, pv->type);
2969 arg_types = debug_get_parameter_types (dhandle, pv->type,
2970 &varargs);
2971 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
2973 ieee_error (info, start,
2974 _("no type information for C++ method function"));
2975 return FALSE;
2978 type = debug_make_method_type (dhandle, return_type, it->type,
2979 (debug_type *) arg_types,
2980 varargs);
2982 if (type == DEBUG_TYPE_NULL)
2983 return FALSE;
2985 switch (flags & CXXFLAGS_VISIBILITY)
2987 default:
2988 ieee_error (info, start, _("unknown C++ visibility"));
2989 return FALSE;
2991 case CXXFLAGS_VISIBILITY_PUBLIC:
2992 visibility = DEBUG_VISIBILITY_PUBLIC;
2993 break;
2995 case CXXFLAGS_VISIBILITY_PRIVATE:
2996 visibility = DEBUG_VISIBILITY_PRIVATE;
2997 break;
2999 case CXXFLAGS_VISIBILITY_PROTECTED:
3000 visibility = DEBUG_VISIBILITY_PROTECTED;
3001 break;
3004 constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
3005 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;
3007 mangledcopy = savestring (mangled, mangledlen);
3009 if ((flags & CXXFLAGS_STATIC) != 0)
3011 if (id == 'v')
3013 ieee_error (info, start, _("C++ static virtual method"));
3014 return FALSE;
3016 mv = debug_make_static_method_variant (dhandle, mangledcopy,
3017 type, visibility,
3018 constp, volatilep);
3020 else
3022 debug_type vcontext;
3024 if (id != 'v')
3025 vcontext = DEBUG_TYPE_NULL;
3026 else
3028 /* FIXME: How can we calculate this correctly? */
3029 vcontext = it->type;
3031 mv = debug_make_method_variant (dhandle, mangledcopy, type,
3032 visibility, constp,
3033 volatilep, voffset,
3034 vcontext);
3036 if (mv == DEBUG_METHOD_VARIANT_NULL)
3037 return FALSE;
3039 for (meth = methods, im = 0; im < methods_count; meth++, im++)
3040 if (meth->namlen == namlen
3041 && strncmp (meth->name, name, namlen) == 0)
3042 break;
3043 if (im >= methods_count)
3045 if (methods_count >= methods_alloc)
3047 methods_alloc += 10;
3048 methods = ((struct ieee_method *)
3049 xrealloc (methods,
3050 methods_alloc * sizeof *methods));
3052 methods[methods_count].name = name;
3053 methods[methods_count].namlen = namlen;
3054 methods[methods_count].variants = NULL;
3055 methods[methods_count].count = 0;
3056 methods[methods_count].alloc = 0;
3057 meth = methods + methods_count;
3058 ++methods_count;
3061 if (meth->count + 1 >= meth->alloc)
3063 meth->alloc += 10;
3064 meth->variants = ((debug_method_variant *)
3065 xrealloc (meth->variants,
3066 (meth->alloc
3067 * sizeof *meth->variants)));
3070 meth->variants[meth->count] = mv;
3071 ++meth->count;
3072 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
3074 break;
3076 case 'o':
3078 bfd_vma spec;
3080 /* We have no way to store this information, so we just
3081 ignore it. */
3082 if (! ieee_require_asn (info, pp, &spec))
3083 return FALSE;
3084 --count;
3085 if ((spec & 4) != 0)
3087 const char *filename;
3088 unsigned long filenamlen;
3089 bfd_vma lineno;
3091 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
3092 || ! ieee_require_asn (info, pp, &lineno))
3093 return FALSE;
3094 count -= 2;
3096 else if ((spec & 8) != 0)
3098 const char *mangled;
3099 unsigned long mangledlen;
3101 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
3102 return FALSE;
3103 --count;
3105 else
3107 ieee_error (info, start,
3108 _("unrecognized C++ object overhead spec"));
3109 return FALSE;
3112 break;
3114 case 'z':
3116 const char *vname, *base;
3117 unsigned long vnamelen, baselen;
3118 bfd_vma vsize, control;
3120 /* A virtual table pointer. */
3122 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3123 || ! ieee_require_asn (info, pp, &vsize)
3124 || ! ieee_require_atn65 (info, pp, &base, &baselen)
3125 || ! ieee_require_asn (info, pp, &control))
3126 return FALSE;
3127 count -= 4;
3129 /* We just ignore the control number. We don't care what
3130 the virtual table name is. We have no way to store the
3131 virtual table size, and I don't think we care anyhow. */
3133 /* FIXME: We can't handle multiple virtual table pointers. */
3135 if (baselen == 0)
3136 ownvptr = TRUE;
3137 else
3139 char *basecopy;
3141 basecopy = savestring (base, baselen);
3142 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3143 DEBUG_KIND_ILLEGAL);
3144 free (basecopy);
3145 if (vptrbase == DEBUG_TYPE_NULL)
3147 ieee_error (info, start, _("undefined C++ vtable"));
3148 return FALSE;
3152 break;
3156 /* Now that we have seen all the method variants, we can call
3157 debug_make_method for each one. */
3159 if (methods_count == 0)
3160 dmethods = NULL;
3161 else
3163 unsigned int i;
3165 dmethods = ((debug_method *)
3166 xmalloc ((methods_count + 1) * sizeof *dmethods));
3167 for (i = 0; i < methods_count; i++)
3169 char *namcopy;
3171 namcopy = savestring (methods[i].name, methods[i].namlen);
3172 dmethods[i] = debug_make_method (dhandle, namcopy,
3173 methods[i].variants);
3174 if (dmethods[i] == DEBUG_METHOD_NULL)
3175 return FALSE;
3177 dmethods[i] = DEBUG_METHOD_NULL;
3178 free (methods);
3181 /* The struct type was created as an indirect type pointing at
3182 it->slot. We update it->slot to automatically update all
3183 references to this struct. */
3184 it->slot = debug_make_object_type (dhandle,
3185 cxx_class != 'u',
3186 debug_get_type_size (dhandle,
3187 it->slot),
3188 fields, baseclasses, dmethods,
3189 vptrbase, ownvptr);
3190 if (it->slot == DEBUG_TYPE_NULL)
3191 return FALSE;
3193 return TRUE;
3196 /* Read C++ default argument value and reference type information. */
3198 static bfd_boolean
3199 ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp,
3200 unsigned long count)
3202 const bfd_byte *start;
3203 const char *fnname;
3204 unsigned long fnlen;
3205 bfd_vma defcount;
3207 start = *pp;
3209 /* Giving the function name before the argument count is an addendum
3210 to the spec. The function name is demangled, though, so this
3211 record must always refer to the current function. */
3213 if (info->blockstack.bsp <= info->blockstack.stack
3214 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3216 ieee_error (info, start, _("C++ default values not in a function"));
3217 return FALSE;
3220 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3221 || ! ieee_require_asn (info, pp, &defcount))
3222 return FALSE;
3223 count -= 2;
3225 while (defcount-- > 0)
3227 bfd_vma type, val;
3228 const char *strval;
3229 unsigned long strvallen;
3231 if (! ieee_require_asn (info, pp, &type))
3232 return FALSE;
3233 --count;
3235 switch (type)
3237 case 0:
3238 case 4:
3239 break;
3241 case 1:
3242 case 2:
3243 if (! ieee_require_asn (info, pp, &val))
3244 return FALSE;
3245 --count;
3246 break;
3248 case 3:
3249 case 7:
3250 if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3251 return FALSE;
3252 --count;
3253 break;
3255 default:
3256 ieee_error (info, start, _("unrecognized C++ default type"));
3257 return FALSE;
3260 /* We have no way to record the default argument values, so we
3261 just ignore them. FIXME. */
3264 /* Any remaining arguments are indices of parameters that are really
3265 reference type. */
3266 if (count > 0)
3268 void *dhandle;
3269 debug_type *arg_slots;
3271 dhandle = info->dhandle;
3272 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3273 while (count-- > 0)
3275 bfd_vma indx;
3276 debug_type target;
3278 if (! ieee_require_asn (info, pp, &indx))
3279 return FALSE;
3280 /* The index is 1 based. */
3281 --indx;
3282 if (arg_slots == NULL
3283 || arg_slots[indx] == DEBUG_TYPE_NULL
3284 || (debug_get_type_kind (dhandle, arg_slots[indx])
3285 != DEBUG_KIND_POINTER))
3287 ieee_error (info, start, _("reference parameter is not a pointer"));
3288 return FALSE;
3291 target = debug_get_target_type (dhandle, arg_slots[indx]);
3292 arg_slots[indx] = debug_make_reference_type (dhandle, target);
3293 if (arg_slots[indx] == DEBUG_TYPE_NULL)
3294 return FALSE;
3298 return TRUE;
3301 /* Read a C++ reference definition. */
3303 static bfd_boolean
3304 ieee_read_reference (struct ieee_info *info, const bfd_byte **pp)
3306 const bfd_byte *start;
3307 bfd_vma flags;
3308 const char *cxx_class, *name;
3309 unsigned long classlen, namlen;
3310 debug_type *pslot;
3311 debug_type target;
3313 start = *pp;
3315 if (! ieee_require_asn (info, pp, &flags))
3316 return FALSE;
3318 /* Giving the class name before the member name is in an addendum to
3319 the spec. */
3320 if (flags == 3)
3322 if (! ieee_require_atn65 (info, pp, &cxx_class, &classlen))
3323 return FALSE;
3326 if (! ieee_require_atn65 (info, pp, &name, &namlen))
3327 return FALSE;
3329 pslot = NULL;
3330 if (flags != 3)
3332 int pass;
3334 /* We search from the last variable indices to the first in
3335 hopes of finding local variables correctly. We search the
3336 local variables on the first pass, and the global variables
3337 on the second. FIXME: This probably won't work in all cases.
3338 On the other hand, I don't know what will. */
3339 for (pass = 0; pass < 2; pass++)
3341 struct ieee_vars *vars;
3342 int i;
3343 struct ieee_var *pv = NULL;
3345 if (pass == 0)
3346 vars = &info->vars;
3347 else
3349 vars = info->global_vars;
3350 if (vars == NULL)
3351 break;
3354 for (i = (int) vars->alloc - 1; i >= 0; i--)
3356 bfd_boolean found;
3358 pv = vars->vars + i;
3360 if (pv->pslot == NULL
3361 || pv->namlen != namlen
3362 || strncmp (pv->name, name, namlen) != 0)
3363 continue;
3365 found = FALSE;
3366 switch (flags)
3368 default:
3369 ieee_error (info, start,
3370 _("unrecognized C++ reference type"));
3371 return FALSE;
3373 case 0:
3374 /* Global variable or function. */
3375 if (pv->kind == IEEE_GLOBAL
3376 || pv->kind == IEEE_EXTERNAL
3377 || pv->kind == IEEE_FUNCTION)
3378 found = TRUE;
3379 break;
3381 case 1:
3382 /* Global static variable or function. */
3383 if (pv->kind == IEEE_STATIC
3384 || pv->kind == IEEE_FUNCTION)
3385 found = TRUE;
3386 break;
3388 case 2:
3389 /* Local variable. */
3390 if (pv->kind == IEEE_LOCAL)
3391 found = TRUE;
3392 break;
3395 if (found)
3396 break;
3399 if (i >= 0)
3401 pslot = pv->pslot;
3402 break;
3406 else
3408 struct ieee_tag *it;
3410 for (it = info->tags; it != NULL; it = it->next)
3412 if (it->name[0] == cxx_class[0]
3413 && strncmp (it->name, cxx_class, classlen) == 0
3414 && strlen (it->name) == classlen)
3416 if (it->fslots != NULL)
3418 const debug_field *pf;
3419 unsigned int findx;
3421 pf = debug_get_fields (info->dhandle, it->type);
3422 if (pf == NULL)
3424 ieee_error (info, start,
3425 "C++ reference in class with no fields");
3426 return FALSE;
3429 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3431 const char *fname;
3433 fname = debug_get_field_name (info->dhandle, *pf);
3434 if (fname == NULL)
3435 return FALSE;
3436 if (strncmp (fname, name, namlen) == 0
3437 && strlen (fname) == namlen)
3439 pslot = it->fslots + findx;
3440 break;
3445 break;
3450 if (pslot == NULL)
3452 ieee_error (info, start, _("C++ reference not found"));
3453 return FALSE;
3456 /* We allocated the type of the object as an indirect type pointing
3457 to *pslot, which we can now update to be a reference type. */
3458 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3460 ieee_error (info, start, _("C++ reference is not pointer"));
3461 return FALSE;
3464 target = debug_get_target_type (info->dhandle, *pslot);
3465 *pslot = debug_make_reference_type (info->dhandle, target);
3466 if (*pslot == DEBUG_TYPE_NULL)
3467 return FALSE;
3469 return TRUE;
3472 /* Require an ASN record. */
3474 static bfd_boolean
3475 ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
3477 const bfd_byte *start;
3478 ieee_record_enum_type c;
3479 bfd_vma varindx;
3481 start = *pp;
3483 c = (ieee_record_enum_type) **pp;
3484 if (c != ieee_e2_first_byte_enum)
3486 ieee_error (info, start, _("missing required ASN"));
3487 return FALSE;
3489 ++*pp;
3491 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3492 if (c != ieee_asn_record_enum)
3494 ieee_error (info, start, _("missing required ASN"));
3495 return FALSE;
3497 ++*pp;
3499 /* Just ignore the variable index. */
3500 if (! ieee_read_number (info, pp, &varindx))
3501 return FALSE;
3503 return ieee_read_expression (info, pp, pv);
3506 /* Require an ATN65 record. */
3508 static bfd_boolean
3509 ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp,
3510 const char **pname, unsigned long *pnamlen)
3512 const bfd_byte *start;
3513 ieee_record_enum_type c;
3514 bfd_vma name_indx, type_indx, atn_code;
3516 start = *pp;
3518 c = (ieee_record_enum_type) **pp;
3519 if (c != ieee_at_record_enum)
3521 ieee_error (info, start, _("missing required ATN65"));
3522 return FALSE;
3524 ++*pp;
3526 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3527 if (c != ieee_atn_record_enum)
3529 ieee_error (info, start, _("missing required ATN65"));
3530 return FALSE;
3532 ++*pp;
3534 if (! ieee_read_number (info, pp, &name_indx)
3535 || ! ieee_read_number (info, pp, &type_indx)
3536 || ! ieee_read_number (info, pp, &atn_code))
3537 return FALSE;
3539 /* Just ignore name_indx. */
3541 if (type_indx != 0 || atn_code != 65)
3543 ieee_error (info, start, _("bad ATN65 record"));
3544 return FALSE;
3547 return ieee_read_id (info, pp, pname, pnamlen);
3550 /* Convert a register number in IEEE debugging information into a
3551 generic register number. */
3553 static int
3554 ieee_regno_to_genreg (bfd *abfd, int r)
3556 switch (bfd_get_arch (abfd))
3558 case bfd_arch_m68k:
3559 /* For some reasons stabs adds 2 to the floating point register
3560 numbers. */
3561 if (r >= 16)
3562 r += 2;
3563 break;
3565 case bfd_arch_i960:
3566 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3567 32 to 35 for fp0 to fp3. */
3568 --r;
3569 break;
3571 default:
3572 break;
3575 return r;
3578 /* Convert a generic register number to an IEEE specific one. */
3580 static int
3581 ieee_genreg_to_regno (bfd *abfd, int r)
3583 switch (bfd_get_arch (abfd))
3585 case bfd_arch_m68k:
3586 /* For some reason stabs add 2 to the floating point register
3587 numbers. */
3588 if (r >= 18)
3589 r -= 2;
3590 break;
3592 case bfd_arch_i960:
3593 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3594 32 to 35 for fp0 to fp3. */
3595 ++r;
3596 break;
3598 default:
3599 break;
3602 return r;
3605 /* These routines build IEEE debugging information out of the generic
3606 debugging information. */
3608 /* We build the IEEE debugging information byte by byte. Rather than
3609 waste time copying data around, we use a linked list of buffers to
3610 hold the data. */
3612 #define IEEE_BUFSIZE (490)
3614 struct ieee_buf
3616 /* Next buffer. */
3617 struct ieee_buf *next;
3618 /* Number of data bytes in this buffer. */
3619 unsigned int c;
3620 /* Bytes. */
3621 bfd_byte buf[IEEE_BUFSIZE];
3624 /* A list of buffers. */
3626 struct ieee_buflist
3628 /* Head of list. */
3629 struct ieee_buf *head;
3630 /* Tail--last buffer on list. */
3631 struct ieee_buf *tail;
3634 /* In order to generate the BB11 blocks required by the HP emulator,
3635 we keep track of ranges of addresses which correspond to a given
3636 compilation unit. */
3638 struct ieee_range
3640 /* Next range. */
3641 struct ieee_range *next;
3642 /* Low address. */
3643 bfd_vma low;
3644 /* High address. */
3645 bfd_vma high;
3648 /* This structure holds information for a class on the type stack. */
3650 struct ieee_type_class
3652 /* The name index in the debugging information. */
3653 unsigned int indx;
3654 /* The pmisc records for the class. */
3655 struct ieee_buflist pmiscbuf;
3656 /* The number of pmisc records. */
3657 unsigned int pmisccount;
3658 /* The name of the class holding the virtual table, if not this
3659 class. */
3660 const char *vclass;
3661 /* Whether this class holds its own virtual table. */
3662 bfd_boolean ownvptr;
3663 /* The largest virtual table offset seen so far. */
3664 bfd_vma voffset;
3665 /* The current method. */
3666 const char *method;
3667 /* Additional pmisc records used to record fields of reference type. */
3668 struct ieee_buflist refs;
3671 /* This is how we store types for the writing routines. Most types
3672 are simply represented by a type index. */
3674 struct ieee_write_type
3676 /* Type index. */
3677 unsigned int indx;
3678 /* The size of the type, if known. */
3679 unsigned int size;
3680 /* The name of the type, if any. */
3681 const char *name;
3682 /* If this is a function or method type, we build the type here, and
3683 only add it to the output buffers if we need it. */
3684 struct ieee_buflist fndef;
3685 /* If this is a struct, this is where the struct definition is
3686 built. */
3687 struct ieee_buflist strdef;
3688 /* If this is a class, this is where the class information is built. */
3689 struct ieee_type_class *classdef;
3690 /* Whether the type is unsigned. */
3691 unsigned int unsignedp : 1;
3692 /* Whether this is a reference type. */
3693 unsigned int referencep : 1;
3694 /* Whether this is in the local type block. */
3695 unsigned int localp : 1;
3696 /* Whether this is a duplicate struct definition which we are
3697 ignoring. */
3698 unsigned int ignorep : 1;
3701 /* This is the type stack used by the debug writing routines. FIXME:
3702 We could generate more efficient output if we remembered when we
3703 have output a particular type before. */
3705 struct ieee_type_stack
3707 /* Next entry on stack. */
3708 struct ieee_type_stack *next;
3709 /* Type information. */
3710 struct ieee_write_type type;
3713 /* This is a list of associations between a name and some types.
3714 These are used for typedefs and tags. */
3716 struct ieee_name_type
3718 /* Next type for this name. */
3719 struct ieee_name_type *next;
3720 /* ID number. For a typedef, this is the index of the type to which
3721 this name is typedefed. */
3722 unsigned int id;
3723 /* Type. */
3724 struct ieee_write_type type;
3725 /* If this is a tag which has not yet been defined, this is the
3726 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3727 enum debug_type_kind kind;
3730 /* We use a hash table to associate names and types. */
3732 struct ieee_name_type_hash_table
3734 struct bfd_hash_table root;
3737 struct ieee_name_type_hash_entry
3739 struct bfd_hash_entry root;
3740 /* Information for this name. */
3741 struct ieee_name_type *types;
3744 /* This is a list of enums. */
3746 struct ieee_defined_enum
3748 /* Next enum. */
3749 struct ieee_defined_enum *next;
3750 /* Type index. */
3751 unsigned int indx;
3752 /* Whether this enum has been defined. */
3753 bfd_boolean defined;
3754 /* Tag. */
3755 const char *tag;
3756 /* Names. */
3757 const char **names;
3758 /* Values. */
3759 bfd_signed_vma *vals;
3762 /* We keep a list of modified versions of types, so that we don't
3763 output them more than once. */
3765 struct ieee_modified_type
3767 /* Pointer to this type. */
3768 unsigned int pointer;
3769 /* Function with unknown arguments returning this type. */
3770 unsigned int function;
3771 /* Const version of this type. */
3772 unsigned int const_qualified;
3773 /* Volatile version of this type. */
3774 unsigned int volatile_qualified;
3775 /* List of arrays of this type of various bounds. */
3776 struct ieee_modified_array_type *arrays;
3779 /* A list of arrays bounds. */
3781 struct ieee_modified_array_type
3783 /* Next array bounds. */
3784 struct ieee_modified_array_type *next;
3785 /* Type index with these bounds. */
3786 unsigned int indx;
3787 /* Low bound. */
3788 bfd_signed_vma low;
3789 /* High bound. */
3790 bfd_signed_vma high;
3793 /* This is a list of pending function parameter information. We don't
3794 output them until we see the first block. */
3796 struct ieee_pending_parm
3798 /* Next pending parameter. */
3799 struct ieee_pending_parm *next;
3800 /* Name. */
3801 const char *name;
3802 /* Type index. */
3803 unsigned int type;
3804 /* Whether the type is a reference. */
3805 bfd_boolean referencep;
3806 /* Kind. */
3807 enum debug_parm_kind kind;
3808 /* Value. */
3809 bfd_vma val;
3812 /* This is the handle passed down by debug_write. */
3814 struct ieee_handle
3816 /* BFD we are writing to. */
3817 bfd *abfd;
3818 /* Whether we got an error in a subroutine called via traverse or
3819 map_over_sections. */
3820 bfd_boolean error;
3821 /* Current data buffer list. */
3822 struct ieee_buflist *current;
3823 /* Current data buffer. */
3824 struct ieee_buf *curbuf;
3825 /* Filename of current compilation unit. */
3826 const char *filename;
3827 /* Module name of current compilation unit. */
3828 const char *modname;
3829 /* List of buffer for global types. */
3830 struct ieee_buflist global_types;
3831 /* List of finished data buffers. */
3832 struct ieee_buflist data;
3833 /* List of buffers for typedefs in the current compilation unit. */
3834 struct ieee_buflist types;
3835 /* List of buffers for variables and functions in the current
3836 compilation unit. */
3837 struct ieee_buflist vars;
3838 /* List of buffers for C++ class definitions in the current
3839 compilation unit. */
3840 struct ieee_buflist cxx;
3841 /* List of buffers for line numbers in the current compilation unit. */
3842 struct ieee_buflist linenos;
3843 /* Ranges for the current compilation unit. */
3844 struct ieee_range *ranges;
3845 /* Ranges for all debugging information. */
3846 struct ieee_range *global_ranges;
3847 /* Nested pending ranges. */
3848 struct ieee_range *pending_ranges;
3849 /* Type stack. */
3850 struct ieee_type_stack *type_stack;
3851 /* Next unallocated type index. */
3852 unsigned int type_indx;
3853 /* Next unallocated name index. */
3854 unsigned int name_indx;
3855 /* Typedefs. */
3856 struct ieee_name_type_hash_table typedefs;
3857 /* Tags. */
3858 struct ieee_name_type_hash_table tags;
3859 /* Enums. */
3860 struct ieee_defined_enum *enums;
3861 /* Modified versions of types. */
3862 struct ieee_modified_type *modified;
3863 /* Number of entries allocated in modified. */
3864 unsigned int modified_alloc;
3865 /* 4 byte complex type. */
3866 unsigned int complex_float_index;
3867 /* 8 byte complex type. */
3868 unsigned int complex_double_index;
3869 /* The depth of block nesting. This is 0 outside a function, and 1
3870 just after start_function is called. */
3871 unsigned int block_depth;
3872 /* The name of the current function. */
3873 const char *fnname;
3874 /* List of buffers for the type of the function we are currently
3875 writing out. */
3876 struct ieee_buflist fntype;
3877 /* List of buffers for the parameters of the function we are
3878 currently writing out. */
3879 struct ieee_buflist fnargs;
3880 /* Number of arguments written to fnargs. */
3881 unsigned int fnargcount;
3882 /* Pending function parameters. */
3883 struct ieee_pending_parm *pending_parms;
3884 /* Current line number filename. */
3885 const char *lineno_filename;
3886 /* Line number name index. */
3887 unsigned int lineno_name_indx;
3888 /* Filename of pending line number. */
3889 const char *pending_lineno_filename;
3890 /* Pending line number. */
3891 unsigned long pending_lineno;
3892 /* Address of pending line number. */
3893 bfd_vma pending_lineno_addr;
3894 /* Highest address seen at end of procedure. */
3895 bfd_vma highaddr;
3898 static bfd_boolean ieee_init_buffer
3899 (struct ieee_handle *, struct ieee_buflist *);
3900 static bfd_boolean ieee_change_buffer
3901 (struct ieee_handle *, struct ieee_buflist *);
3902 static bfd_boolean ieee_append_buffer
3903 (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *);
3904 static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int);
3905 static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int);
3906 static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma);
3907 static bfd_boolean ieee_write_id (struct ieee_handle *, const char *);
3908 static bfd_boolean ieee_write_asn
3909 (struct ieee_handle *, unsigned int, bfd_vma);
3910 static bfd_boolean ieee_write_atn65
3911 (struct ieee_handle *, unsigned int, const char *);
3912 static bfd_boolean ieee_push_type
3913 (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean,
3914 bfd_boolean);
3915 static unsigned int ieee_pop_type (struct ieee_handle *);
3916 static void ieee_pop_unused_type (struct ieee_handle *);
3917 static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean);
3918 static bfd_boolean ieee_add_range
3919 (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma);
3920 static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma);
3921 static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma);
3922 static bfd_boolean ieee_define_type
3923 (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean);
3924 static bfd_boolean ieee_define_named_type
3925 (struct ieee_handle *, const char *, unsigned int, unsigned int,
3926 bfd_boolean, bfd_boolean, struct ieee_buflist *);
3927 static struct ieee_modified_type *ieee_get_modified_info
3928 (struct ieee_handle *, unsigned int);
3929 static struct bfd_hash_entry *ieee_name_type_newfunc
3930 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
3931 static bfd_boolean ieee_write_undefined_tag
3932 (struct ieee_name_type_hash_entry *, void *);
3933 static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *);
3934 static void ieee_add_bb11_blocks (bfd *, asection *, void *);
3935 static bfd_boolean ieee_add_bb11
3936 (struct ieee_handle *, asection *, bfd_vma, bfd_vma);
3937 static bfd_boolean ieee_output_pending_parms (struct ieee_handle *);
3938 static unsigned int ieee_vis_to_flags (enum debug_visibility);
3939 static bfd_boolean ieee_class_method_var
3940 (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean,
3941 bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
3943 static bfd_boolean ieee_start_compilation_unit (void *, const char *);
3944 static bfd_boolean ieee_start_source (void *, const char *);
3945 static bfd_boolean ieee_empty_type (void *);
3946 static bfd_boolean ieee_void_type (void *);
3947 static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean);
3948 static bfd_boolean ieee_float_type (void *, unsigned int);
3949 static bfd_boolean ieee_complex_type (void *, unsigned int);
3950 static bfd_boolean ieee_bool_type (void *, unsigned int);
3951 static bfd_boolean ieee_enum_type
3952 (void *, const char *, const char **, bfd_signed_vma *);
3953 static bfd_boolean ieee_pointer_type (void *);
3954 static bfd_boolean ieee_function_type (void *, int, bfd_boolean);
3955 static bfd_boolean ieee_reference_type (void *);
3956 static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma);
3957 static bfd_boolean ieee_array_type
3958 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
3959 static bfd_boolean ieee_set_type (void *, bfd_boolean);
3960 static bfd_boolean ieee_offset_type (void *);
3961 static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean);
3962 static bfd_boolean ieee_const_type (void *);
3963 static bfd_boolean ieee_volatile_type (void *);
3964 static bfd_boolean ieee_start_struct_type
3965 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
3966 static bfd_boolean ieee_struct_field
3967 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
3968 static bfd_boolean ieee_end_struct_type (void *);
3969 static bfd_boolean ieee_start_class_type
3970 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean,
3971 bfd_boolean);
3972 static bfd_boolean ieee_class_static_member
3973 (void *, const char *, const char *, enum debug_visibility);
3974 static bfd_boolean ieee_class_baseclass
3975 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
3976 static bfd_boolean ieee_class_start_method (void *, const char *);
3977 static bfd_boolean ieee_class_method_variant
3978 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
3979 bfd_vma, bfd_boolean);
3980 static bfd_boolean ieee_class_static_method_variant
3981 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
3982 static bfd_boolean ieee_class_end_method (void *);
3983 static bfd_boolean ieee_end_class_type (void *);
3984 static bfd_boolean ieee_typedef_type (void *, const char *);
3985 static bfd_boolean ieee_tag_type
3986 (void *, const char *, unsigned int, enum debug_type_kind);
3987 static bfd_boolean ieee_typdef (void *, const char *);
3988 static bfd_boolean ieee_tag (void *, const char *);
3989 static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma);
3990 static bfd_boolean ieee_float_constant (void *, const char *, double);
3991 static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma);
3992 static bfd_boolean ieee_variable
3993 (void *, const char *, enum debug_var_kind, bfd_vma);
3994 static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean);
3995 static bfd_boolean ieee_function_parameter
3996 (void *, const char *, enum debug_parm_kind, bfd_vma);
3997 static bfd_boolean ieee_start_block (void *, bfd_vma);
3998 static bfd_boolean ieee_end_block (void *, bfd_vma);
3999 static bfd_boolean ieee_end_function (void *);
4000 static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma);
4002 static const struct debug_write_fns ieee_fns =
4004 ieee_start_compilation_unit,
4005 ieee_start_source,
4006 ieee_empty_type,
4007 ieee_void_type,
4008 ieee_int_type,
4009 ieee_float_type,
4010 ieee_complex_type,
4011 ieee_bool_type,
4012 ieee_enum_type,
4013 ieee_pointer_type,
4014 ieee_function_type,
4015 ieee_reference_type,
4016 ieee_range_type,
4017 ieee_array_type,
4018 ieee_set_type,
4019 ieee_offset_type,
4020 ieee_method_type,
4021 ieee_const_type,
4022 ieee_volatile_type,
4023 ieee_start_struct_type,
4024 ieee_struct_field,
4025 ieee_end_struct_type,
4026 ieee_start_class_type,
4027 ieee_class_static_member,
4028 ieee_class_baseclass,
4029 ieee_class_start_method,
4030 ieee_class_method_variant,
4031 ieee_class_static_method_variant,
4032 ieee_class_end_method,
4033 ieee_end_class_type,
4034 ieee_typedef_type,
4035 ieee_tag_type,
4036 ieee_typdef,
4037 ieee_tag,
4038 ieee_int_constant,
4039 ieee_float_constant,
4040 ieee_typed_constant,
4041 ieee_variable,
4042 ieee_start_function,
4043 ieee_function_parameter,
4044 ieee_start_block,
4045 ieee_end_block,
4046 ieee_end_function,
4047 ieee_lineno
4050 /* Initialize a buffer to be empty. */
4052 static bfd_boolean
4053 ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4054 struct ieee_buflist *buflist)
4056 buflist->head = NULL;
4057 buflist->tail = NULL;
4058 return TRUE;
4061 /* See whether a buffer list has any data. */
4063 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
4065 /* Change the current buffer to a specified buffer chain. */
4067 static bfd_boolean
4068 ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist)
4070 if (buflist->head == NULL)
4072 struct ieee_buf *buf;
4074 buf = (struct ieee_buf *) xmalloc (sizeof *buf);
4075 buf->next = NULL;
4076 buf->c = 0;
4077 buflist->head = buf;
4078 buflist->tail = buf;
4081 info->current = buflist;
4082 info->curbuf = buflist->tail;
4084 return TRUE;
4087 /* Append a buffer chain. */
4089 static bfd_boolean
4090 ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4091 struct ieee_buflist *mainbuf,
4092 struct ieee_buflist *newbuf)
4094 if (newbuf->head != NULL)
4096 if (mainbuf->head == NULL)
4097 mainbuf->head = newbuf->head;
4098 else
4099 mainbuf->tail->next = newbuf->head;
4100 mainbuf->tail = newbuf->tail;
4102 return TRUE;
4105 /* Write a byte into the buffer. We use a macro for speed and a
4106 function for the complex cases. */
4108 #define ieee_write_byte(info, b) \
4109 ((info)->curbuf->c < IEEE_BUFSIZE \
4110 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \
4111 : ieee_real_write_byte ((info), (b)))
4113 static bfd_boolean
4114 ieee_real_write_byte (struct ieee_handle *info, int b)
4116 if (info->curbuf->c >= IEEE_BUFSIZE)
4118 struct ieee_buf *n;
4120 n = (struct ieee_buf *) xmalloc (sizeof *n);
4121 n->next = NULL;
4122 n->c = 0;
4123 if (info->current->head == NULL)
4124 info->current->head = n;
4125 else
4126 info->current->tail->next = n;
4127 info->current->tail = n;
4128 info->curbuf = n;
4131 info->curbuf->buf[info->curbuf->c] = b;
4132 ++info->curbuf->c;
4134 return TRUE;
4137 /* Write out two bytes. */
4139 static bfd_boolean
4140 ieee_write_2bytes (struct ieee_handle *info, int i)
4142 return (ieee_write_byte (info, i >> 8)
4143 && ieee_write_byte (info, i & 0xff));
4146 /* Write out an integer. */
4148 static bfd_boolean
4149 ieee_write_number (struct ieee_handle *info, bfd_vma v)
4151 bfd_vma t;
4152 bfd_byte ab[20];
4153 bfd_byte *p;
4154 unsigned int c;
4156 if (v <= (bfd_vma) ieee_number_end_enum)
4157 return ieee_write_byte (info, (int) v);
4159 t = v;
4160 p = ab + sizeof ab;
4161 while (t != 0)
4163 *--p = t & 0xff;
4164 t >>= 8;
4166 c = (ab + 20) - p;
4168 if (c > (unsigned int) (ieee_number_repeat_end_enum
4169 - ieee_number_repeat_start_enum))
4171 fprintf (stderr, _("IEEE numeric overflow: 0x"));
4172 fprintf_vma (stderr, v);
4173 fprintf (stderr, "\n");
4174 return FALSE;
4177 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
4178 return FALSE;
4179 for (; c > 0; --c, ++p)
4181 if (! ieee_write_byte (info, *p))
4182 return FALSE;
4185 return TRUE;
4188 /* Write out a string. */
4190 static bfd_boolean
4191 ieee_write_id (struct ieee_handle *info, const char *s)
4193 unsigned int len;
4195 len = strlen (s);
4196 if (len <= 0x7f)
4198 if (! ieee_write_byte (info, len))
4199 return FALSE;
4201 else if (len <= 0xff)
4203 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
4204 || ! ieee_write_byte (info, len))
4205 return FALSE;
4207 else if (len <= 0xffff)
4209 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
4210 || ! ieee_write_2bytes (info, len))
4211 return FALSE;
4213 else
4215 fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
4216 return FALSE;
4219 for (; *s != '\0'; s++)
4220 if (! ieee_write_byte (info, *s))
4221 return FALSE;
4223 return TRUE;
4226 /* Write out an ASN record. */
4228 static bfd_boolean
4229 ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val)
4231 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
4232 && ieee_write_number (info, indx)
4233 && ieee_write_number (info, val));
4236 /* Write out an ATN65 record. */
4238 static bfd_boolean
4239 ieee_write_atn65 (struct ieee_handle *info, unsigned int indx, const char *s)
4241 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
4242 && ieee_write_number (info, indx)
4243 && ieee_write_number (info, 0)
4244 && ieee_write_number (info, 65)
4245 && ieee_write_id (info, s));
4248 /* Push a type index onto the type stack. */
4250 static bfd_boolean
4251 ieee_push_type (struct ieee_handle *info, unsigned int indx,
4252 unsigned int size, bfd_boolean unsignedp, bfd_boolean localp)
4254 struct ieee_type_stack *ts;
4256 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
4257 memset (ts, 0, sizeof *ts);
4259 ts->type.indx = indx;
4260 ts->type.size = size;
4261 ts->type.unsignedp = unsignedp;
4262 ts->type.localp = localp;
4264 ts->next = info->type_stack;
4265 info->type_stack = ts;
4267 return TRUE;
4270 /* Pop a type index off the type stack. */
4272 static unsigned int
4273 ieee_pop_type (struct ieee_handle *info)
4275 return ieee_pop_type_used (info, TRUE);
4278 /* Pop an unused type index off the type stack. */
4280 static void
4281 ieee_pop_unused_type (struct ieee_handle *info)
4283 (void) ieee_pop_type_used (info, FALSE);
4286 /* Pop a used or unused type index off the type stack. */
4288 static unsigned int
4289 ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used)
4291 struct ieee_type_stack *ts;
4292 unsigned int ret;
4294 ts = info->type_stack;
4295 assert (ts != NULL);
4297 /* If this is a function type, and we need it, we need to append the
4298 actual definition to the typedef block now. */
4299 if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
4301 struct ieee_buflist *buflist;
4303 if (ts->type.localp)
4305 /* Make sure we have started the types block. */
4306 if (ieee_buffer_emptyp (&info->types))
4308 if (! ieee_change_buffer (info, &info->types)
4309 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4310 || ! ieee_write_byte (info, 1)
4311 || ! ieee_write_number (info, 0)
4312 || ! ieee_write_id (info, info->modname))
4313 return FALSE;
4315 buflist = &info->types;
4317 else
4319 /* Make sure we started the global type block. */
4320 if (ieee_buffer_emptyp (&info->global_types))
4322 if (! ieee_change_buffer (info, &info->global_types)
4323 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4324 || ! ieee_write_byte (info, 2)
4325 || ! ieee_write_number (info, 0)
4326 || ! ieee_write_id (info, ""))
4327 return FALSE;
4329 buflist = &info->global_types;
4332 if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
4333 return FALSE;
4336 ret = ts->type.indx;
4337 info->type_stack = ts->next;
4338 free (ts);
4339 return ret;
4342 /* Add a range of bytes included in the current compilation unit. */
4344 static bfd_boolean
4345 ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low,
4346 bfd_vma high)
4348 struct ieee_range **plist, *r, **pr;
4350 if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
4351 return TRUE;
4353 if (global)
4354 plist = &info->global_ranges;
4355 else
4356 plist = &info->ranges;
4358 for (r = *plist; r != NULL; r = r->next)
4360 if (high >= r->low && low <= r->high)
4362 /* The new range overlaps r. */
4363 if (low < r->low)
4364 r->low = low;
4365 if (high > r->high)
4366 r->high = high;
4367 pr = &r->next;
4368 while (*pr != NULL && (*pr)->low <= r->high)
4370 struct ieee_range *n;
4372 if ((*pr)->high > r->high)
4373 r->high = (*pr)->high;
4374 n = (*pr)->next;
4375 free (*pr);
4376 *pr = n;
4378 return TRUE;
4382 r = (struct ieee_range *) xmalloc (sizeof *r);
4383 memset (r, 0, sizeof *r);
4385 r->low = low;
4386 r->high = high;
4388 /* Store the ranges sorted by address. */
4389 for (pr = plist; *pr != NULL; pr = &(*pr)->next)
4390 if ((*pr)->low > high)
4391 break;
4392 r->next = *pr;
4393 *pr = r;
4395 return TRUE;
4398 /* Start a new range for which we only have the low address. */
4400 static bfd_boolean
4401 ieee_start_range (struct ieee_handle *info, bfd_vma low)
4403 struct ieee_range *r;
4405 r = (struct ieee_range *) xmalloc (sizeof *r);
4406 memset (r, 0, sizeof *r);
4407 r->low = low;
4408 r->next = info->pending_ranges;
4409 info->pending_ranges = r;
4410 return TRUE;
4413 /* Finish a range started by ieee_start_range. */
4415 static bfd_boolean
4416 ieee_end_range (struct ieee_handle *info, bfd_vma high)
4418 struct ieee_range *r;
4419 bfd_vma low;
4421 assert (info->pending_ranges != NULL);
4422 r = info->pending_ranges;
4423 low = r->low;
4424 info->pending_ranges = r->next;
4425 free (r);
4426 return ieee_add_range (info, FALSE, low, high);
4429 /* Start defining a type. */
4431 static bfd_boolean
4432 ieee_define_type (struct ieee_handle *info, unsigned int size,
4433 bfd_boolean unsignedp, bfd_boolean localp)
4435 return ieee_define_named_type (info, (const char *) NULL,
4436 (unsigned int) -1, size, unsignedp,
4437 localp, (struct ieee_buflist *) NULL);
4440 /* Start defining a named type. */
4442 static bfd_boolean
4443 ieee_define_named_type (struct ieee_handle *info, const char *name,
4444 unsigned int indx, unsigned int size,
4445 bfd_boolean unsignedp, bfd_boolean localp,
4446 struct ieee_buflist *buflist)
4448 unsigned int type_indx;
4449 unsigned int name_indx;
4451 if (indx != (unsigned int) -1)
4452 type_indx = indx;
4453 else
4455 type_indx = info->type_indx;
4456 ++info->type_indx;
4459 name_indx = info->name_indx;
4460 ++info->name_indx;
4462 if (name == NULL)
4463 name = "";
4465 /* If we were given a buffer, use it; otherwise, use either the
4466 local or the global type information, and make sure that the type
4467 block is started. */
4468 if (buflist != NULL)
4470 if (! ieee_change_buffer (info, buflist))
4471 return FALSE;
4473 else if (localp)
4475 if (! ieee_buffer_emptyp (&info->types))
4477 if (! ieee_change_buffer (info, &info->types))
4478 return FALSE;
4480 else
4482 if (! ieee_change_buffer (info, &info->types)
4483 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4484 || ! ieee_write_byte (info, 1)
4485 || ! ieee_write_number (info, 0)
4486 || ! ieee_write_id (info, info->modname))
4487 return FALSE;
4490 else
4492 if (! ieee_buffer_emptyp (&info->global_types))
4494 if (! ieee_change_buffer (info, &info->global_types))
4495 return FALSE;
4497 else
4499 if (! ieee_change_buffer (info, &info->global_types)
4500 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4501 || ! ieee_write_byte (info, 2)
4502 || ! ieee_write_number (info, 0)
4503 || ! ieee_write_id (info, ""))
4504 return FALSE;
4508 /* Push the new type on the type stack, write out an NN record, and
4509 write out the start of a TY record. The caller will then finish
4510 the TY record. */
4511 if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
4512 return FALSE;
4514 return (ieee_write_byte (info, (int) ieee_nn_record)
4515 && ieee_write_number (info, name_indx)
4516 && ieee_write_id (info, name)
4517 && ieee_write_byte (info, (int) ieee_ty_record_enum)
4518 && ieee_write_number (info, type_indx)
4519 && ieee_write_byte (info, 0xce)
4520 && ieee_write_number (info, name_indx));
4523 /* Get an entry to the list of modified versions of a type. */
4525 static struct ieee_modified_type *
4526 ieee_get_modified_info (struct ieee_handle *info, unsigned int indx)
4528 if (indx >= info->modified_alloc)
4530 unsigned int nalloc;
4532 nalloc = info->modified_alloc;
4533 if (nalloc == 0)
4534 nalloc = 16;
4535 while (indx >= nalloc)
4536 nalloc *= 2;
4537 info->modified = ((struct ieee_modified_type *)
4538 xrealloc (info->modified,
4539 nalloc * sizeof *info->modified));
4540 memset (info->modified + info->modified_alloc, 0,
4541 (nalloc - info->modified_alloc) * sizeof *info->modified);
4542 info->modified_alloc = nalloc;
4545 return info->modified + indx;
4548 /* Routines for the hash table mapping names to types. */
4550 /* Initialize an entry in the hash table. */
4552 static struct bfd_hash_entry *
4553 ieee_name_type_newfunc (struct bfd_hash_entry *entry,
4554 struct bfd_hash_table *table, const char *string)
4556 struct ieee_name_type_hash_entry *ret =
4557 (struct ieee_name_type_hash_entry *) entry;
4559 /* Allocate the structure if it has not already been allocated by a
4560 subclass. */
4561 if (ret == NULL)
4562 ret = ((struct ieee_name_type_hash_entry *)
4563 bfd_hash_allocate (table, sizeof *ret));
4564 if (ret == NULL)
4565 return NULL;
4567 /* Call the allocation method of the superclass. */
4568 ret = ((struct ieee_name_type_hash_entry *)
4569 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
4570 if (ret)
4572 /* Set local fields. */
4573 ret->types = NULL;
4576 return (struct bfd_hash_entry *) ret;
4579 /* Look up an entry in the hash table. */
4581 #define ieee_name_type_hash_lookup(table, string, create, copy) \
4582 ((struct ieee_name_type_hash_entry *) \
4583 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4585 /* Traverse the hash table. */
4587 #define ieee_name_type_hash_traverse(table, func, info) \
4588 (bfd_hash_traverse \
4589 (&(table)->root, \
4590 (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \
4591 (info)))
4593 /* The general routine to write out IEEE debugging information. */
4595 bfd_boolean
4596 write_ieee_debugging_info (bfd *abfd, void *dhandle)
4598 struct ieee_handle info;
4599 asection *s;
4600 const char *err;
4601 struct ieee_buf *b;
4603 memset (&info, 0, sizeof info);
4604 info.abfd = abfd;
4605 info.type_indx = 256;
4606 info.name_indx = 32;
4608 if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc,
4609 sizeof (struct ieee_name_type_hash_entry))
4610 || !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc,
4611 sizeof (struct ieee_name_type_hash_entry)))
4612 return FALSE;
4614 if (! ieee_init_buffer (&info, &info.global_types)
4615 || ! ieee_init_buffer (&info, &info.data)
4616 || ! ieee_init_buffer (&info, &info.types)
4617 || ! ieee_init_buffer (&info, &info.vars)
4618 || ! ieee_init_buffer (&info, &info.cxx)
4619 || ! ieee_init_buffer (&info, &info.linenos)
4620 || ! ieee_init_buffer (&info, &info.fntype)
4621 || ! ieee_init_buffer (&info, &info.fnargs))
4622 return FALSE;
4624 if (! debug_write (dhandle, &ieee_fns, (void *) &info))
4625 return FALSE;
4627 if (info.filename != NULL)
4629 if (! ieee_finish_compilation_unit (&info))
4630 return FALSE;
4633 /* Put any undefined tags in the global typedef information. */
4634 info.error = FALSE;
4635 ieee_name_type_hash_traverse (&info.tags,
4636 ieee_write_undefined_tag,
4637 (void *) &info);
4638 if (info.error)
4639 return FALSE;
4641 /* Prepend the global typedef information to the other data. */
4642 if (! ieee_buffer_emptyp (&info.global_types))
4644 /* The HP debugger seems to have a bug in which it ignores the
4645 last entry in the global types, so we add a dummy entry. */
4646 if (! ieee_change_buffer (&info, &info.global_types)
4647 || ! ieee_write_byte (&info, (int) ieee_nn_record)
4648 || ! ieee_write_number (&info, info.name_indx)
4649 || ! ieee_write_id (&info, "")
4650 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
4651 || ! ieee_write_number (&info, info.type_indx)
4652 || ! ieee_write_byte (&info, 0xce)
4653 || ! ieee_write_number (&info, info.name_indx)
4654 || ! ieee_write_number (&info, 'P')
4655 || ! ieee_write_number (&info, (int) builtin_void + 32)
4656 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4657 return FALSE;
4659 if (! ieee_append_buffer (&info, &info.global_types, &info.data))
4660 return FALSE;
4661 info.data = info.global_types;
4664 /* Make sure that we have declare BB11 blocks for each range in the
4665 file. They are added to info->vars. */
4666 info.error = FALSE;
4667 if (! ieee_init_buffer (&info, &info.vars))
4668 return FALSE;
4669 bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info);
4670 if (info.error)
4671 return FALSE;
4672 if (! ieee_buffer_emptyp (&info.vars))
4674 if (! ieee_change_buffer (&info, &info.vars)
4675 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4676 return FALSE;
4678 if (! ieee_append_buffer (&info, &info.data, &info.vars))
4679 return FALSE;
4682 /* Now all the data is in info.data. Write it out to the BFD. We
4683 normally would need to worry about whether all the other sections
4684 are set up yet, but the IEEE backend will handle this particular
4685 case correctly regardless. */
4686 if (ieee_buffer_emptyp (&info.data))
4688 /* There is no debugging information. */
4689 return TRUE;
4691 err = NULL;
4692 s = bfd_make_section_with_flags (abfd, ".debug",
4693 SEC_DEBUGGING | SEC_HAS_CONTENTS);
4694 if (s == NULL)
4695 err = "bfd_make_section";
4696 if (err == NULL)
4698 bfd_size_type size;
4700 size = 0;
4701 for (b = info.data.head; b != NULL; b = b->next)
4702 size += b->c;
4703 if (! bfd_set_section_size (abfd, s, size))
4704 err = "bfd_set_section_size";
4706 if (err == NULL)
4708 file_ptr offset;
4710 offset = 0;
4711 for (b = info.data.head; b != NULL; b = b->next)
4713 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4715 err = "bfd_set_section_contents";
4716 break;
4718 offset += b->c;
4722 if (err != NULL)
4724 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4725 bfd_errmsg (bfd_get_error ()));
4726 return FALSE;
4729 bfd_hash_table_free (&info.typedefs.root);
4730 bfd_hash_table_free (&info.tags.root);
4732 return TRUE;
4735 /* Write out information for an undefined tag. This is called via
4736 ieee_name_type_hash_traverse. */
4738 static bfd_boolean
4739 ieee_write_undefined_tag (struct ieee_name_type_hash_entry *h, void *p)
4741 struct ieee_handle *info = (struct ieee_handle *) p;
4742 struct ieee_name_type *nt;
4744 for (nt = h->types; nt != NULL; nt = nt->next)
4746 unsigned int name_indx;
4747 char code;
4749 if (nt->kind == DEBUG_KIND_ILLEGAL)
4750 continue;
4752 if (ieee_buffer_emptyp (&info->global_types))
4754 if (! ieee_change_buffer (info, &info->global_types)
4755 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4756 || ! ieee_write_byte (info, 2)
4757 || ! ieee_write_number (info, 0)
4758 || ! ieee_write_id (info, ""))
4760 info->error = TRUE;
4761 return FALSE;
4764 else
4766 if (! ieee_change_buffer (info, &info->global_types))
4768 info->error = TRUE;
4769 return FALSE;
4773 name_indx = info->name_indx;
4774 ++info->name_indx;
4775 if (! ieee_write_byte (info, (int) ieee_nn_record)
4776 || ! ieee_write_number (info, name_indx)
4777 || ! ieee_write_id (info, nt->type.name)
4778 || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
4779 || ! ieee_write_number (info, nt->type.indx)
4780 || ! ieee_write_byte (info, 0xce)
4781 || ! ieee_write_number (info, name_indx))
4783 info->error = TRUE;
4784 return FALSE;
4787 switch (nt->kind)
4789 default:
4790 abort ();
4791 info->error = TRUE;
4792 return FALSE;
4793 case DEBUG_KIND_STRUCT:
4794 case DEBUG_KIND_CLASS:
4795 code = 'S';
4796 break;
4797 case DEBUG_KIND_UNION:
4798 case DEBUG_KIND_UNION_CLASS:
4799 code = 'U';
4800 break;
4801 case DEBUG_KIND_ENUM:
4802 code = 'E';
4803 break;
4805 if (! ieee_write_number (info, code)
4806 || ! ieee_write_number (info, 0))
4808 info->error = TRUE;
4809 return FALSE;
4813 return TRUE;
4816 /* Start writing out information for a compilation unit. */
4818 static bfd_boolean
4819 ieee_start_compilation_unit (void *p, const char *filename)
4821 struct ieee_handle *info = (struct ieee_handle *) p;
4822 const char *modname;
4823 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4824 const char *backslash;
4825 #endif
4826 char *c, *s;
4828 if (info->filename != NULL)
4830 if (! ieee_finish_compilation_unit (info))
4831 return FALSE;
4834 info->filename = filename;
4835 modname = strrchr (filename, '/');
4836 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4837 /* We could have a mixed forward/back slash case. */
4838 backslash = strrchr (filename, '\\');
4839 if (modname == NULL || (backslash != NULL && backslash > modname))
4840 modname = backslash;
4841 #endif
4843 if (modname != NULL)
4844 ++modname;
4845 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4846 else if (filename[0] && filename[1] == ':')
4847 modname = filename + 2;
4848 #endif
4849 else
4850 modname = filename;
4852 c = xstrdup (modname);
4853 s = strrchr (c, '.');
4854 if (s != NULL)
4855 *s = '\0';
4856 info->modname = c;
4858 if (! ieee_init_buffer (info, &info->types)
4859 || ! ieee_init_buffer (info, &info->vars)
4860 || ! ieee_init_buffer (info, &info->cxx)
4861 || ! ieee_init_buffer (info, &info->linenos))
4862 return FALSE;
4863 info->ranges = NULL;
4865 /* Always include a BB1 and a BB3 block. That is what the output of
4866 the MRI linker seems to look like. */
4867 if (! ieee_change_buffer (info, &info->types)
4868 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4869 || ! ieee_write_byte (info, 1)
4870 || ! ieee_write_number (info, 0)
4871 || ! ieee_write_id (info, info->modname))
4872 return FALSE;
4874 ++info->name_indx;
4875 if (! ieee_change_buffer (info, &info->vars)
4876 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4877 || ! ieee_write_byte (info, 3)
4878 || ! ieee_write_number (info, 0)
4879 || ! ieee_write_id (info, info->modname))
4880 return FALSE;
4882 return TRUE;
4885 /* Finish up a compilation unit. */
4887 static bfd_boolean
4888 ieee_finish_compilation_unit (struct ieee_handle *info)
4890 struct ieee_range *r;
4892 if (! ieee_buffer_emptyp (&info->types))
4894 if (! ieee_change_buffer (info, &info->types)
4895 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4896 return FALSE;
4899 if (! ieee_buffer_emptyp (&info->cxx))
4901 /* Append any C++ information to the global function and
4902 variable information. */
4903 assert (! ieee_buffer_emptyp (&info->vars));
4904 if (! ieee_change_buffer (info, &info->vars))
4905 return FALSE;
4907 /* We put the pmisc records in a dummy procedure, just as the
4908 MRI compiler does. */
4909 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4910 || ! ieee_write_byte (info, 6)
4911 || ! ieee_write_number (info, 0)
4912 || ! ieee_write_id (info, "__XRYCPP")
4913 || ! ieee_write_number (info, 0)
4914 || ! ieee_write_number (info, 0)
4915 || ! ieee_write_number (info, info->highaddr - 1)
4916 || ! ieee_append_buffer (info, &info->vars, &info->cxx)
4917 || ! ieee_change_buffer (info, &info->vars)
4918 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4919 || ! ieee_write_number (info, info->highaddr - 1))
4920 return FALSE;
4923 if (! ieee_buffer_emptyp (&info->vars))
4925 if (! ieee_change_buffer (info, &info->vars)
4926 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4927 return FALSE;
4930 if (info->pending_lineno_filename != NULL)
4932 /* Force out the pending line number. */
4933 if (! ieee_lineno ((void *) info, (const char *) NULL, 0, (bfd_vma) -1))
4934 return FALSE;
4936 if (! ieee_buffer_emptyp (&info->linenos))
4938 if (! ieee_change_buffer (info, &info->linenos)
4939 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4940 return FALSE;
4941 if (strcmp (info->filename, info->lineno_filename) != 0)
4943 /* We were not in the main file. We just closed the
4944 included line number block, and now we must close the
4945 main line number block. */
4946 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
4947 return FALSE;
4951 if (! ieee_append_buffer (info, &info->data, &info->types)
4952 || ! ieee_append_buffer (info, &info->data, &info->vars)
4953 || ! ieee_append_buffer (info, &info->data, &info->linenos))
4954 return FALSE;
4956 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4957 if (! ieee_change_buffer (info, &info->data))
4958 return FALSE;
4960 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4961 || ! ieee_write_byte (info, 10)
4962 || ! ieee_write_number (info, 0)
4963 || ! ieee_write_id (info, info->modname)
4964 || ! ieee_write_id (info, "")
4965 || ! ieee_write_number (info, 0)
4966 || ! ieee_write_id (info, "GNU objcopy"))
4967 return FALSE;
4969 for (r = info->ranges; r != NULL; r = r->next)
4971 bfd_vma low, high;
4972 asection *s;
4973 int kind;
4975 low = r->low;
4976 high = r->high;
4978 /* Find the section corresponding to this range. */
4979 for (s = info->abfd->sections; s != NULL; s = s->next)
4981 if (bfd_get_section_vma (info->abfd, s) <= low
4982 && high <= (bfd_get_section_vma (info->abfd, s)
4983 + bfd_section_size (info->abfd, s)))
4984 break;
4987 if (s == NULL)
4989 /* Just ignore this range. */
4990 continue;
4993 /* Coalesce ranges if it seems reasonable. */
4994 while (r->next != NULL
4995 && high + 0x1000 >= r->next->low
4996 && (r->next->high
4997 <= (bfd_get_section_vma (info->abfd, s)
4998 + bfd_section_size (info->abfd, s))))
5000 r = r->next;
5001 high = r->high;
5004 if ((s->flags & SEC_CODE) != 0)
5005 kind = 1;
5006 else if ((s->flags & SEC_READONLY) != 0)
5007 kind = 3;
5008 else
5009 kind = 2;
5011 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5012 || ! ieee_write_byte (info, 11)
5013 || ! ieee_write_number (info, 0)
5014 || ! ieee_write_id (info, "")
5015 || ! ieee_write_number (info, kind)
5016 || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
5017 || ! ieee_write_number (info, low)
5018 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5019 || ! ieee_write_number (info, high - low))
5020 return FALSE;
5022 /* Add this range to the list of global ranges. */
5023 if (! ieee_add_range (info, TRUE, low, high))
5024 return FALSE;
5027 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
5028 return FALSE;
5030 return TRUE;
5033 /* Add BB11 blocks describing each range that we have not already
5034 described. */
5036 static void
5037 ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data)
5039 struct ieee_handle *info = (struct ieee_handle *) data;
5040 bfd_vma low, high;
5041 struct ieee_range *r;
5043 low = bfd_get_section_vma (abfd, sec);
5044 high = low + bfd_section_size (abfd, sec);
5046 /* Find the first range at or after this section. The ranges are
5047 sorted by address. */
5048 for (r = info->global_ranges; r != NULL; r = r->next)
5049 if (r->high > low)
5050 break;
5052 while (low < high)
5054 if (r == NULL || r->low >= high)
5056 if (! ieee_add_bb11 (info, sec, low, high))
5057 info->error = TRUE;
5058 return;
5061 if (low < r->low
5062 && r->low - low > 0x100)
5064 if (! ieee_add_bb11 (info, sec, low, r->low))
5066 info->error = TRUE;
5067 return;
5070 low = r->high;
5072 r = r->next;
5076 /* Add a single BB11 block for a range. We add it to info->vars. */
5078 static bfd_boolean
5079 ieee_add_bb11 (struct ieee_handle *info, asection *sec, bfd_vma low,
5080 bfd_vma high)
5082 int kind;
5084 if (! ieee_buffer_emptyp (&info->vars))
5086 if (! ieee_change_buffer (info, &info->vars))
5087 return FALSE;
5089 else
5091 const char *filename, *modname;
5092 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5093 const char *backslash;
5094 #endif
5095 char *c, *s;
5097 /* Start the enclosing BB10 block. */
5098 filename = bfd_get_filename (info->abfd);
5099 modname = strrchr (filename, '/');
5100 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5101 backslash = strrchr (filename, '\\');
5102 if (modname == NULL || (backslash != NULL && backslash > modname))
5103 modname = backslash;
5104 #endif
5106 if (modname != NULL)
5107 ++modname;
5108 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5109 else if (filename[0] && filename[1] == ':')
5110 modname = filename + 2;
5111 #endif
5112 else
5113 modname = filename;
5115 c = xstrdup (modname);
5116 s = strrchr (c, '.');
5117 if (s != NULL)
5118 *s = '\0';
5120 if (! ieee_change_buffer (info, &info->vars)
5121 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5122 || ! ieee_write_byte (info, 10)
5123 || ! ieee_write_number (info, 0)
5124 || ! ieee_write_id (info, c)
5125 || ! ieee_write_id (info, "")
5126 || ! ieee_write_number (info, 0)
5127 || ! ieee_write_id (info, "GNU objcopy"))
5128 return FALSE;
5130 free (c);
5133 if ((sec->flags & SEC_CODE) != 0)
5134 kind = 1;
5135 else if ((sec->flags & SEC_READONLY) != 0)
5136 kind = 3;
5137 else
5138 kind = 2;
5140 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5141 || ! ieee_write_byte (info, 11)
5142 || ! ieee_write_number (info, 0)
5143 || ! ieee_write_id (info, "")
5144 || ! ieee_write_number (info, kind)
5145 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5146 || ! ieee_write_number (info, low)
5147 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5148 || ! ieee_write_number (info, high - low))
5149 return FALSE;
5151 return TRUE;
5154 /* Start recording information from a particular source file. This is
5155 used to record which file defined which types, variables, etc. It
5156 is not used for line numbers, since the lineno entry point passes
5157 down the file name anyhow. IEEE debugging information doesn't seem
5158 to store this information anywhere. */
5160 static bfd_boolean
5161 ieee_start_source (void *p ATTRIBUTE_UNUSED,
5162 const char *filename ATTRIBUTE_UNUSED)
5164 return TRUE;
5167 /* Make an empty type. */
5169 static bfd_boolean
5170 ieee_empty_type (void *p)
5172 struct ieee_handle *info = (struct ieee_handle *) p;
5174 return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
5177 /* Make a void type. */
5179 static bfd_boolean
5180 ieee_void_type (void *p)
5182 struct ieee_handle *info = (struct ieee_handle *) p;
5184 return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
5187 /* Make an integer type. */
5189 static bfd_boolean
5190 ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
5192 struct ieee_handle *info = (struct ieee_handle *) p;
5193 unsigned int indx;
5195 switch (size)
5197 case 1:
5198 indx = (int) builtin_signed_char;
5199 break;
5200 case 2:
5201 indx = (int) builtin_signed_short_int;
5202 break;
5203 case 4:
5204 indx = (int) builtin_signed_long;
5205 break;
5206 case 8:
5207 indx = (int) builtin_signed_long_long;
5208 break;
5209 default:
5210 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
5211 return FALSE;
5214 if (unsignedp)
5215 ++indx;
5217 return ieee_push_type (info, indx, size, unsignedp, FALSE);
5220 /* Make a floating point type. */
5222 static bfd_boolean
5223 ieee_float_type (void *p, unsigned int size)
5225 struct ieee_handle *info = (struct ieee_handle *) p;
5226 unsigned int indx;
5228 switch (size)
5230 case 4:
5231 indx = (int) builtin_float;
5232 break;
5233 case 8:
5234 indx = (int) builtin_double;
5235 break;
5236 case 12:
5237 /* FIXME: This size really depends upon the processor. */
5238 indx = (int) builtin_long_double;
5239 break;
5240 case 16:
5241 indx = (int) builtin_long_long_double;
5242 break;
5243 default:
5244 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
5245 return FALSE;
5248 return ieee_push_type (info, indx, size, FALSE, FALSE);
5251 /* Make a complex type. */
5253 static bfd_boolean
5254 ieee_complex_type (void *p, unsigned int size)
5256 struct ieee_handle *info = (struct ieee_handle *) p;
5257 char code;
5259 switch (size)
5261 case 4:
5262 if (info->complex_float_index != 0)
5263 return ieee_push_type (info, info->complex_float_index, size * 2,
5264 FALSE, FALSE);
5265 code = 'c';
5266 break;
5267 case 12:
5268 case 16:
5269 /* These cases can be output by gcc -gstabs. Outputting the
5270 wrong type is better than crashing. */
5271 case 8:
5272 if (info->complex_double_index != 0)
5273 return ieee_push_type (info, info->complex_double_index, size * 2,
5274 FALSE, FALSE);
5275 code = 'd';
5276 break;
5277 default:
5278 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
5279 return FALSE;
5282 /* FIXME: I don't know what the string is for. */
5283 if (! ieee_define_type (info, size * 2, FALSE, FALSE)
5284 || ! ieee_write_number (info, code)
5285 || ! ieee_write_id (info, ""))
5286 return FALSE;
5288 if (size == 4)
5289 info->complex_float_index = info->type_stack->type.indx;
5290 else
5291 info->complex_double_index = info->type_stack->type.indx;
5293 return TRUE;
5296 /* Make a boolean type. IEEE doesn't support these, so we just make
5297 an integer type instead. */
5299 static bfd_boolean
5300 ieee_bool_type (void *p, unsigned int size)
5302 return ieee_int_type (p, size, TRUE);
5305 /* Make an enumeration. */
5307 static bfd_boolean
5308 ieee_enum_type (void *p, const char *tag, const char **names,
5309 bfd_signed_vma *vals)
5311 struct ieee_handle *info = (struct ieee_handle *) p;
5312 struct ieee_defined_enum *e;
5313 bfd_boolean localp, simple;
5314 unsigned int indx;
5315 int i = 0;
5317 localp = FALSE;
5318 indx = (unsigned int) -1;
5319 for (e = info->enums; e != NULL; e = e->next)
5321 if (tag == NULL)
5323 if (e->tag != NULL)
5324 continue;
5326 else
5328 if (e->tag == NULL
5329 || tag[0] != e->tag[0]
5330 || strcmp (tag, e->tag) != 0)
5331 continue;
5334 if (! e->defined)
5336 /* This enum tag has been seen but not defined. */
5337 indx = e->indx;
5338 break;
5341 if (names != NULL && e->names != NULL)
5343 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5345 if (names[i][0] != e->names[i][0]
5346 || vals[i] != e->vals[i]
5347 || strcmp (names[i], e->names[i]) != 0)
5348 break;
5352 if ((names == NULL && e->names == NULL)
5353 || (names != NULL
5354 && e->names != NULL
5355 && names[i] == NULL
5356 && e->names[i] == NULL))
5358 /* We've seen this enum before. */
5359 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
5362 if (tag != NULL)
5364 /* We've already seen an enum of the same name, so we must make
5365 sure to output this one locally. */
5366 localp = TRUE;
5367 break;
5371 /* If this is a simple enumeration, in which the values start at 0
5372 and always increment by 1, we can use type E. Otherwise we must
5373 use type N. */
5375 simple = TRUE;
5376 if (names != NULL)
5378 for (i = 0; names[i] != NULL; i++)
5380 if (vals[i] != i)
5382 simple = FALSE;
5383 break;
5388 if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
5389 (struct ieee_buflist *) NULL)
5390 || ! ieee_write_number (info, simple ? 'E' : 'N'))
5391 return FALSE;
5392 if (simple)
5394 /* FIXME: This is supposed to be the enumeration size, but we
5395 don't store that. */
5396 if (! ieee_write_number (info, 4))
5397 return FALSE;
5399 if (names != NULL)
5401 for (i = 0; names[i] != NULL; i++)
5403 if (! ieee_write_id (info, names[i]))
5404 return FALSE;
5405 if (! simple)
5407 if (! ieee_write_number (info, vals[i]))
5408 return FALSE;
5413 if (! localp)
5415 if (indx == (unsigned int) -1)
5417 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5418 memset (e, 0, sizeof *e);
5419 e->indx = info->type_stack->type.indx;
5420 e->tag = tag;
5422 e->next = info->enums;
5423 info->enums = e;
5426 e->names = names;
5427 e->vals = vals;
5428 e->defined = TRUE;
5431 return TRUE;
5434 /* Make a pointer type. */
5436 static bfd_boolean
5437 ieee_pointer_type (void *p)
5439 struct ieee_handle *info = (struct ieee_handle *) p;
5440 bfd_boolean localp;
5441 unsigned int indx;
5442 struct ieee_modified_type *m = NULL;
5444 localp = info->type_stack->type.localp;
5445 indx = ieee_pop_type (info);
5447 /* A pointer to a simple builtin type can be obtained by adding 32.
5448 FIXME: Will this be a short pointer, and will that matter? */
5449 if (indx < 32)
5450 return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);
5452 if (! localp)
5454 m = ieee_get_modified_info ((struct ieee_handle *) p, indx);
5455 if (m == NULL)
5456 return FALSE;
5458 /* FIXME: The size should depend upon the architecture. */
5459 if (m->pointer > 0)
5460 return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
5463 if (! ieee_define_type (info, 4, TRUE, localp)
5464 || ! ieee_write_number (info, 'P')
5465 || ! ieee_write_number (info, indx))
5466 return FALSE;
5468 if (! localp)
5469 m->pointer = info->type_stack->type.indx;
5471 return TRUE;
5474 /* Make a function type. This will be called for a method, but we
5475 don't want to actually add it to the type table in that case. We
5476 handle this by defining the type in a private buffer, and only
5477 adding that buffer to the typedef block if we are going to use it. */
5479 static bfd_boolean
5480 ieee_function_type (void *p, int argcount, bfd_boolean varargs)
5482 struct ieee_handle *info = (struct ieee_handle *) p;
5483 bfd_boolean localp;
5484 unsigned int *args = NULL;
5485 int i;
5486 unsigned int retindx;
5487 struct ieee_buflist fndef;
5488 struct ieee_modified_type *m;
5490 localp = FALSE;
5492 if (argcount > 0)
5494 args = (unsigned int *) xmalloc (argcount * sizeof *args);
5495 for (i = argcount - 1; i >= 0; i--)
5497 if (info->type_stack->type.localp)
5498 localp = TRUE;
5499 args[i] = ieee_pop_type (info);
5502 else if (argcount < 0)
5503 varargs = FALSE;
5505 if (info->type_stack->type.localp)
5506 localp = TRUE;
5507 retindx = ieee_pop_type (info);
5509 m = NULL;
5510 if (argcount < 0 && ! localp)
5512 m = ieee_get_modified_info ((struct ieee_handle *) p, retindx);
5513 if (m == NULL)
5514 return FALSE;
5516 if (m->function > 0)
5517 return ieee_push_type (info, m->function, 0, TRUE, FALSE);
5520 /* An attribute of 0x41 means that the frame and push mask are
5521 unknown. */
5522 if (! ieee_init_buffer (info, &fndef)
5523 || ! ieee_define_named_type (info, (const char *) NULL,
5524 (unsigned int) -1, 0, TRUE, localp,
5525 &fndef)
5526 || ! ieee_write_number (info, 'x')
5527 || ! ieee_write_number (info, 0x41)
5528 || ! ieee_write_number (info, 0)
5529 || ! ieee_write_number (info, 0)
5530 || ! ieee_write_number (info, retindx)
5531 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5532 return FALSE;
5533 if (argcount > 0)
5535 for (i = 0; i < argcount; i++)
5536 if (! ieee_write_number (info, args[i]))
5537 return FALSE;
5538 free (args);
5540 if (varargs)
5542 /* A varargs function is represented by writing out the last
5543 argument as type void *, although this makes little sense. */
5544 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5545 return FALSE;
5548 if (! ieee_write_number (info, 0))
5549 return FALSE;
5551 /* We wrote the information into fndef, in case we don't need it.
5552 It will be appended to info->types by ieee_pop_type. */
5553 info->type_stack->type.fndef = fndef;
5555 if (m != NULL)
5556 m->function = info->type_stack->type.indx;
5558 return TRUE;
5561 /* Make a reference type. */
5563 static bfd_boolean
5564 ieee_reference_type (void *p)
5566 struct ieee_handle *info = (struct ieee_handle *) p;
5568 /* IEEE appears to record a normal pointer type, and then use a
5569 pmisc record to indicate that it is really a reference. */
5571 if (! ieee_pointer_type (p))
5572 return FALSE;
5573 info->type_stack->type.referencep = TRUE;
5574 return TRUE;
5577 /* Make a range type. */
5579 static bfd_boolean
5580 ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
5582 struct ieee_handle *info = (struct ieee_handle *) p;
5583 unsigned int size;
5584 bfd_boolean unsignedp, localp;
5586 size = info->type_stack->type.size;
5587 unsignedp = info->type_stack->type.unsignedp;
5588 localp = info->type_stack->type.localp;
5589 ieee_pop_unused_type (info);
5590 return (ieee_define_type (info, size, unsignedp, localp)
5591 && ieee_write_number (info, 'R')
5592 && ieee_write_number (info, (bfd_vma) low)
5593 && ieee_write_number (info, (bfd_vma) high)
5594 && ieee_write_number (info, unsignedp ? 0 : 1)
5595 && ieee_write_number (info, size));
5598 /* Make an array type. */
5600 static bfd_boolean
5601 ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
5602 bfd_boolean stringp ATTRIBUTE_UNUSED)
5604 struct ieee_handle *info = (struct ieee_handle *) p;
5605 unsigned int eleindx;
5606 bfd_boolean localp;
5607 unsigned int size;
5608 struct ieee_modified_type *m = NULL;
5609 struct ieee_modified_array_type *a;
5611 /* IEEE does not store the range, so we just ignore it. */
5612 ieee_pop_unused_type (info);
5613 localp = info->type_stack->type.localp;
5614 size = info->type_stack->type.size;
5615 eleindx = ieee_pop_type (info);
5617 /* If we don't know the range, treat the size as exactly one
5618 element. */
5619 if (low < high)
5620 size *= (high - low) + 1;
5622 if (! localp)
5624 m = ieee_get_modified_info (info, eleindx);
5625 if (m == NULL)
5626 return FALSE;
5628 for (a = m->arrays; a != NULL; a = a->next)
5630 if (a->low == low && a->high == high)
5631 return ieee_push_type (info, a->indx, size, FALSE, FALSE);
5635 if (! ieee_define_type (info, size, FALSE, localp)
5636 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5637 || ! ieee_write_number (info, eleindx))
5638 return FALSE;
5639 if (low != 0)
5641 if (! ieee_write_number (info, low))
5642 return FALSE;
5645 if (! ieee_write_number (info, high + 1))
5646 return FALSE;
5648 if (! localp)
5650 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5651 memset (a, 0, sizeof *a);
5653 a->indx = info->type_stack->type.indx;
5654 a->low = low;
5655 a->high = high;
5657 a->next = m->arrays;
5658 m->arrays = a;
5661 return TRUE;
5664 /* Make a set type. */
5666 static bfd_boolean
5667 ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
5669 struct ieee_handle *info = (struct ieee_handle *) p;
5670 bfd_boolean localp;
5671 unsigned int eleindx;
5673 localp = info->type_stack->type.localp;
5674 eleindx = ieee_pop_type (info);
5676 /* FIXME: We don't know the size, so we just use 4. */
5678 return (ieee_define_type (info, 0, TRUE, localp)
5679 && ieee_write_number (info, 's')
5680 && ieee_write_number (info, 4)
5681 && ieee_write_number (info, eleindx));
5684 /* Make an offset type. */
5686 static bfd_boolean
5687 ieee_offset_type (void *p)
5689 /* FIXME: The MRI C++ compiler does not appear to generate any
5690 useful type information about an offset type. It just records a
5691 pointer to member as an integer. The MRI/HP IEEE spec does
5692 describe a pmisc record which can be used for a pointer to
5693 member. Unfortunately, it does not describe the target type,
5694 which seems pretty important. I'm going to punt this for now. */
5696 return ieee_int_type (p, 4, TRUE);
5699 /* Make a method type. */
5701 static bfd_boolean
5702 ieee_method_type (void *p, bfd_boolean domain, int argcount,
5703 bfd_boolean varargs)
5705 struct ieee_handle *info = (struct ieee_handle *) p;
5707 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5708 method, but the definition is incomplete. We just output an 'x'
5709 type. */
5711 if (domain)
5712 ieee_pop_unused_type (info);
5714 return ieee_function_type (p, argcount, varargs);
5717 /* Make a const qualified type. */
5719 static bfd_boolean
5720 ieee_const_type (void *p)
5722 struct ieee_handle *info = (struct ieee_handle *) p;
5723 unsigned int size;
5724 bfd_boolean unsignedp, localp;
5725 unsigned int indx;
5726 struct ieee_modified_type *m = NULL;
5728 size = info->type_stack->type.size;
5729 unsignedp = info->type_stack->type.unsignedp;
5730 localp = info->type_stack->type.localp;
5731 indx = ieee_pop_type (info);
5733 if (! localp)
5735 m = ieee_get_modified_info (info, indx);
5736 if (m == NULL)
5737 return FALSE;
5739 if (m->const_qualified > 0)
5740 return ieee_push_type (info, m->const_qualified, size, unsignedp,
5741 FALSE);
5744 if (! ieee_define_type (info, size, unsignedp, localp)
5745 || ! ieee_write_number (info, 'n')
5746 || ! ieee_write_number (info, 1)
5747 || ! ieee_write_number (info, indx))
5748 return FALSE;
5750 if (! localp)
5751 m->const_qualified = info->type_stack->type.indx;
5753 return TRUE;
5756 /* Make a volatile qualified type. */
5758 static bfd_boolean
5759 ieee_volatile_type (void *p)
5761 struct ieee_handle *info = (struct ieee_handle *) p;
5762 unsigned int size;
5763 bfd_boolean unsignedp, localp;
5764 unsigned int indx;
5765 struct ieee_modified_type *m = NULL;
5767 size = info->type_stack->type.size;
5768 unsignedp = info->type_stack->type.unsignedp;
5769 localp = info->type_stack->type.localp;
5770 indx = ieee_pop_type (info);
5772 if (! localp)
5774 m = ieee_get_modified_info (info, indx);
5775 if (m == NULL)
5776 return FALSE;
5778 if (m->volatile_qualified > 0)
5779 return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
5780 FALSE);
5783 if (! ieee_define_type (info, size, unsignedp, localp)
5784 || ! ieee_write_number (info, 'n')
5785 || ! ieee_write_number (info, 2)
5786 || ! ieee_write_number (info, indx))
5787 return FALSE;
5789 if (! localp)
5790 m->volatile_qualified = info->type_stack->type.indx;
5792 return TRUE;
5795 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5797 static unsigned int
5798 ieee_vis_to_flags (enum debug_visibility visibility)
5800 switch (visibility)
5802 default:
5803 abort ();
5804 case DEBUG_VISIBILITY_PUBLIC:
5805 return CXXFLAGS_VISIBILITY_PUBLIC;
5806 case DEBUG_VISIBILITY_PRIVATE:
5807 return CXXFLAGS_VISIBILITY_PRIVATE;
5808 case DEBUG_VISIBILITY_PROTECTED:
5809 return CXXFLAGS_VISIBILITY_PROTECTED;
5811 /*NOTREACHED*/
5814 /* Start defining a struct type. We build it in the strdef field on
5815 the stack, to avoid confusing type definitions required by the
5816 fields with the struct type itself. */
5818 static bfd_boolean
5819 ieee_start_struct_type (void *p, const char *tag, unsigned int id,
5820 bfd_boolean structp, unsigned int size)
5822 struct ieee_handle *info = (struct ieee_handle *) p;
5823 bfd_boolean localp, ignorep;
5824 bfd_boolean copy;
5825 char ab[20];
5826 const char *look;
5827 struct ieee_name_type_hash_entry *h;
5828 struct ieee_name_type *nt, *ntlook;
5829 struct ieee_buflist strdef;
5831 localp = FALSE;
5832 ignorep = FALSE;
5834 /* We need to create a tag for internal use even if we don't want
5835 one for external use. This will let us refer to an anonymous
5836 struct. */
5837 if (tag != NULL)
5839 look = tag;
5840 copy = FALSE;
5842 else
5844 sprintf (ab, "__anon%u", id);
5845 look = ab;
5846 copy = TRUE;
5849 /* If we already have references to the tag, we must use the
5850 existing type index. */
5851 h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy);
5852 if (h == NULL)
5853 return FALSE;
5855 nt = NULL;
5856 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
5858 if (ntlook->id == id)
5859 nt = ntlook;
5860 else if (! ntlook->type.localp)
5862 /* We are creating a duplicate definition of a globally
5863 defined tag. Force it to be local to avoid
5864 confusion. */
5865 localp = TRUE;
5869 if (nt != NULL)
5871 assert (localp == nt->type.localp);
5872 if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
5874 /* We've already seen a global definition of the type.
5875 Ignore this new definition. */
5876 ignorep = TRUE;
5879 else
5881 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5882 memset (nt, 0, sizeof *nt);
5883 nt->id = id;
5884 nt->type.name = h->root.string;
5885 nt->next = h->types;
5886 h->types = nt;
5887 nt->type.indx = info->type_indx;
5888 ++info->type_indx;
5891 nt->kind = DEBUG_KIND_ILLEGAL;
5893 if (! ieee_init_buffer (info, &strdef)
5894 || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE,
5895 localp, &strdef)
5896 || ! ieee_write_number (info, structp ? 'S' : 'U')
5897 || ! ieee_write_number (info, size))
5898 return FALSE;
5900 if (! ignorep)
5902 const char *hold;
5904 /* We never want nt->type.name to be NULL. We want the rest of
5905 the type to be the object set up on the type stack; it will
5906 have a NULL name if tag is NULL. */
5907 hold = nt->type.name;
5908 nt->type = info->type_stack->type;
5909 nt->type.name = hold;
5912 info->type_stack->type.name = tag;
5913 info->type_stack->type.strdef = strdef;
5914 info->type_stack->type.ignorep = ignorep;
5916 return TRUE;
5919 /* Add a field to a struct. */
5921 static bfd_boolean
5922 ieee_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
5923 enum debug_visibility visibility)
5925 struct ieee_handle *info = (struct ieee_handle *) p;
5926 unsigned int size;
5927 bfd_boolean unsignedp;
5928 bfd_boolean referencep;
5929 bfd_boolean localp;
5930 unsigned int indx;
5931 bfd_vma offset;
5933 assert (info->type_stack != NULL
5934 && info->type_stack->next != NULL
5935 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
5937 /* If we are ignoring this struct definition, just pop and ignore
5938 the type. */
5939 if (info->type_stack->next->type.ignorep)
5941 ieee_pop_unused_type (info);
5942 return TRUE;
5945 size = info->type_stack->type.size;
5946 unsignedp = info->type_stack->type.unsignedp;
5947 referencep = info->type_stack->type.referencep;
5948 localp = info->type_stack->type.localp;
5949 indx = ieee_pop_type (info);
5951 if (localp)
5952 info->type_stack->type.localp = TRUE;
5954 if (info->type_stack->type.classdef != NULL)
5956 unsigned int flags;
5957 unsigned int nindx;
5959 /* This is a class. We must add a description of this field to
5960 the class records we are building. */
5962 flags = ieee_vis_to_flags (visibility);
5963 nindx = info->type_stack->type.classdef->indx;
5964 if (! ieee_change_buffer (info,
5965 &info->type_stack->type.classdef->pmiscbuf)
5966 || ! ieee_write_asn (info, nindx, 'd')
5967 || ! ieee_write_asn (info, nindx, flags)
5968 || ! ieee_write_atn65 (info, nindx, name)
5969 || ! ieee_write_atn65 (info, nindx, name))
5970 return FALSE;
5971 info->type_stack->type.classdef->pmisccount += 4;
5973 if (referencep)
5975 /* We need to output a record recording that this field is
5976 really of reference type. We put this on the refs field
5977 of classdef, so that it can be appended to the C++
5978 records after the class is defined. */
5980 nindx = info->name_indx;
5981 ++info->name_indx;
5983 if (! ieee_change_buffer (info,
5984 &info->type_stack->type.classdef->refs)
5985 || ! ieee_write_byte (info, (int) ieee_nn_record)
5986 || ! ieee_write_number (info, nindx)
5987 || ! ieee_write_id (info, "")
5988 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5989 || ! ieee_write_number (info, nindx)
5990 || ! ieee_write_number (info, 0)
5991 || ! ieee_write_number (info, 62)
5992 || ! ieee_write_number (info, 80)
5993 || ! ieee_write_number (info, 4)
5994 || ! ieee_write_asn (info, nindx, 'R')
5995 || ! ieee_write_asn (info, nindx, 3)
5996 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
5997 || ! ieee_write_atn65 (info, nindx, name))
5998 return FALSE;
6002 /* If the bitsize doesn't match the expected size, we need to output
6003 a bitfield type. */
6004 if (size == 0 || bitsize == 0 || bitsize == size * 8)
6005 offset = bitpos / 8;
6006 else
6008 if (! ieee_define_type (info, 0, unsignedp,
6009 info->type_stack->type.localp)
6010 || ! ieee_write_number (info, 'g')
6011 || ! ieee_write_number (info, unsignedp ? 0 : 1)
6012 || ! ieee_write_number (info, bitsize)
6013 || ! ieee_write_number (info, indx))
6014 return FALSE;
6015 indx = ieee_pop_type (info);
6016 offset = bitpos;
6019 /* Switch to the struct we are building in order to output this
6020 field definition. */
6021 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
6022 && ieee_write_id (info, name)
6023 && ieee_write_number (info, indx)
6024 && ieee_write_number (info, offset));
6027 /* Finish up a struct type. */
6029 static bfd_boolean
6030 ieee_end_struct_type (void *p)
6032 struct ieee_handle *info = (struct ieee_handle *) p;
6033 struct ieee_buflist *pb;
6035 assert (info->type_stack != NULL
6036 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
6038 /* If we were ignoring this struct definition because it was a
6039 duplicate definition, just through away whatever bytes we have
6040 accumulated. Leave the type on the stack. */
6041 if (info->type_stack->type.ignorep)
6042 return TRUE;
6044 /* If this is not a duplicate definition of this tag, then localp
6045 will be FALSE, and we can put it in the global type block.
6046 FIXME: We should avoid outputting duplicate definitions which are
6047 the same. */
6048 if (! info->type_stack->type.localp)
6050 /* Make sure we have started the global type block. */
6051 if (ieee_buffer_emptyp (&info->global_types))
6053 if (! ieee_change_buffer (info, &info->global_types)
6054 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6055 || ! ieee_write_byte (info, 2)
6056 || ! ieee_write_number (info, 0)
6057 || ! ieee_write_id (info, ""))
6058 return FALSE;
6060 pb = &info->global_types;
6062 else
6064 /* Make sure we have started the types block. */
6065 if (ieee_buffer_emptyp (&info->types))
6067 if (! ieee_change_buffer (info, &info->types)
6068 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6069 || ! ieee_write_byte (info, 1)
6070 || ! ieee_write_number (info, 0)
6071 || ! ieee_write_id (info, info->modname))
6072 return FALSE;
6074 pb = &info->types;
6077 /* Append the struct definition to the types. */
6078 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6079 || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6080 return FALSE;
6082 /* Leave the struct on the type stack. */
6084 return TRUE;
6087 /* Start a class type. */
6089 static bfd_boolean
6090 ieee_start_class_type (void *p, const char *tag, unsigned int id,
6091 bfd_boolean structp, unsigned int size,
6092 bfd_boolean vptr, bfd_boolean ownvptr)
6094 struct ieee_handle *info = (struct ieee_handle *) p;
6095 const char *vclass;
6096 struct ieee_buflist pmiscbuf;
6097 unsigned int indx;
6098 struct ieee_type_class *classdef;
6100 /* A C++ class is output as a C++ struct along with a set of pmisc
6101 records describing the class. */
6103 /* We need to have a name so that we can associate the struct and
6104 the class. */
6105 if (tag == NULL)
6107 char *t;
6109 t = (char *) xmalloc (20);
6110 sprintf (t, "__anon%u", id);
6111 tag = t;
6114 /* We can't write out the virtual table information until we have
6115 finished the class, because we don't know the virtual table size.
6116 We get the size from the largest voffset we see. */
6117 vclass = NULL;
6118 if (vptr && ! ownvptr)
6120 vclass = info->type_stack->type.name;
6121 assert (vclass != NULL);
6122 /* We don't call ieee_pop_unused_type, since the class should
6123 get defined. */
6124 (void) ieee_pop_type (info);
6127 if (! ieee_start_struct_type (p, tag, id, structp, size))
6128 return FALSE;
6130 indx = info->name_indx;
6131 ++info->name_indx;
6133 /* We write out pmisc records into the classdef field. We will
6134 write out the pmisc start after we know the number of records we
6135 need. */
6136 if (! ieee_init_buffer (info, &pmiscbuf)
6137 || ! ieee_change_buffer (info, &pmiscbuf)
6138 || ! ieee_write_asn (info, indx, 'T')
6139 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6140 || ! ieee_write_atn65 (info, indx, tag))
6141 return FALSE;
6143 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6144 memset (classdef, 0, sizeof *classdef);
6146 classdef->indx = indx;
6147 classdef->pmiscbuf = pmiscbuf;
6148 classdef->pmisccount = 3;
6149 classdef->vclass = vclass;
6150 classdef->ownvptr = ownvptr;
6152 info->type_stack->type.classdef = classdef;
6154 return TRUE;
6157 /* Add a static member to a class. */
6159 static bfd_boolean
6160 ieee_class_static_member (void *p, const char *name, const char *physname,
6161 enum debug_visibility visibility)
6163 struct ieee_handle *info = (struct ieee_handle *) p;
6164 unsigned int flags;
6165 unsigned int nindx;
6167 /* We don't care about the type. Hopefully there will be a call to
6168 ieee_variable declaring the physical name and the type, since
6169 that is where an IEEE consumer must get the type. */
6170 ieee_pop_unused_type (info);
6172 assert (info->type_stack != NULL
6173 && info->type_stack->type.classdef != NULL);
6175 flags = ieee_vis_to_flags (visibility);
6176 flags |= CXXFLAGS_STATIC;
6178 nindx = info->type_stack->type.classdef->indx;
6180 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6181 || ! ieee_write_asn (info, nindx, 'd')
6182 || ! ieee_write_asn (info, nindx, flags)
6183 || ! ieee_write_atn65 (info, nindx, name)
6184 || ! ieee_write_atn65 (info, nindx, physname))
6185 return FALSE;
6186 info->type_stack->type.classdef->pmisccount += 4;
6188 return TRUE;
6191 /* Add a base class to a class. */
6193 static bfd_boolean
6194 ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
6195 enum debug_visibility visibility)
6197 struct ieee_handle *info = (struct ieee_handle *) p;
6198 const char *bname;
6199 bfd_boolean localp;
6200 unsigned int bindx;
6201 char *fname;
6202 unsigned int flags;
6203 unsigned int nindx;
6205 assert (info->type_stack != NULL
6206 && info->type_stack->type.name != NULL
6207 && info->type_stack->next != NULL
6208 && info->type_stack->next->type.classdef != NULL
6209 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6211 bname = info->type_stack->type.name;
6212 localp = info->type_stack->type.localp;
6213 bindx = ieee_pop_type (info);
6215 /* We are currently defining both a struct and a class. We must
6216 write out a field definition in the struct which holds the base
6217 class. The stabs debugging reader will create a field named
6218 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6219 we should not depend upon a detail of stabs debugging. */
6220 if (is_virtual)
6222 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6223 sprintf (fname, "_vb$%s", bname);
6224 flags = BASEFLAGS_VIRTUAL;
6226 else
6228 if (localp)
6229 info->type_stack->type.localp = TRUE;
6231 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6232 sprintf (fname, "_b$%s", bname);
6234 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6235 || ! ieee_write_id (info, fname)
6236 || ! ieee_write_number (info, bindx)
6237 || ! ieee_write_number (info, bitpos / 8))
6238 return FALSE;
6239 flags = 0;
6242 if (visibility == DEBUG_VISIBILITY_PRIVATE)
6243 flags |= BASEFLAGS_PRIVATE;
6245 nindx = info->type_stack->type.classdef->indx;
6247 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6248 || ! ieee_write_asn (info, nindx, 'b')
6249 || ! ieee_write_asn (info, nindx, flags)
6250 || ! ieee_write_atn65 (info, nindx, bname)
6251 || ! ieee_write_asn (info, nindx, 0)
6252 || ! ieee_write_atn65 (info, nindx, fname))
6253 return FALSE;
6254 info->type_stack->type.classdef->pmisccount += 5;
6256 free (fname);
6258 return TRUE;
6261 /* Start building a method for a class. */
6263 static bfd_boolean
6264 ieee_class_start_method (void *p, const char *name)
6266 struct ieee_handle *info = (struct ieee_handle *) p;
6268 assert (info->type_stack != NULL
6269 && info->type_stack->type.classdef != NULL
6270 && info->type_stack->type.classdef->method == NULL);
6272 info->type_stack->type.classdef->method = name;
6274 return TRUE;
6277 /* Define a new method variant, either static or not. */
6279 static bfd_boolean
6280 ieee_class_method_var (struct ieee_handle *info, const char *physname,
6281 enum debug_visibility visibility,
6282 bfd_boolean staticp, bfd_boolean constp,
6283 bfd_boolean volatilep, bfd_vma voffset,
6284 bfd_boolean context)
6286 unsigned int flags;
6287 unsigned int nindx;
6288 bfd_boolean is_virtual;
6290 /* We don't need the type of the method. An IEEE consumer which
6291 wants the type must track down the function by the physical name
6292 and get the type from that. */
6293 ieee_pop_unused_type (info);
6295 /* We don't use the context. FIXME: We probably ought to use it to
6296 adjust the voffset somehow, but I don't really know how. */
6297 if (context)
6298 ieee_pop_unused_type (info);
6300 assert (info->type_stack != NULL
6301 && info->type_stack->type.classdef != NULL
6302 && info->type_stack->type.classdef->method != NULL);
6304 flags = ieee_vis_to_flags (visibility);
6306 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6307 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6309 if (staticp)
6310 flags |= CXXFLAGS_STATIC;
6311 if (constp)
6312 flags |= CXXFLAGS_CONST;
6313 if (volatilep)
6314 flags |= CXXFLAGS_VOLATILE;
6316 nindx = info->type_stack->type.classdef->indx;
6318 is_virtual = context || voffset > 0;
6320 if (! ieee_change_buffer (info,
6321 &info->type_stack->type.classdef->pmiscbuf)
6322 || ! ieee_write_asn (info, nindx, is_virtual ? 'v' : 'm')
6323 || ! ieee_write_asn (info, nindx, flags)
6324 || ! ieee_write_atn65 (info, nindx,
6325 info->type_stack->type.classdef->method)
6326 || ! ieee_write_atn65 (info, nindx, physname))
6327 return FALSE;
6329 if (is_virtual)
6331 if (voffset > info->type_stack->type.classdef->voffset)
6332 info->type_stack->type.classdef->voffset = voffset;
6333 if (! ieee_write_asn (info, nindx, voffset))
6334 return FALSE;
6335 ++info->type_stack->type.classdef->pmisccount;
6338 if (! ieee_write_asn (info, nindx, 0))
6339 return FALSE;
6341 info->type_stack->type.classdef->pmisccount += 5;
6343 return TRUE;
6346 /* Define a new method variant. */
6348 static bfd_boolean
6349 ieee_class_method_variant (void *p, const char *physname,
6350 enum debug_visibility visibility,
6351 bfd_boolean constp, bfd_boolean volatilep,
6352 bfd_vma voffset, bfd_boolean context)
6354 struct ieee_handle *info = (struct ieee_handle *) p;
6356 return ieee_class_method_var (info, physname, visibility, FALSE, constp,
6357 volatilep, voffset, context);
6360 /* Define a new static method variant. */
6362 static bfd_boolean
6363 ieee_class_static_method_variant (void *p, const char *physname,
6364 enum debug_visibility visibility,
6365 bfd_boolean constp, bfd_boolean volatilep)
6367 struct ieee_handle *info = (struct ieee_handle *) p;
6369 return ieee_class_method_var (info, physname, visibility, TRUE, constp,
6370 volatilep, 0, FALSE);
6373 /* Finish up a method. */
6375 static bfd_boolean
6376 ieee_class_end_method (void *p)
6378 struct ieee_handle *info = (struct ieee_handle *) p;
6380 assert (info->type_stack != NULL
6381 && info->type_stack->type.classdef != NULL
6382 && info->type_stack->type.classdef->method != NULL);
6384 info->type_stack->type.classdef->method = NULL;
6386 return TRUE;
6389 /* Finish up a class. */
6391 static bfd_boolean
6392 ieee_end_class_type (void *p)
6394 struct ieee_handle *info = (struct ieee_handle *) p;
6395 unsigned int nindx;
6397 assert (info->type_stack != NULL
6398 && info->type_stack->type.classdef != NULL);
6400 /* If we were ignoring this class definition because it was a
6401 duplicate definition, just through away whatever bytes we have
6402 accumulated. Leave the type on the stack. */
6403 if (info->type_stack->type.ignorep)
6404 return TRUE;
6406 nindx = info->type_stack->type.classdef->indx;
6408 /* If we have a virtual table, we can write out the information now. */
6409 if (info->type_stack->type.classdef->vclass != NULL
6410 || info->type_stack->type.classdef->ownvptr)
6412 if (! ieee_change_buffer (info,
6413 &info->type_stack->type.classdef->pmiscbuf)
6414 || ! ieee_write_asn (info, nindx, 'z')
6415 || ! ieee_write_atn65 (info, nindx, "")
6416 || ! ieee_write_asn (info, nindx,
6417 info->type_stack->type.classdef->voffset))
6418 return FALSE;
6419 if (info->type_stack->type.classdef->ownvptr)
6421 if (! ieee_write_atn65 (info, nindx, ""))
6422 return FALSE;
6424 else
6426 if (! ieee_write_atn65 (info, nindx,
6427 info->type_stack->type.classdef->vclass))
6428 return FALSE;
6430 if (! ieee_write_asn (info, nindx, 0))
6431 return FALSE;
6432 info->type_stack->type.classdef->pmisccount += 5;
6435 /* Now that we know the number of pmisc records, we can write out
6436 the atn62 which starts the pmisc records, and append them to the
6437 C++ buffers. */
6439 if (! ieee_change_buffer (info, &info->cxx)
6440 || ! ieee_write_byte (info, (int) ieee_nn_record)
6441 || ! ieee_write_number (info, nindx)
6442 || ! ieee_write_id (info, "")
6443 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6444 || ! ieee_write_number (info, nindx)
6445 || ! ieee_write_number (info, 0)
6446 || ! ieee_write_number (info, 62)
6447 || ! ieee_write_number (info, 80)
6448 || ! ieee_write_number (info,
6449 info->type_stack->type.classdef->pmisccount))
6450 return FALSE;
6452 if (! ieee_append_buffer (info, &info->cxx,
6453 &info->type_stack->type.classdef->pmiscbuf))
6454 return FALSE;
6455 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6457 if (! ieee_append_buffer (info, &info->cxx,
6458 &info->type_stack->type.classdef->refs))
6459 return FALSE;
6462 return ieee_end_struct_type (p);
6465 /* Push a previously seen typedef onto the type stack. */
6467 static bfd_boolean
6468 ieee_typedef_type (void *p, const char *name)
6470 struct ieee_handle *info = (struct ieee_handle *) p;
6471 struct ieee_name_type_hash_entry *h;
6472 struct ieee_name_type *nt;
6474 h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);
6476 /* h should never be NULL, since that would imply that the generic
6477 debugging code has asked for a typedef which it has not yet
6478 defined. */
6479 assert (h != NULL);
6481 /* We always use the most recently defined type for this name, which
6482 will be the first one on the list. */
6484 nt = h->types;
6485 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6486 nt->type.unsignedp, nt->type.localp))
6487 return FALSE;
6489 /* Copy over any other type information we may have. */
6490 info->type_stack->type = nt->type;
6492 return TRUE;
6495 /* Push a tagged type onto the type stack. */
6497 static bfd_boolean
6498 ieee_tag_type (void *p, const char *name, unsigned int id,
6499 enum debug_type_kind kind)
6501 struct ieee_handle *info = (struct ieee_handle *) p;
6502 bfd_boolean localp;
6503 bfd_boolean copy;
6504 char ab[20];
6505 struct ieee_name_type_hash_entry *h;
6506 struct ieee_name_type *nt;
6508 if (kind == DEBUG_KIND_ENUM)
6510 struct ieee_defined_enum *e;
6512 if (name == NULL)
6513 abort ();
6514 for (e = info->enums; e != NULL; e = e->next)
6515 if (e->tag != NULL && strcmp (e->tag, name) == 0)
6516 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6518 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
6519 memset (e, 0, sizeof *e);
6521 e->indx = info->type_indx;
6522 ++info->type_indx;
6523 e->tag = name;
6524 e->defined = FALSE;
6526 e->next = info->enums;
6527 info->enums = e;
6529 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6532 localp = FALSE;
6534 copy = FALSE;
6535 if (name == NULL)
6537 sprintf (ab, "__anon%u", id);
6538 name = ab;
6539 copy = TRUE;
6542 h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
6543 if (h == NULL)
6544 return FALSE;
6546 for (nt = h->types; nt != NULL; nt = nt->next)
6548 if (nt->id == id)
6550 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6551 nt->type.unsignedp, nt->type.localp))
6552 return FALSE;
6553 /* Copy over any other type information we may have. */
6554 info->type_stack->type = nt->type;
6555 return TRUE;
6558 if (! nt->type.localp)
6560 /* This is a duplicate of a global type, so it must be
6561 local. */
6562 localp = TRUE;
6566 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6567 memset (nt, 0, sizeof *nt);
6569 nt->id = id;
6570 nt->type.name = h->root.string;
6571 nt->type.indx = info->type_indx;
6572 nt->type.localp = localp;
6573 ++info->type_indx;
6574 nt->kind = kind;
6576 nt->next = h->types;
6577 h->types = nt;
6579 if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
6580 return FALSE;
6582 info->type_stack->type.name = h->root.string;
6584 return TRUE;
6587 /* Output a typedef. */
6589 static bfd_boolean
6590 ieee_typdef (void *p, const char *name)
6592 struct ieee_handle *info = (struct ieee_handle *) p;
6593 struct ieee_write_type type;
6594 unsigned int indx;
6595 bfd_boolean found;
6596 bfd_boolean localp;
6597 struct ieee_name_type_hash_entry *h;
6598 struct ieee_name_type *nt;
6600 type = info->type_stack->type;
6601 indx = type.indx;
6603 /* If this is a simple builtin type using a builtin name, we don't
6604 want to output the typedef itself. We also want to change the
6605 type index to correspond to the name being used. We recognize
6606 names used in stabs debugging output even if they don't exactly
6607 correspond to the names used for the IEEE builtin types. */
6608 found = FALSE;
6609 if (indx <= (unsigned int) builtin_bcd_float)
6611 switch ((enum builtin_types) indx)
6613 default:
6614 break;
6616 case builtin_void:
6617 if (strcmp (name, "void") == 0)
6618 found = TRUE;
6619 break;
6621 case builtin_signed_char:
6622 case builtin_char:
6623 if (strcmp (name, "signed char") == 0)
6625 indx = (unsigned int) builtin_signed_char;
6626 found = TRUE;
6628 else if (strcmp (name, "char") == 0)
6630 indx = (unsigned int) builtin_char;
6631 found = TRUE;
6633 break;
6635 case builtin_unsigned_char:
6636 if (strcmp (name, "unsigned char") == 0)
6637 found = TRUE;
6638 break;
6640 case builtin_signed_short_int:
6641 case builtin_short:
6642 case builtin_short_int:
6643 case builtin_signed_short:
6644 if (strcmp (name, "signed short int") == 0)
6646 indx = (unsigned int) builtin_signed_short_int;
6647 found = TRUE;
6649 else if (strcmp (name, "short") == 0)
6651 indx = (unsigned int) builtin_short;
6652 found = TRUE;
6654 else if (strcmp (name, "short int") == 0)
6656 indx = (unsigned int) builtin_short_int;
6657 found = TRUE;
6659 else if (strcmp (name, "signed short") == 0)
6661 indx = (unsigned int) builtin_signed_short;
6662 found = TRUE;
6664 break;
6666 case builtin_unsigned_short_int:
6667 case builtin_unsigned_short:
6668 if (strcmp (name, "unsigned short int") == 0
6669 || strcmp (name, "short unsigned int") == 0)
6671 indx = builtin_unsigned_short_int;
6672 found = TRUE;
6674 else if (strcmp (name, "unsigned short") == 0)
6676 indx = builtin_unsigned_short;
6677 found = TRUE;
6679 break;
6681 case builtin_signed_long:
6682 case builtin_int: /* FIXME: Size depends upon architecture. */
6683 case builtin_long:
6684 if (strcmp (name, "signed long") == 0)
6686 indx = builtin_signed_long;
6687 found = TRUE;
6689 else if (strcmp (name, "int") == 0)
6691 indx = builtin_int;
6692 found = TRUE;
6694 else if (strcmp (name, "long") == 0
6695 || strcmp (name, "long int") == 0)
6697 indx = builtin_long;
6698 found = TRUE;
6700 break;
6702 case builtin_unsigned_long:
6703 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
6704 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
6705 if (strcmp (name, "unsigned long") == 0
6706 || strcmp (name, "long unsigned int") == 0)
6708 indx = builtin_unsigned_long;
6709 found = TRUE;
6711 else if (strcmp (name, "unsigned") == 0)
6713 indx = builtin_unsigned;
6714 found = TRUE;
6716 else if (strcmp (name, "unsigned int") == 0)
6718 indx = builtin_unsigned_int;
6719 found = TRUE;
6721 break;
6723 case builtin_signed_long_long:
6724 if (strcmp (name, "signed long long") == 0
6725 || strcmp (name, "long long int") == 0)
6726 found = TRUE;
6727 break;
6729 case builtin_unsigned_long_long:
6730 if (strcmp (name, "unsigned long long") == 0
6731 || strcmp (name, "long long unsigned int") == 0)
6732 found = TRUE;
6733 break;
6735 case builtin_float:
6736 if (strcmp (name, "float") == 0)
6737 found = TRUE;
6738 break;
6740 case builtin_double:
6741 if (strcmp (name, "double") == 0)
6742 found = TRUE;
6743 break;
6745 case builtin_long_double:
6746 if (strcmp (name, "long double") == 0)
6747 found = TRUE;
6748 break;
6750 case builtin_long_long_double:
6751 if (strcmp (name, "long long double") == 0)
6752 found = TRUE;
6753 break;
6756 if (found)
6757 type.indx = indx;
6760 h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
6761 if (h == NULL)
6762 return FALSE;
6764 /* See if we have already defined this type with this name. */
6765 localp = type.localp;
6766 for (nt = h->types; nt != NULL; nt = nt->next)
6768 if (nt->id == indx)
6770 /* If this is a global definition, then we don't need to
6771 do anything here. */
6772 if (! nt->type.localp)
6774 ieee_pop_unused_type (info);
6775 return TRUE;
6778 else
6780 /* This is a duplicate definition, so make this one local. */
6781 localp = TRUE;
6785 /* We need to add a new typedef for this type. */
6787 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6788 memset (nt, 0, sizeof *nt);
6789 nt->id = indx;
6790 nt->type = type;
6791 nt->type.name = name;
6792 nt->type.localp = localp;
6793 nt->kind = DEBUG_KIND_ILLEGAL;
6795 nt->next = h->types;
6796 h->types = nt;
6798 if (found)
6800 /* This is one of the builtin typedefs, so we don't need to
6801 actually define it. */
6802 ieee_pop_unused_type (info);
6803 return TRUE;
6806 indx = ieee_pop_type (info);
6808 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
6809 type.unsignedp, localp,
6810 (struct ieee_buflist *) NULL)
6811 || ! ieee_write_number (info, 'T')
6812 || ! ieee_write_number (info, indx))
6813 return FALSE;
6815 /* Remove the type we just added to the type stack. This should not
6816 be ieee_pop_unused_type, since the type is used, we just don't
6817 need it now. */
6818 (void) ieee_pop_type (info);
6820 return TRUE;
6823 /* Output a tag for a type. We don't have to do anything here. */
6825 static bfd_boolean
6826 ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED)
6828 struct ieee_handle *info = (struct ieee_handle *) p;
6830 /* This should not be ieee_pop_unused_type, since we want the type
6831 to be defined. */
6832 (void) ieee_pop_type (info);
6833 return TRUE;
6836 /* Output an integer constant. */
6838 static bfd_boolean
6839 ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED,
6840 bfd_vma val ATTRIBUTE_UNUSED)
6842 /* FIXME. */
6843 return TRUE;
6846 /* Output a floating point constant. */
6848 static bfd_boolean
6849 ieee_float_constant (void *p ATTRIBUTE_UNUSED,
6850 const char *name ATTRIBUTE_UNUSED,
6851 double val ATTRIBUTE_UNUSED)
6853 /* FIXME. */
6854 return TRUE;
6857 /* Output a typed constant. */
6859 static bfd_boolean
6860 ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED,
6861 bfd_vma val ATTRIBUTE_UNUSED)
6863 struct ieee_handle *info = (struct ieee_handle *) p;
6865 /* FIXME. */
6866 ieee_pop_unused_type (info);
6867 return TRUE;
6870 /* Output a variable. */
6872 static bfd_boolean
6873 ieee_variable (void *p, const char *name, enum debug_var_kind kind,
6874 bfd_vma val)
6876 struct ieee_handle *info = (struct ieee_handle *) p;
6877 unsigned int name_indx;
6878 unsigned int size;
6879 bfd_boolean referencep;
6880 unsigned int type_indx;
6881 bfd_boolean asn;
6882 int refflag;
6884 size = info->type_stack->type.size;
6885 referencep = info->type_stack->type.referencep;
6886 type_indx = ieee_pop_type (info);
6888 assert (! ieee_buffer_emptyp (&info->vars));
6889 if (! ieee_change_buffer (info, &info->vars))
6890 return FALSE;
6892 name_indx = info->name_indx;
6893 ++info->name_indx;
6895 /* Write out an NN and an ATN record for this variable. */
6896 if (! ieee_write_byte (info, (int) ieee_nn_record)
6897 || ! ieee_write_number (info, name_indx)
6898 || ! ieee_write_id (info, name)
6899 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6900 || ! ieee_write_number (info, name_indx)
6901 || ! ieee_write_number (info, type_indx))
6902 return FALSE;
6903 switch (kind)
6905 default:
6906 abort ();
6907 return FALSE;
6908 case DEBUG_GLOBAL:
6909 if (! ieee_write_number (info, 8)
6910 || ! ieee_add_range (info, FALSE, val, val + size))
6911 return FALSE;
6912 refflag = 0;
6913 asn = TRUE;
6914 break;
6915 case DEBUG_STATIC:
6916 if (! ieee_write_number (info, 3)
6917 || ! ieee_add_range (info, FALSE, val, val + size))
6918 return FALSE;
6919 refflag = 1;
6920 asn = TRUE;
6921 break;
6922 case DEBUG_LOCAL_STATIC:
6923 if (! ieee_write_number (info, 3)
6924 || ! ieee_add_range (info, FALSE, val, val + size))
6925 return FALSE;
6926 refflag = 2;
6927 asn = TRUE;
6928 break;
6929 case DEBUG_LOCAL:
6930 if (! ieee_write_number (info, 1)
6931 || ! ieee_write_number (info, val))
6932 return FALSE;
6933 refflag = 2;
6934 asn = FALSE;
6935 break;
6936 case DEBUG_REGISTER:
6937 if (! ieee_write_number (info, 2)
6938 || ! ieee_write_number (info,
6939 ieee_genreg_to_regno (info->abfd, val)))
6940 return FALSE;
6941 refflag = 2;
6942 asn = FALSE;
6943 break;
6946 if (asn)
6948 if (! ieee_write_asn (info, name_indx, val))
6949 return FALSE;
6952 /* If this is really a reference type, then we just output it with
6953 pointer type, and must now output a C++ record indicating that it
6954 is really reference type. */
6955 if (referencep)
6957 unsigned int nindx;
6959 nindx = info->name_indx;
6960 ++info->name_indx;
6962 /* If this is a global variable, we want to output the misc
6963 record in the C++ misc record block. Otherwise, we want to
6964 output it just after the variable definition, which is where
6965 the current buffer is. */
6966 if (refflag != 2)
6968 if (! ieee_change_buffer (info, &info->cxx))
6969 return FALSE;
6972 if (! ieee_write_byte (info, (int) ieee_nn_record)
6973 || ! ieee_write_number (info, nindx)
6974 || ! ieee_write_id (info, "")
6975 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6976 || ! ieee_write_number (info, nindx)
6977 || ! ieee_write_number (info, 0)
6978 || ! ieee_write_number (info, 62)
6979 || ! ieee_write_number (info, 80)
6980 || ! ieee_write_number (info, 3)
6981 || ! ieee_write_asn (info, nindx, 'R')
6982 || ! ieee_write_asn (info, nindx, refflag)
6983 || ! ieee_write_atn65 (info, nindx, name))
6984 return FALSE;
6987 return TRUE;
6990 /* Start outputting information for a function. */
6992 static bfd_boolean
6993 ieee_start_function (void *p, const char *name, bfd_boolean global)
6995 struct ieee_handle *info = (struct ieee_handle *) p;
6996 bfd_boolean referencep;
6997 unsigned int retindx, typeindx;
6999 referencep = info->type_stack->type.referencep;
7000 retindx = ieee_pop_type (info);
7002 /* Besides recording a BB4 or BB6 block, we record the type of the
7003 function in the BB1 typedef block. We can't write out the full
7004 type until we have seen all the parameters, so we accumulate it
7005 in info->fntype and info->fnargs. */
7006 if (! ieee_buffer_emptyp (&info->fntype))
7008 /* FIXME: This might happen someday if we support nested
7009 functions. */
7010 abort ();
7013 info->fnname = name;
7015 /* An attribute of 0x40 means that the push mask is unknown. */
7016 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
7017 &info->fntype)
7018 || ! ieee_write_number (info, 'x')
7019 || ! ieee_write_number (info, 0x40)
7020 || ! ieee_write_number (info, 0)
7021 || ! ieee_write_number (info, 0)
7022 || ! ieee_write_number (info, retindx))
7023 return FALSE;
7025 typeindx = ieee_pop_type (info);
7027 if (! ieee_init_buffer (info, &info->fnargs))
7028 return FALSE;
7029 info->fnargcount = 0;
7031 /* If the function return value is actually a reference type, we
7032 must add a record indicating that. */
7033 if (referencep)
7035 unsigned int nindx;
7037 nindx = info->name_indx;
7038 ++info->name_indx;
7039 if (! ieee_change_buffer (info, &info->cxx)
7040 || ! ieee_write_byte (info, (int) ieee_nn_record)
7041 || ! ieee_write_number (info, nindx)
7042 || ! ieee_write_id (info, "")
7043 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7044 || ! ieee_write_number (info, nindx)
7045 || ! ieee_write_number (info, 0)
7046 || ! ieee_write_number (info, 62)
7047 || ! ieee_write_number (info, 80)
7048 || ! ieee_write_number (info, 3)
7049 || ! ieee_write_asn (info, nindx, 'R')
7050 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7051 || ! ieee_write_atn65 (info, nindx, name))
7052 return FALSE;
7055 assert (! ieee_buffer_emptyp (&info->vars));
7056 if (! ieee_change_buffer (info, &info->vars))
7057 return FALSE;
7059 /* The address is written out as the first block. */
7061 ++info->block_depth;
7063 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7064 && ieee_write_byte (info, global ? 4 : 6)
7065 && ieee_write_number (info, 0)
7066 && ieee_write_id (info, name)
7067 && ieee_write_number (info, 0)
7068 && ieee_write_number (info, typeindx));
7071 /* Add a function parameter. This will normally be called before the
7072 first block, so we postpone them until we see the block. */
7074 static bfd_boolean
7075 ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
7076 bfd_vma val)
7078 struct ieee_handle *info = (struct ieee_handle *) p;
7079 struct ieee_pending_parm *m, **pm;
7081 assert (info->block_depth == 1);
7083 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7084 memset (m, 0, sizeof *m);
7086 m->next = NULL;
7087 m->name = name;
7088 m->referencep = info->type_stack->type.referencep;
7089 m->type = ieee_pop_type (info);
7090 m->kind = kind;
7091 m->val = val;
7093 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7095 *pm = m;
7097 /* Add the type to the fnargs list. */
7098 if (! ieee_change_buffer (info, &info->fnargs)
7099 || ! ieee_write_number (info, m->type))
7100 return FALSE;
7101 ++info->fnargcount;
7103 return TRUE;
7106 /* Output pending function parameters. */
7108 static bfd_boolean
7109 ieee_output_pending_parms (struct ieee_handle *info)
7111 struct ieee_pending_parm *m;
7112 unsigned int refcount;
7114 refcount = 0;
7115 for (m = info->pending_parms; m != NULL; m = m->next)
7117 enum debug_var_kind vkind;
7119 switch (m->kind)
7121 default:
7122 abort ();
7123 return FALSE;
7124 case DEBUG_PARM_STACK:
7125 case DEBUG_PARM_REFERENCE:
7126 vkind = DEBUG_LOCAL;
7127 break;
7128 case DEBUG_PARM_REG:
7129 case DEBUG_PARM_REF_REG:
7130 vkind = DEBUG_REGISTER;
7131 break;
7134 if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
7135 return FALSE;
7136 info->type_stack->type.referencep = m->referencep;
7137 if (m->referencep)
7138 ++refcount;
7139 if (! ieee_variable ((void *) info, m->name, vkind, m->val))
7140 return FALSE;
7143 /* If there are any reference parameters, we need to output a
7144 miscellaneous record indicating them. */
7145 if (refcount > 0)
7147 unsigned int nindx, varindx;
7149 /* FIXME: The MRI compiler outputs the demangled function name
7150 here, but we are outputting the mangled name. */
7151 nindx = info->name_indx;
7152 ++info->name_indx;
7153 if (! ieee_change_buffer (info, &info->vars)
7154 || ! ieee_write_byte (info, (int) ieee_nn_record)
7155 || ! ieee_write_number (info, nindx)
7156 || ! ieee_write_id (info, "")
7157 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7158 || ! ieee_write_number (info, nindx)
7159 || ! ieee_write_number (info, 0)
7160 || ! ieee_write_number (info, 62)
7161 || ! ieee_write_number (info, 80)
7162 || ! ieee_write_number (info, refcount + 3)
7163 || ! ieee_write_asn (info, nindx, 'B')
7164 || ! ieee_write_atn65 (info, nindx, info->fnname)
7165 || ! ieee_write_asn (info, nindx, 0))
7166 return FALSE;
7167 for (m = info->pending_parms, varindx = 1;
7168 m != NULL;
7169 m = m->next, varindx++)
7171 if (m->referencep)
7173 if (! ieee_write_asn (info, nindx, varindx))
7174 return FALSE;
7179 m = info->pending_parms;
7180 while (m != NULL)
7182 struct ieee_pending_parm *next;
7184 next = m->next;
7185 free (m);
7186 m = next;
7189 info->pending_parms = NULL;
7191 return TRUE;
7194 /* Start a block. If this is the first block, we output the address
7195 to finish the BB4 or BB6, and then output the function parameters. */
7197 static bfd_boolean
7198 ieee_start_block (void *p, bfd_vma addr)
7200 struct ieee_handle *info = (struct ieee_handle *) p;
7202 if (! ieee_change_buffer (info, &info->vars))
7203 return FALSE;
7205 if (info->block_depth == 1)
7207 if (! ieee_write_number (info, addr)
7208 || ! ieee_output_pending_parms (info))
7209 return FALSE;
7211 else
7213 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7214 || ! ieee_write_byte (info, 6)
7215 || ! ieee_write_number (info, 0)
7216 || ! ieee_write_id (info, "")
7217 || ! ieee_write_number (info, 0)
7218 || ! ieee_write_number (info, 0)
7219 || ! ieee_write_number (info, addr))
7220 return FALSE;
7223 if (! ieee_start_range (info, addr))
7224 return FALSE;
7226 ++info->block_depth;
7228 return TRUE;
7231 /* End a block. */
7233 static bfd_boolean
7234 ieee_end_block (void *p, bfd_vma addr)
7236 struct ieee_handle *info = (struct ieee_handle *) p;
7238 /* The address we are given is the end of the block, but IEEE seems
7239 to want to the address of the last byte in the block, so we
7240 subtract one. */
7241 if (! ieee_change_buffer (info, &info->vars)
7242 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7243 || ! ieee_write_number (info, addr - 1))
7244 return FALSE;
7246 if (! ieee_end_range (info, addr))
7247 return FALSE;
7249 --info->block_depth;
7251 if (addr > info->highaddr)
7252 info->highaddr = addr;
7254 return TRUE;
7257 /* End a function. */
7259 static bfd_boolean
7260 ieee_end_function (void *p)
7262 struct ieee_handle *info = (struct ieee_handle *) p;
7264 assert (info->block_depth == 1);
7266 --info->block_depth;
7268 /* Now we can finish up fntype, and add it to the typdef section.
7269 At this point, fntype is the 'x' type up to the argument count,
7270 and fnargs is the argument types. We must add the argument
7271 count, and we must add the level. FIXME: We don't record varargs
7272 functions correctly. In fact, stabs debugging does not give us
7273 enough information to do so. */
7274 if (! ieee_change_buffer (info, &info->fntype)
7275 || ! ieee_write_number (info, info->fnargcount)
7276 || ! ieee_change_buffer (info, &info->fnargs)
7277 || ! ieee_write_number (info, 0))
7278 return FALSE;
7280 /* Make sure the typdef block has been started. */
7281 if (ieee_buffer_emptyp (&info->types))
7283 if (! ieee_change_buffer (info, &info->types)
7284 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7285 || ! ieee_write_byte (info, 1)
7286 || ! ieee_write_number (info, 0)
7287 || ! ieee_write_id (info, info->modname))
7288 return FALSE;
7291 if (! ieee_append_buffer (info, &info->types, &info->fntype)
7292 || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7293 return FALSE;
7295 info->fnname = NULL;
7296 if (! ieee_init_buffer (info, &info->fntype)
7297 || ! ieee_init_buffer (info, &info->fnargs))
7298 return FALSE;
7299 info->fnargcount = 0;
7301 return TRUE;
7304 /* Record line number information. */
7306 static bfd_boolean
7307 ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
7309 struct ieee_handle *info = (struct ieee_handle *) p;
7311 assert (info->filename != NULL);
7313 /* The HP simulator seems to get confused when more than one line is
7314 listed for the same address, at least if they are in different
7315 files. We handle this by always listing the last line for a
7316 given address, since that seems to be the one that gdb uses. */
7317 if (info->pending_lineno_filename != NULL
7318 && addr != info->pending_lineno_addr)
7320 /* Make sure we have a line number block. */
7321 if (! ieee_buffer_emptyp (&info->linenos))
7323 if (! ieee_change_buffer (info, &info->linenos))
7324 return FALSE;
7326 else
7328 info->lineno_name_indx = info->name_indx;
7329 ++info->name_indx;
7330 if (! ieee_change_buffer (info, &info->linenos)
7331 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7332 || ! ieee_write_byte (info, 5)
7333 || ! ieee_write_number (info, 0)
7334 || ! ieee_write_id (info, info->filename)
7335 || ! ieee_write_byte (info, (int) ieee_nn_record)
7336 || ! ieee_write_number (info, info->lineno_name_indx)
7337 || ! ieee_write_id (info, ""))
7338 return FALSE;
7339 info->lineno_filename = info->filename;
7342 if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0)
7344 if (strcmp (info->filename, info->lineno_filename) != 0)
7346 /* We were not in the main file. Close the block for the
7347 included file. */
7348 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7349 return FALSE;
7350 if (strcmp (info->filename, info->pending_lineno_filename) == 0)
7352 /* We need a new NN record, and we aren't about to
7353 output one. */
7354 info->lineno_name_indx = info->name_indx;
7355 ++info->name_indx;
7356 if (! ieee_write_byte (info, (int) ieee_nn_record)
7357 || ! ieee_write_number (info, info->lineno_name_indx)
7358 || ! ieee_write_id (info, ""))
7359 return FALSE;
7362 if (strcmp (info->filename, info->pending_lineno_filename) != 0)
7364 /* We are not changing to the main file. Open a block for
7365 the new included file. */
7366 info->lineno_name_indx = info->name_indx;
7367 ++info->name_indx;
7368 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7369 || ! ieee_write_byte (info, 5)
7370 || ! ieee_write_number (info, 0)
7371 || ! ieee_write_id (info, info->pending_lineno_filename)
7372 || ! ieee_write_byte (info, (int) ieee_nn_record)
7373 || ! ieee_write_number (info, info->lineno_name_indx)
7374 || ! ieee_write_id (info, ""))
7375 return FALSE;
7377 info->lineno_filename = info->pending_lineno_filename;
7380 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7381 || ! ieee_write_number (info, info->lineno_name_indx)
7382 || ! ieee_write_number (info, 0)
7383 || ! ieee_write_number (info, 7)
7384 || ! ieee_write_number (info, info->pending_lineno)
7385 || ! ieee_write_number (info, 0)
7386 || ! ieee_write_asn (info, info->lineno_name_indx,
7387 info->pending_lineno_addr))
7388 return FALSE;
7391 info->pending_lineno_filename = filename;
7392 info->pending_lineno = lineno;
7393 info->pending_lineno_addr = addr;
7395 return TRUE;