daily update
[binutils.git] / binutils / ieee.c
blob044da313ddfe5c750a48cfb13ed203de96afd1b2
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, 2011 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 (filename_cmp (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"))
5129 free (c);
5130 return FALSE;
5133 free (c);
5136 if ((sec->flags & SEC_CODE) != 0)
5137 kind = 1;
5138 else if ((sec->flags & SEC_READONLY) != 0)
5139 kind = 3;
5140 else
5141 kind = 2;
5143 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5144 || ! ieee_write_byte (info, 11)
5145 || ! ieee_write_number (info, 0)
5146 || ! ieee_write_id (info, "")
5147 || ! ieee_write_number (info, kind)
5148 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5149 || ! ieee_write_number (info, low)
5150 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5151 || ! ieee_write_number (info, high - low))
5152 return FALSE;
5154 return TRUE;
5157 /* Start recording information from a particular source file. This is
5158 used to record which file defined which types, variables, etc. It
5159 is not used for line numbers, since the lineno entry point passes
5160 down the file name anyhow. IEEE debugging information doesn't seem
5161 to store this information anywhere. */
5163 static bfd_boolean
5164 ieee_start_source (void *p ATTRIBUTE_UNUSED,
5165 const char *filename ATTRIBUTE_UNUSED)
5167 return TRUE;
5170 /* Make an empty type. */
5172 static bfd_boolean
5173 ieee_empty_type (void *p)
5175 struct ieee_handle *info = (struct ieee_handle *) p;
5177 return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
5180 /* Make a void type. */
5182 static bfd_boolean
5183 ieee_void_type (void *p)
5185 struct ieee_handle *info = (struct ieee_handle *) p;
5187 return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
5190 /* Make an integer type. */
5192 static bfd_boolean
5193 ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
5195 struct ieee_handle *info = (struct ieee_handle *) p;
5196 unsigned int indx;
5198 switch (size)
5200 case 1:
5201 indx = (int) builtin_signed_char;
5202 break;
5203 case 2:
5204 indx = (int) builtin_signed_short_int;
5205 break;
5206 case 4:
5207 indx = (int) builtin_signed_long;
5208 break;
5209 case 8:
5210 indx = (int) builtin_signed_long_long;
5211 break;
5212 default:
5213 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
5214 return FALSE;
5217 if (unsignedp)
5218 ++indx;
5220 return ieee_push_type (info, indx, size, unsignedp, FALSE);
5223 /* Make a floating point type. */
5225 static bfd_boolean
5226 ieee_float_type (void *p, unsigned int size)
5228 struct ieee_handle *info = (struct ieee_handle *) p;
5229 unsigned int indx;
5231 switch (size)
5233 case 4:
5234 indx = (int) builtin_float;
5235 break;
5236 case 8:
5237 indx = (int) builtin_double;
5238 break;
5239 case 12:
5240 /* FIXME: This size really depends upon the processor. */
5241 indx = (int) builtin_long_double;
5242 break;
5243 case 16:
5244 indx = (int) builtin_long_long_double;
5245 break;
5246 default:
5247 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
5248 return FALSE;
5251 return ieee_push_type (info, indx, size, FALSE, FALSE);
5254 /* Make a complex type. */
5256 static bfd_boolean
5257 ieee_complex_type (void *p, unsigned int size)
5259 struct ieee_handle *info = (struct ieee_handle *) p;
5260 char code;
5262 switch (size)
5264 case 4:
5265 if (info->complex_float_index != 0)
5266 return ieee_push_type (info, info->complex_float_index, size * 2,
5267 FALSE, FALSE);
5268 code = 'c';
5269 break;
5270 case 12:
5271 case 16:
5272 /* These cases can be output by gcc -gstabs. Outputting the
5273 wrong type is better than crashing. */
5274 case 8:
5275 if (info->complex_double_index != 0)
5276 return ieee_push_type (info, info->complex_double_index, size * 2,
5277 FALSE, FALSE);
5278 code = 'd';
5279 break;
5280 default:
5281 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
5282 return FALSE;
5285 /* FIXME: I don't know what the string is for. */
5286 if (! ieee_define_type (info, size * 2, FALSE, FALSE)
5287 || ! ieee_write_number (info, code)
5288 || ! ieee_write_id (info, ""))
5289 return FALSE;
5291 if (size == 4)
5292 info->complex_float_index = info->type_stack->type.indx;
5293 else
5294 info->complex_double_index = info->type_stack->type.indx;
5296 return TRUE;
5299 /* Make a boolean type. IEEE doesn't support these, so we just make
5300 an integer type instead. */
5302 static bfd_boolean
5303 ieee_bool_type (void *p, unsigned int size)
5305 return ieee_int_type (p, size, TRUE);
5308 /* Make an enumeration. */
5310 static bfd_boolean
5311 ieee_enum_type (void *p, const char *tag, const char **names,
5312 bfd_signed_vma *vals)
5314 struct ieee_handle *info = (struct ieee_handle *) p;
5315 struct ieee_defined_enum *e;
5316 bfd_boolean localp, simple;
5317 unsigned int indx;
5318 int i = 0;
5320 localp = FALSE;
5321 indx = (unsigned int) -1;
5322 for (e = info->enums; e != NULL; e = e->next)
5324 if (tag == NULL)
5326 if (e->tag != NULL)
5327 continue;
5329 else
5331 if (e->tag == NULL
5332 || tag[0] != e->tag[0]
5333 || strcmp (tag, e->tag) != 0)
5334 continue;
5337 if (! e->defined)
5339 /* This enum tag has been seen but not defined. */
5340 indx = e->indx;
5341 break;
5344 if (names != NULL && e->names != NULL)
5346 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5348 if (names[i][0] != e->names[i][0]
5349 || vals[i] != e->vals[i]
5350 || strcmp (names[i], e->names[i]) != 0)
5351 break;
5355 if ((names == NULL && e->names == NULL)
5356 || (names != NULL
5357 && e->names != NULL
5358 && names[i] == NULL
5359 && e->names[i] == NULL))
5361 /* We've seen this enum before. */
5362 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
5365 if (tag != NULL)
5367 /* We've already seen an enum of the same name, so we must make
5368 sure to output this one locally. */
5369 localp = TRUE;
5370 break;
5374 /* If this is a simple enumeration, in which the values start at 0
5375 and always increment by 1, we can use type E. Otherwise we must
5376 use type N. */
5378 simple = TRUE;
5379 if (names != NULL)
5381 for (i = 0; names[i] != NULL; i++)
5383 if (vals[i] != i)
5385 simple = FALSE;
5386 break;
5391 if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
5392 (struct ieee_buflist *) NULL)
5393 || ! ieee_write_number (info, simple ? 'E' : 'N'))
5394 return FALSE;
5395 if (simple)
5397 /* FIXME: This is supposed to be the enumeration size, but we
5398 don't store that. */
5399 if (! ieee_write_number (info, 4))
5400 return FALSE;
5402 if (names != NULL)
5404 for (i = 0; names[i] != NULL; i++)
5406 if (! ieee_write_id (info, names[i]))
5407 return FALSE;
5408 if (! simple)
5410 if (! ieee_write_number (info, vals[i]))
5411 return FALSE;
5416 if (! localp)
5418 if (indx == (unsigned int) -1)
5420 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5421 memset (e, 0, sizeof *e);
5422 e->indx = info->type_stack->type.indx;
5423 e->tag = tag;
5425 e->next = info->enums;
5426 info->enums = e;
5429 e->names = names;
5430 e->vals = vals;
5431 e->defined = TRUE;
5434 return TRUE;
5437 /* Make a pointer type. */
5439 static bfd_boolean
5440 ieee_pointer_type (void *p)
5442 struct ieee_handle *info = (struct ieee_handle *) p;
5443 bfd_boolean localp;
5444 unsigned int indx;
5445 struct ieee_modified_type *m = NULL;
5447 localp = info->type_stack->type.localp;
5448 indx = ieee_pop_type (info);
5450 /* A pointer to a simple builtin type can be obtained by adding 32.
5451 FIXME: Will this be a short pointer, and will that matter? */
5452 if (indx < 32)
5453 return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);
5455 if (! localp)
5457 m = ieee_get_modified_info ((struct ieee_handle *) p, indx);
5458 if (m == NULL)
5459 return FALSE;
5461 /* FIXME: The size should depend upon the architecture. */
5462 if (m->pointer > 0)
5463 return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
5466 if (! ieee_define_type (info, 4, TRUE, localp)
5467 || ! ieee_write_number (info, 'P')
5468 || ! ieee_write_number (info, indx))
5469 return FALSE;
5471 if (! localp)
5472 m->pointer = info->type_stack->type.indx;
5474 return TRUE;
5477 /* Make a function type. This will be called for a method, but we
5478 don't want to actually add it to the type table in that case. We
5479 handle this by defining the type in a private buffer, and only
5480 adding that buffer to the typedef block if we are going to use it. */
5482 static bfd_boolean
5483 ieee_function_type (void *p, int argcount, bfd_boolean varargs)
5485 struct ieee_handle *info = (struct ieee_handle *) p;
5486 bfd_boolean localp;
5487 unsigned int *args = NULL;
5488 int i;
5489 unsigned int retindx;
5490 struct ieee_buflist fndef;
5491 struct ieee_modified_type *m;
5493 localp = FALSE;
5495 if (argcount > 0)
5497 args = (unsigned int *) xmalloc (argcount * sizeof *args);
5498 for (i = argcount - 1; i >= 0; i--)
5500 if (info->type_stack->type.localp)
5501 localp = TRUE;
5502 args[i] = ieee_pop_type (info);
5505 else if (argcount < 0)
5506 varargs = FALSE;
5508 if (info->type_stack->type.localp)
5509 localp = TRUE;
5510 retindx = ieee_pop_type (info);
5512 m = NULL;
5513 if (argcount < 0 && ! localp)
5515 m = ieee_get_modified_info ((struct ieee_handle *) p, retindx);
5516 if (m == NULL)
5517 return FALSE;
5519 if (m->function > 0)
5520 return ieee_push_type (info, m->function, 0, TRUE, FALSE);
5523 /* An attribute of 0x41 means that the frame and push mask are
5524 unknown. */
5525 if (! ieee_init_buffer (info, &fndef)
5526 || ! ieee_define_named_type (info, (const char *) NULL,
5527 (unsigned int) -1, 0, TRUE, localp,
5528 &fndef)
5529 || ! ieee_write_number (info, 'x')
5530 || ! ieee_write_number (info, 0x41)
5531 || ! ieee_write_number (info, 0)
5532 || ! ieee_write_number (info, 0)
5533 || ! ieee_write_number (info, retindx)
5534 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5536 free (args);
5537 return FALSE;
5539 if (argcount > 0)
5541 for (i = 0; i < argcount; i++)
5542 if (! ieee_write_number (info, args[i]))
5543 return FALSE;
5544 free (args);
5546 if (varargs)
5548 /* A varargs function is represented by writing out the last
5549 argument as type void *, although this makes little sense. */
5550 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5551 return FALSE;
5554 if (! ieee_write_number (info, 0))
5555 return FALSE;
5557 /* We wrote the information into fndef, in case we don't need it.
5558 It will be appended to info->types by ieee_pop_type. */
5559 info->type_stack->type.fndef = fndef;
5561 if (m != NULL)
5562 m->function = info->type_stack->type.indx;
5564 return TRUE;
5567 /* Make a reference type. */
5569 static bfd_boolean
5570 ieee_reference_type (void *p)
5572 struct ieee_handle *info = (struct ieee_handle *) p;
5574 /* IEEE appears to record a normal pointer type, and then use a
5575 pmisc record to indicate that it is really a reference. */
5577 if (! ieee_pointer_type (p))
5578 return FALSE;
5579 info->type_stack->type.referencep = TRUE;
5580 return TRUE;
5583 /* Make a range type. */
5585 static bfd_boolean
5586 ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
5588 struct ieee_handle *info = (struct ieee_handle *) p;
5589 unsigned int size;
5590 bfd_boolean unsignedp, localp;
5592 size = info->type_stack->type.size;
5593 unsignedp = info->type_stack->type.unsignedp;
5594 localp = info->type_stack->type.localp;
5595 ieee_pop_unused_type (info);
5596 return (ieee_define_type (info, size, unsignedp, localp)
5597 && ieee_write_number (info, 'R')
5598 && ieee_write_number (info, (bfd_vma) low)
5599 && ieee_write_number (info, (bfd_vma) high)
5600 && ieee_write_number (info, unsignedp ? 0 : 1)
5601 && ieee_write_number (info, size));
5604 /* Make an array type. */
5606 static bfd_boolean
5607 ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
5608 bfd_boolean stringp ATTRIBUTE_UNUSED)
5610 struct ieee_handle *info = (struct ieee_handle *) p;
5611 unsigned int eleindx;
5612 bfd_boolean localp;
5613 unsigned int size;
5614 struct ieee_modified_type *m = NULL;
5615 struct ieee_modified_array_type *a;
5617 /* IEEE does not store the range, so we just ignore it. */
5618 ieee_pop_unused_type (info);
5619 localp = info->type_stack->type.localp;
5620 size = info->type_stack->type.size;
5621 eleindx = ieee_pop_type (info);
5623 /* If we don't know the range, treat the size as exactly one
5624 element. */
5625 if (low < high)
5626 size *= (high - low) + 1;
5628 if (! localp)
5630 m = ieee_get_modified_info (info, eleindx);
5631 if (m == NULL)
5632 return FALSE;
5634 for (a = m->arrays; a != NULL; a = a->next)
5636 if (a->low == low && a->high == high)
5637 return ieee_push_type (info, a->indx, size, FALSE, FALSE);
5641 if (! ieee_define_type (info, size, FALSE, localp)
5642 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5643 || ! ieee_write_number (info, eleindx))
5644 return FALSE;
5645 if (low != 0)
5647 if (! ieee_write_number (info, low))
5648 return FALSE;
5651 if (! ieee_write_number (info, high + 1))
5652 return FALSE;
5654 if (! localp)
5656 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5657 memset (a, 0, sizeof *a);
5659 a->indx = info->type_stack->type.indx;
5660 a->low = low;
5661 a->high = high;
5663 a->next = m->arrays;
5664 m->arrays = a;
5667 return TRUE;
5670 /* Make a set type. */
5672 static bfd_boolean
5673 ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
5675 struct ieee_handle *info = (struct ieee_handle *) p;
5676 bfd_boolean localp;
5677 unsigned int eleindx;
5679 localp = info->type_stack->type.localp;
5680 eleindx = ieee_pop_type (info);
5682 /* FIXME: We don't know the size, so we just use 4. */
5684 return (ieee_define_type (info, 0, TRUE, localp)
5685 && ieee_write_number (info, 's')
5686 && ieee_write_number (info, 4)
5687 && ieee_write_number (info, eleindx));
5690 /* Make an offset type. */
5692 static bfd_boolean
5693 ieee_offset_type (void *p)
5695 /* FIXME: The MRI C++ compiler does not appear to generate any
5696 useful type information about an offset type. It just records a
5697 pointer to member as an integer. The MRI/HP IEEE spec does
5698 describe a pmisc record which can be used for a pointer to
5699 member. Unfortunately, it does not describe the target type,
5700 which seems pretty important. I'm going to punt this for now. */
5702 return ieee_int_type (p, 4, TRUE);
5705 /* Make a method type. */
5707 static bfd_boolean
5708 ieee_method_type (void *p, bfd_boolean domain, int argcount,
5709 bfd_boolean varargs)
5711 struct ieee_handle *info = (struct ieee_handle *) p;
5713 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5714 method, but the definition is incomplete. We just output an 'x'
5715 type. */
5717 if (domain)
5718 ieee_pop_unused_type (info);
5720 return ieee_function_type (p, argcount, varargs);
5723 /* Make a const qualified type. */
5725 static bfd_boolean
5726 ieee_const_type (void *p)
5728 struct ieee_handle *info = (struct ieee_handle *) p;
5729 unsigned int size;
5730 bfd_boolean unsignedp, localp;
5731 unsigned int indx;
5732 struct ieee_modified_type *m = NULL;
5734 size = info->type_stack->type.size;
5735 unsignedp = info->type_stack->type.unsignedp;
5736 localp = info->type_stack->type.localp;
5737 indx = ieee_pop_type (info);
5739 if (! localp)
5741 m = ieee_get_modified_info (info, indx);
5742 if (m == NULL)
5743 return FALSE;
5745 if (m->const_qualified > 0)
5746 return ieee_push_type (info, m->const_qualified, size, unsignedp,
5747 FALSE);
5750 if (! ieee_define_type (info, size, unsignedp, localp)
5751 || ! ieee_write_number (info, 'n')
5752 || ! ieee_write_number (info, 1)
5753 || ! ieee_write_number (info, indx))
5754 return FALSE;
5756 if (! localp)
5757 m->const_qualified = info->type_stack->type.indx;
5759 return TRUE;
5762 /* Make a volatile qualified type. */
5764 static bfd_boolean
5765 ieee_volatile_type (void *p)
5767 struct ieee_handle *info = (struct ieee_handle *) p;
5768 unsigned int size;
5769 bfd_boolean unsignedp, localp;
5770 unsigned int indx;
5771 struct ieee_modified_type *m = NULL;
5773 size = info->type_stack->type.size;
5774 unsignedp = info->type_stack->type.unsignedp;
5775 localp = info->type_stack->type.localp;
5776 indx = ieee_pop_type (info);
5778 if (! localp)
5780 m = ieee_get_modified_info (info, indx);
5781 if (m == NULL)
5782 return FALSE;
5784 if (m->volatile_qualified > 0)
5785 return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
5786 FALSE);
5789 if (! ieee_define_type (info, size, unsignedp, localp)
5790 || ! ieee_write_number (info, 'n')
5791 || ! ieee_write_number (info, 2)
5792 || ! ieee_write_number (info, indx))
5793 return FALSE;
5795 if (! localp)
5796 m->volatile_qualified = info->type_stack->type.indx;
5798 return TRUE;
5801 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5803 static unsigned int
5804 ieee_vis_to_flags (enum debug_visibility visibility)
5806 switch (visibility)
5808 default:
5809 abort ();
5810 case DEBUG_VISIBILITY_PUBLIC:
5811 return CXXFLAGS_VISIBILITY_PUBLIC;
5812 case DEBUG_VISIBILITY_PRIVATE:
5813 return CXXFLAGS_VISIBILITY_PRIVATE;
5814 case DEBUG_VISIBILITY_PROTECTED:
5815 return CXXFLAGS_VISIBILITY_PROTECTED;
5817 /*NOTREACHED*/
5820 /* Start defining a struct type. We build it in the strdef field on
5821 the stack, to avoid confusing type definitions required by the
5822 fields with the struct type itself. */
5824 static bfd_boolean
5825 ieee_start_struct_type (void *p, const char *tag, unsigned int id,
5826 bfd_boolean structp, unsigned int size)
5828 struct ieee_handle *info = (struct ieee_handle *) p;
5829 bfd_boolean localp, ignorep;
5830 bfd_boolean copy;
5831 char ab[20];
5832 const char *look;
5833 struct ieee_name_type_hash_entry *h;
5834 struct ieee_name_type *nt, *ntlook;
5835 struct ieee_buflist strdef;
5837 localp = FALSE;
5838 ignorep = FALSE;
5840 /* We need to create a tag for internal use even if we don't want
5841 one for external use. This will let us refer to an anonymous
5842 struct. */
5843 if (tag != NULL)
5845 look = tag;
5846 copy = FALSE;
5848 else
5850 sprintf (ab, "__anon%u", id);
5851 look = ab;
5852 copy = TRUE;
5855 /* If we already have references to the tag, we must use the
5856 existing type index. */
5857 h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy);
5858 if (h == NULL)
5859 return FALSE;
5861 nt = NULL;
5862 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
5864 if (ntlook->id == id)
5865 nt = ntlook;
5866 else if (! ntlook->type.localp)
5868 /* We are creating a duplicate definition of a globally
5869 defined tag. Force it to be local to avoid
5870 confusion. */
5871 localp = TRUE;
5875 if (nt != NULL)
5877 assert (localp == nt->type.localp);
5878 if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
5880 /* We've already seen a global definition of the type.
5881 Ignore this new definition. */
5882 ignorep = TRUE;
5885 else
5887 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5888 memset (nt, 0, sizeof *nt);
5889 nt->id = id;
5890 nt->type.name = h->root.string;
5891 nt->next = h->types;
5892 h->types = nt;
5893 nt->type.indx = info->type_indx;
5894 ++info->type_indx;
5897 nt->kind = DEBUG_KIND_ILLEGAL;
5899 if (! ieee_init_buffer (info, &strdef)
5900 || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE,
5901 localp, &strdef)
5902 || ! ieee_write_number (info, structp ? 'S' : 'U')
5903 || ! ieee_write_number (info, size))
5904 return FALSE;
5906 if (! ignorep)
5908 const char *hold;
5910 /* We never want nt->type.name to be NULL. We want the rest of
5911 the type to be the object set up on the type stack; it will
5912 have a NULL name if tag is NULL. */
5913 hold = nt->type.name;
5914 nt->type = info->type_stack->type;
5915 nt->type.name = hold;
5918 info->type_stack->type.name = tag;
5919 info->type_stack->type.strdef = strdef;
5920 info->type_stack->type.ignorep = ignorep;
5922 return TRUE;
5925 /* Add a field to a struct. */
5927 static bfd_boolean
5928 ieee_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
5929 enum debug_visibility visibility)
5931 struct ieee_handle *info = (struct ieee_handle *) p;
5932 unsigned int size;
5933 bfd_boolean unsignedp;
5934 bfd_boolean referencep;
5935 bfd_boolean localp;
5936 unsigned int indx;
5937 bfd_vma offset;
5939 assert (info->type_stack != NULL
5940 && info->type_stack->next != NULL
5941 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
5943 /* If we are ignoring this struct definition, just pop and ignore
5944 the type. */
5945 if (info->type_stack->next->type.ignorep)
5947 ieee_pop_unused_type (info);
5948 return TRUE;
5951 size = info->type_stack->type.size;
5952 unsignedp = info->type_stack->type.unsignedp;
5953 referencep = info->type_stack->type.referencep;
5954 localp = info->type_stack->type.localp;
5955 indx = ieee_pop_type (info);
5957 if (localp)
5958 info->type_stack->type.localp = TRUE;
5960 if (info->type_stack->type.classdef != NULL)
5962 unsigned int flags;
5963 unsigned int nindx;
5965 /* This is a class. We must add a description of this field to
5966 the class records we are building. */
5968 flags = ieee_vis_to_flags (visibility);
5969 nindx = info->type_stack->type.classdef->indx;
5970 if (! ieee_change_buffer (info,
5971 &info->type_stack->type.classdef->pmiscbuf)
5972 || ! ieee_write_asn (info, nindx, 'd')
5973 || ! ieee_write_asn (info, nindx, flags)
5974 || ! ieee_write_atn65 (info, nindx, name)
5975 || ! ieee_write_atn65 (info, nindx, name))
5976 return FALSE;
5977 info->type_stack->type.classdef->pmisccount += 4;
5979 if (referencep)
5981 /* We need to output a record recording that this field is
5982 really of reference type. We put this on the refs field
5983 of classdef, so that it can be appended to the C++
5984 records after the class is defined. */
5986 nindx = info->name_indx;
5987 ++info->name_indx;
5989 if (! ieee_change_buffer (info,
5990 &info->type_stack->type.classdef->refs)
5991 || ! ieee_write_byte (info, (int) ieee_nn_record)
5992 || ! ieee_write_number (info, nindx)
5993 || ! ieee_write_id (info, "")
5994 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5995 || ! ieee_write_number (info, nindx)
5996 || ! ieee_write_number (info, 0)
5997 || ! ieee_write_number (info, 62)
5998 || ! ieee_write_number (info, 80)
5999 || ! ieee_write_number (info, 4)
6000 || ! ieee_write_asn (info, nindx, 'R')
6001 || ! ieee_write_asn (info, nindx, 3)
6002 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
6003 || ! ieee_write_atn65 (info, nindx, name))
6004 return FALSE;
6008 /* If the bitsize doesn't match the expected size, we need to output
6009 a bitfield type. */
6010 if (size == 0 || bitsize == 0 || bitsize == size * 8)
6011 offset = bitpos / 8;
6012 else
6014 if (! ieee_define_type (info, 0, unsignedp,
6015 info->type_stack->type.localp)
6016 || ! ieee_write_number (info, 'g')
6017 || ! ieee_write_number (info, unsignedp ? 0 : 1)
6018 || ! ieee_write_number (info, bitsize)
6019 || ! ieee_write_number (info, indx))
6020 return FALSE;
6021 indx = ieee_pop_type (info);
6022 offset = bitpos;
6025 /* Switch to the struct we are building in order to output this
6026 field definition. */
6027 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
6028 && ieee_write_id (info, name)
6029 && ieee_write_number (info, indx)
6030 && ieee_write_number (info, offset));
6033 /* Finish up a struct type. */
6035 static bfd_boolean
6036 ieee_end_struct_type (void *p)
6038 struct ieee_handle *info = (struct ieee_handle *) p;
6039 struct ieee_buflist *pb;
6041 assert (info->type_stack != NULL
6042 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
6044 /* If we were ignoring this struct definition because it was a
6045 duplicate definition, just through away whatever bytes we have
6046 accumulated. Leave the type on the stack. */
6047 if (info->type_stack->type.ignorep)
6048 return TRUE;
6050 /* If this is not a duplicate definition of this tag, then localp
6051 will be FALSE, and we can put it in the global type block.
6052 FIXME: We should avoid outputting duplicate definitions which are
6053 the same. */
6054 if (! info->type_stack->type.localp)
6056 /* Make sure we have started the global type block. */
6057 if (ieee_buffer_emptyp (&info->global_types))
6059 if (! ieee_change_buffer (info, &info->global_types)
6060 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6061 || ! ieee_write_byte (info, 2)
6062 || ! ieee_write_number (info, 0)
6063 || ! ieee_write_id (info, ""))
6064 return FALSE;
6066 pb = &info->global_types;
6068 else
6070 /* Make sure we have started the types block. */
6071 if (ieee_buffer_emptyp (&info->types))
6073 if (! ieee_change_buffer (info, &info->types)
6074 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6075 || ! ieee_write_byte (info, 1)
6076 || ! ieee_write_number (info, 0)
6077 || ! ieee_write_id (info, info->modname))
6078 return FALSE;
6080 pb = &info->types;
6083 /* Append the struct definition to the types. */
6084 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6085 || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6086 return FALSE;
6088 /* Leave the struct on the type stack. */
6090 return TRUE;
6093 /* Start a class type. */
6095 static bfd_boolean
6096 ieee_start_class_type (void *p, const char *tag, unsigned int id,
6097 bfd_boolean structp, unsigned int size,
6098 bfd_boolean vptr, bfd_boolean ownvptr)
6100 struct ieee_handle *info = (struct ieee_handle *) p;
6101 const char *vclass;
6102 struct ieee_buflist pmiscbuf;
6103 unsigned int indx;
6104 struct ieee_type_class *classdef;
6106 /* A C++ class is output as a C++ struct along with a set of pmisc
6107 records describing the class. */
6109 /* We need to have a name so that we can associate the struct and
6110 the class. */
6111 if (tag == NULL)
6113 char *t;
6115 t = (char *) xmalloc (20);
6116 sprintf (t, "__anon%u", id);
6117 tag = t;
6120 /* We can't write out the virtual table information until we have
6121 finished the class, because we don't know the virtual table size.
6122 We get the size from the largest voffset we see. */
6123 vclass = NULL;
6124 if (vptr && ! ownvptr)
6126 vclass = info->type_stack->type.name;
6127 assert (vclass != NULL);
6128 /* We don't call ieee_pop_unused_type, since the class should
6129 get defined. */
6130 (void) ieee_pop_type (info);
6133 if (! ieee_start_struct_type (p, tag, id, structp, size))
6134 return FALSE;
6136 indx = info->name_indx;
6137 ++info->name_indx;
6139 /* We write out pmisc records into the classdef field. We will
6140 write out the pmisc start after we know the number of records we
6141 need. */
6142 if (! ieee_init_buffer (info, &pmiscbuf)
6143 || ! ieee_change_buffer (info, &pmiscbuf)
6144 || ! ieee_write_asn (info, indx, 'T')
6145 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6146 || ! ieee_write_atn65 (info, indx, tag))
6147 return FALSE;
6149 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6150 memset (classdef, 0, sizeof *classdef);
6152 classdef->indx = indx;
6153 classdef->pmiscbuf = pmiscbuf;
6154 classdef->pmisccount = 3;
6155 classdef->vclass = vclass;
6156 classdef->ownvptr = ownvptr;
6158 info->type_stack->type.classdef = classdef;
6160 return TRUE;
6163 /* Add a static member to a class. */
6165 static bfd_boolean
6166 ieee_class_static_member (void *p, const char *name, const char *physname,
6167 enum debug_visibility visibility)
6169 struct ieee_handle *info = (struct ieee_handle *) p;
6170 unsigned int flags;
6171 unsigned int nindx;
6173 /* We don't care about the type. Hopefully there will be a call to
6174 ieee_variable declaring the physical name and the type, since
6175 that is where an IEEE consumer must get the type. */
6176 ieee_pop_unused_type (info);
6178 assert (info->type_stack != NULL
6179 && info->type_stack->type.classdef != NULL);
6181 flags = ieee_vis_to_flags (visibility);
6182 flags |= CXXFLAGS_STATIC;
6184 nindx = info->type_stack->type.classdef->indx;
6186 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6187 || ! ieee_write_asn (info, nindx, 'd')
6188 || ! ieee_write_asn (info, nindx, flags)
6189 || ! ieee_write_atn65 (info, nindx, name)
6190 || ! ieee_write_atn65 (info, nindx, physname))
6191 return FALSE;
6192 info->type_stack->type.classdef->pmisccount += 4;
6194 return TRUE;
6197 /* Add a base class to a class. */
6199 static bfd_boolean
6200 ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
6201 enum debug_visibility visibility)
6203 struct ieee_handle *info = (struct ieee_handle *) p;
6204 const char *bname;
6205 bfd_boolean localp;
6206 unsigned int bindx;
6207 char *fname;
6208 unsigned int flags;
6209 unsigned int nindx;
6211 assert (info->type_stack != NULL
6212 && info->type_stack->type.name != NULL
6213 && info->type_stack->next != NULL
6214 && info->type_stack->next->type.classdef != NULL
6215 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6217 bname = info->type_stack->type.name;
6218 localp = info->type_stack->type.localp;
6219 bindx = ieee_pop_type (info);
6221 /* We are currently defining both a struct and a class. We must
6222 write out a field definition in the struct which holds the base
6223 class. The stabs debugging reader will create a field named
6224 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6225 we should not depend upon a detail of stabs debugging. */
6226 if (is_virtual)
6228 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6229 sprintf (fname, "_vb$%s", bname);
6230 flags = BASEFLAGS_VIRTUAL;
6232 else
6234 if (localp)
6235 info->type_stack->type.localp = TRUE;
6237 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6238 sprintf (fname, "_b$%s", bname);
6240 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6241 || ! ieee_write_id (info, fname)
6242 || ! ieee_write_number (info, bindx)
6243 || ! ieee_write_number (info, bitpos / 8))
6245 free (fname);
6246 return FALSE;
6248 flags = 0;
6251 if (visibility == DEBUG_VISIBILITY_PRIVATE)
6252 flags |= BASEFLAGS_PRIVATE;
6254 nindx = info->type_stack->type.classdef->indx;
6256 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6257 || ! ieee_write_asn (info, nindx, 'b')
6258 || ! ieee_write_asn (info, nindx, flags)
6259 || ! ieee_write_atn65 (info, nindx, bname)
6260 || ! ieee_write_asn (info, nindx, 0)
6261 || ! ieee_write_atn65 (info, nindx, fname))
6263 free (fname);
6264 return FALSE;
6266 info->type_stack->type.classdef->pmisccount += 5;
6268 free (fname);
6270 return TRUE;
6273 /* Start building a method for a class. */
6275 static bfd_boolean
6276 ieee_class_start_method (void *p, const char *name)
6278 struct ieee_handle *info = (struct ieee_handle *) p;
6280 assert (info->type_stack != NULL
6281 && info->type_stack->type.classdef != NULL
6282 && info->type_stack->type.classdef->method == NULL);
6284 info->type_stack->type.classdef->method = name;
6286 return TRUE;
6289 /* Define a new method variant, either static or not. */
6291 static bfd_boolean
6292 ieee_class_method_var (struct ieee_handle *info, const char *physname,
6293 enum debug_visibility visibility,
6294 bfd_boolean staticp, bfd_boolean constp,
6295 bfd_boolean volatilep, bfd_vma voffset,
6296 bfd_boolean context)
6298 unsigned int flags;
6299 unsigned int nindx;
6300 bfd_boolean is_virtual;
6302 /* We don't need the type of the method. An IEEE consumer which
6303 wants the type must track down the function by the physical name
6304 and get the type from that. */
6305 ieee_pop_unused_type (info);
6307 /* We don't use the context. FIXME: We probably ought to use it to
6308 adjust the voffset somehow, but I don't really know how. */
6309 if (context)
6310 ieee_pop_unused_type (info);
6312 assert (info->type_stack != NULL
6313 && info->type_stack->type.classdef != NULL
6314 && info->type_stack->type.classdef->method != NULL);
6316 flags = ieee_vis_to_flags (visibility);
6318 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6319 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6321 if (staticp)
6322 flags |= CXXFLAGS_STATIC;
6323 if (constp)
6324 flags |= CXXFLAGS_CONST;
6325 if (volatilep)
6326 flags |= CXXFLAGS_VOLATILE;
6328 nindx = info->type_stack->type.classdef->indx;
6330 is_virtual = context || voffset > 0;
6332 if (! ieee_change_buffer (info,
6333 &info->type_stack->type.classdef->pmiscbuf)
6334 || ! ieee_write_asn (info, nindx, is_virtual ? 'v' : 'm')
6335 || ! ieee_write_asn (info, nindx, flags)
6336 || ! ieee_write_atn65 (info, nindx,
6337 info->type_stack->type.classdef->method)
6338 || ! ieee_write_atn65 (info, nindx, physname))
6339 return FALSE;
6341 if (is_virtual)
6343 if (voffset > info->type_stack->type.classdef->voffset)
6344 info->type_stack->type.classdef->voffset = voffset;
6345 if (! ieee_write_asn (info, nindx, voffset))
6346 return FALSE;
6347 ++info->type_stack->type.classdef->pmisccount;
6350 if (! ieee_write_asn (info, nindx, 0))
6351 return FALSE;
6353 info->type_stack->type.classdef->pmisccount += 5;
6355 return TRUE;
6358 /* Define a new method variant. */
6360 static bfd_boolean
6361 ieee_class_method_variant (void *p, const char *physname,
6362 enum debug_visibility visibility,
6363 bfd_boolean constp, bfd_boolean volatilep,
6364 bfd_vma voffset, bfd_boolean context)
6366 struct ieee_handle *info = (struct ieee_handle *) p;
6368 return ieee_class_method_var (info, physname, visibility, FALSE, constp,
6369 volatilep, voffset, context);
6372 /* Define a new static method variant. */
6374 static bfd_boolean
6375 ieee_class_static_method_variant (void *p, const char *physname,
6376 enum debug_visibility visibility,
6377 bfd_boolean constp, bfd_boolean volatilep)
6379 struct ieee_handle *info = (struct ieee_handle *) p;
6381 return ieee_class_method_var (info, physname, visibility, TRUE, constp,
6382 volatilep, 0, FALSE);
6385 /* Finish up a method. */
6387 static bfd_boolean
6388 ieee_class_end_method (void *p)
6390 struct ieee_handle *info = (struct ieee_handle *) p;
6392 assert (info->type_stack != NULL
6393 && info->type_stack->type.classdef != NULL
6394 && info->type_stack->type.classdef->method != NULL);
6396 info->type_stack->type.classdef->method = NULL;
6398 return TRUE;
6401 /* Finish up a class. */
6403 static bfd_boolean
6404 ieee_end_class_type (void *p)
6406 struct ieee_handle *info = (struct ieee_handle *) p;
6407 unsigned int nindx;
6409 assert (info->type_stack != NULL
6410 && info->type_stack->type.classdef != NULL);
6412 /* If we were ignoring this class definition because it was a
6413 duplicate definition, just through away whatever bytes we have
6414 accumulated. Leave the type on the stack. */
6415 if (info->type_stack->type.ignorep)
6416 return TRUE;
6418 nindx = info->type_stack->type.classdef->indx;
6420 /* If we have a virtual table, we can write out the information now. */
6421 if (info->type_stack->type.classdef->vclass != NULL
6422 || info->type_stack->type.classdef->ownvptr)
6424 if (! ieee_change_buffer (info,
6425 &info->type_stack->type.classdef->pmiscbuf)
6426 || ! ieee_write_asn (info, nindx, 'z')
6427 || ! ieee_write_atn65 (info, nindx, "")
6428 || ! ieee_write_asn (info, nindx,
6429 info->type_stack->type.classdef->voffset))
6430 return FALSE;
6431 if (info->type_stack->type.classdef->ownvptr)
6433 if (! ieee_write_atn65 (info, nindx, ""))
6434 return FALSE;
6436 else
6438 if (! ieee_write_atn65 (info, nindx,
6439 info->type_stack->type.classdef->vclass))
6440 return FALSE;
6442 if (! ieee_write_asn (info, nindx, 0))
6443 return FALSE;
6444 info->type_stack->type.classdef->pmisccount += 5;
6447 /* Now that we know the number of pmisc records, we can write out
6448 the atn62 which starts the pmisc records, and append them to the
6449 C++ buffers. */
6451 if (! ieee_change_buffer (info, &info->cxx)
6452 || ! ieee_write_byte (info, (int) ieee_nn_record)
6453 || ! ieee_write_number (info, nindx)
6454 || ! ieee_write_id (info, "")
6455 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6456 || ! ieee_write_number (info, nindx)
6457 || ! ieee_write_number (info, 0)
6458 || ! ieee_write_number (info, 62)
6459 || ! ieee_write_number (info, 80)
6460 || ! ieee_write_number (info,
6461 info->type_stack->type.classdef->pmisccount))
6462 return FALSE;
6464 if (! ieee_append_buffer (info, &info->cxx,
6465 &info->type_stack->type.classdef->pmiscbuf))
6466 return FALSE;
6467 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6469 if (! ieee_append_buffer (info, &info->cxx,
6470 &info->type_stack->type.classdef->refs))
6471 return FALSE;
6474 return ieee_end_struct_type (p);
6477 /* Push a previously seen typedef onto the type stack. */
6479 static bfd_boolean
6480 ieee_typedef_type (void *p, const char *name)
6482 struct ieee_handle *info = (struct ieee_handle *) p;
6483 struct ieee_name_type_hash_entry *h;
6484 struct ieee_name_type *nt;
6486 h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);
6488 /* h should never be NULL, since that would imply that the generic
6489 debugging code has asked for a typedef which it has not yet
6490 defined. */
6491 assert (h != NULL);
6493 /* We always use the most recently defined type for this name, which
6494 will be the first one on the list. */
6496 nt = h->types;
6497 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6498 nt->type.unsignedp, nt->type.localp))
6499 return FALSE;
6501 /* Copy over any other type information we may have. */
6502 info->type_stack->type = nt->type;
6504 return TRUE;
6507 /* Push a tagged type onto the type stack. */
6509 static bfd_boolean
6510 ieee_tag_type (void *p, const char *name, unsigned int id,
6511 enum debug_type_kind kind)
6513 struct ieee_handle *info = (struct ieee_handle *) p;
6514 bfd_boolean localp;
6515 bfd_boolean copy;
6516 char ab[20];
6517 struct ieee_name_type_hash_entry *h;
6518 struct ieee_name_type *nt;
6520 if (kind == DEBUG_KIND_ENUM)
6522 struct ieee_defined_enum *e;
6524 if (name == NULL)
6525 abort ();
6526 for (e = info->enums; e != NULL; e = e->next)
6527 if (e->tag != NULL && strcmp (e->tag, name) == 0)
6528 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6530 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
6531 memset (e, 0, sizeof *e);
6533 e->indx = info->type_indx;
6534 ++info->type_indx;
6535 e->tag = name;
6536 e->defined = FALSE;
6538 e->next = info->enums;
6539 info->enums = e;
6541 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6544 localp = FALSE;
6546 copy = FALSE;
6547 if (name == NULL)
6549 sprintf (ab, "__anon%u", id);
6550 name = ab;
6551 copy = TRUE;
6554 h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
6555 if (h == NULL)
6556 return FALSE;
6558 for (nt = h->types; nt != NULL; nt = nt->next)
6560 if (nt->id == id)
6562 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6563 nt->type.unsignedp, nt->type.localp))
6564 return FALSE;
6565 /* Copy over any other type information we may have. */
6566 info->type_stack->type = nt->type;
6567 return TRUE;
6570 if (! nt->type.localp)
6572 /* This is a duplicate of a global type, so it must be
6573 local. */
6574 localp = TRUE;
6578 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6579 memset (nt, 0, sizeof *nt);
6581 nt->id = id;
6582 nt->type.name = h->root.string;
6583 nt->type.indx = info->type_indx;
6584 nt->type.localp = localp;
6585 ++info->type_indx;
6586 nt->kind = kind;
6588 nt->next = h->types;
6589 h->types = nt;
6591 if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
6592 return FALSE;
6594 info->type_stack->type.name = h->root.string;
6596 return TRUE;
6599 /* Output a typedef. */
6601 static bfd_boolean
6602 ieee_typdef (void *p, const char *name)
6604 struct ieee_handle *info = (struct ieee_handle *) p;
6605 struct ieee_write_type type;
6606 unsigned int indx;
6607 bfd_boolean found;
6608 bfd_boolean localp;
6609 struct ieee_name_type_hash_entry *h;
6610 struct ieee_name_type *nt;
6612 type = info->type_stack->type;
6613 indx = type.indx;
6615 /* If this is a simple builtin type using a builtin name, we don't
6616 want to output the typedef itself. We also want to change the
6617 type index to correspond to the name being used. We recognize
6618 names used in stabs debugging output even if they don't exactly
6619 correspond to the names used for the IEEE builtin types. */
6620 found = FALSE;
6621 if (indx <= (unsigned int) builtin_bcd_float)
6623 switch ((enum builtin_types) indx)
6625 default:
6626 break;
6628 case builtin_void:
6629 if (strcmp (name, "void") == 0)
6630 found = TRUE;
6631 break;
6633 case builtin_signed_char:
6634 case builtin_char:
6635 if (strcmp (name, "signed char") == 0)
6637 indx = (unsigned int) builtin_signed_char;
6638 found = TRUE;
6640 else if (strcmp (name, "char") == 0)
6642 indx = (unsigned int) builtin_char;
6643 found = TRUE;
6645 break;
6647 case builtin_unsigned_char:
6648 if (strcmp (name, "unsigned char") == 0)
6649 found = TRUE;
6650 break;
6652 case builtin_signed_short_int:
6653 case builtin_short:
6654 case builtin_short_int:
6655 case builtin_signed_short:
6656 if (strcmp (name, "signed short int") == 0)
6658 indx = (unsigned int) builtin_signed_short_int;
6659 found = TRUE;
6661 else if (strcmp (name, "short") == 0)
6663 indx = (unsigned int) builtin_short;
6664 found = TRUE;
6666 else if (strcmp (name, "short int") == 0)
6668 indx = (unsigned int) builtin_short_int;
6669 found = TRUE;
6671 else if (strcmp (name, "signed short") == 0)
6673 indx = (unsigned int) builtin_signed_short;
6674 found = TRUE;
6676 break;
6678 case builtin_unsigned_short_int:
6679 case builtin_unsigned_short:
6680 if (strcmp (name, "unsigned short int") == 0
6681 || strcmp (name, "short unsigned int") == 0)
6683 indx = builtin_unsigned_short_int;
6684 found = TRUE;
6686 else if (strcmp (name, "unsigned short") == 0)
6688 indx = builtin_unsigned_short;
6689 found = TRUE;
6691 break;
6693 case builtin_signed_long:
6694 case builtin_int: /* FIXME: Size depends upon architecture. */
6695 case builtin_long:
6696 if (strcmp (name, "signed long") == 0)
6698 indx = builtin_signed_long;
6699 found = TRUE;
6701 else if (strcmp (name, "int") == 0)
6703 indx = builtin_int;
6704 found = TRUE;
6706 else if (strcmp (name, "long") == 0
6707 || strcmp (name, "long int") == 0)
6709 indx = builtin_long;
6710 found = TRUE;
6712 break;
6714 case builtin_unsigned_long:
6715 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
6716 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
6717 if (strcmp (name, "unsigned long") == 0
6718 || strcmp (name, "long unsigned int") == 0)
6720 indx = builtin_unsigned_long;
6721 found = TRUE;
6723 else if (strcmp (name, "unsigned") == 0)
6725 indx = builtin_unsigned;
6726 found = TRUE;
6728 else if (strcmp (name, "unsigned int") == 0)
6730 indx = builtin_unsigned_int;
6731 found = TRUE;
6733 break;
6735 case builtin_signed_long_long:
6736 if (strcmp (name, "signed long long") == 0
6737 || strcmp (name, "long long int") == 0)
6738 found = TRUE;
6739 break;
6741 case builtin_unsigned_long_long:
6742 if (strcmp (name, "unsigned long long") == 0
6743 || strcmp (name, "long long unsigned int") == 0)
6744 found = TRUE;
6745 break;
6747 case builtin_float:
6748 if (strcmp (name, "float") == 0)
6749 found = TRUE;
6750 break;
6752 case builtin_double:
6753 if (strcmp (name, "double") == 0)
6754 found = TRUE;
6755 break;
6757 case builtin_long_double:
6758 if (strcmp (name, "long double") == 0)
6759 found = TRUE;
6760 break;
6762 case builtin_long_long_double:
6763 if (strcmp (name, "long long double") == 0)
6764 found = TRUE;
6765 break;
6768 if (found)
6769 type.indx = indx;
6772 h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
6773 if (h == NULL)
6774 return FALSE;
6776 /* See if we have already defined this type with this name. */
6777 localp = type.localp;
6778 for (nt = h->types; nt != NULL; nt = nt->next)
6780 if (nt->id == indx)
6782 /* If this is a global definition, then we don't need to
6783 do anything here. */
6784 if (! nt->type.localp)
6786 ieee_pop_unused_type (info);
6787 return TRUE;
6790 else
6792 /* This is a duplicate definition, so make this one local. */
6793 localp = TRUE;
6797 /* We need to add a new typedef for this type. */
6799 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6800 memset (nt, 0, sizeof *nt);
6801 nt->id = indx;
6802 nt->type = type;
6803 nt->type.name = name;
6804 nt->type.localp = localp;
6805 nt->kind = DEBUG_KIND_ILLEGAL;
6807 nt->next = h->types;
6808 h->types = nt;
6810 if (found)
6812 /* This is one of the builtin typedefs, so we don't need to
6813 actually define it. */
6814 ieee_pop_unused_type (info);
6815 return TRUE;
6818 indx = ieee_pop_type (info);
6820 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
6821 type.unsignedp, localp,
6822 (struct ieee_buflist *) NULL)
6823 || ! ieee_write_number (info, 'T')
6824 || ! ieee_write_number (info, indx))
6825 return FALSE;
6827 /* Remove the type we just added to the type stack. This should not
6828 be ieee_pop_unused_type, since the type is used, we just don't
6829 need it now. */
6830 (void) ieee_pop_type (info);
6832 return TRUE;
6835 /* Output a tag for a type. We don't have to do anything here. */
6837 static bfd_boolean
6838 ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED)
6840 struct ieee_handle *info = (struct ieee_handle *) p;
6842 /* This should not be ieee_pop_unused_type, since we want the type
6843 to be defined. */
6844 (void) ieee_pop_type (info);
6845 return TRUE;
6848 /* Output an integer constant. */
6850 static bfd_boolean
6851 ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED,
6852 bfd_vma val ATTRIBUTE_UNUSED)
6854 /* FIXME. */
6855 return TRUE;
6858 /* Output a floating point constant. */
6860 static bfd_boolean
6861 ieee_float_constant (void *p ATTRIBUTE_UNUSED,
6862 const char *name ATTRIBUTE_UNUSED,
6863 double val ATTRIBUTE_UNUSED)
6865 /* FIXME. */
6866 return TRUE;
6869 /* Output a typed constant. */
6871 static bfd_boolean
6872 ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED,
6873 bfd_vma val ATTRIBUTE_UNUSED)
6875 struct ieee_handle *info = (struct ieee_handle *) p;
6877 /* FIXME. */
6878 ieee_pop_unused_type (info);
6879 return TRUE;
6882 /* Output a variable. */
6884 static bfd_boolean
6885 ieee_variable (void *p, const char *name, enum debug_var_kind kind,
6886 bfd_vma val)
6888 struct ieee_handle *info = (struct ieee_handle *) p;
6889 unsigned int name_indx;
6890 unsigned int size;
6891 bfd_boolean referencep;
6892 unsigned int type_indx;
6893 bfd_boolean asn;
6894 int refflag;
6896 size = info->type_stack->type.size;
6897 referencep = info->type_stack->type.referencep;
6898 type_indx = ieee_pop_type (info);
6900 assert (! ieee_buffer_emptyp (&info->vars));
6901 if (! ieee_change_buffer (info, &info->vars))
6902 return FALSE;
6904 name_indx = info->name_indx;
6905 ++info->name_indx;
6907 /* Write out an NN and an ATN record for this variable. */
6908 if (! ieee_write_byte (info, (int) ieee_nn_record)
6909 || ! ieee_write_number (info, name_indx)
6910 || ! ieee_write_id (info, name)
6911 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6912 || ! ieee_write_number (info, name_indx)
6913 || ! ieee_write_number (info, type_indx))
6914 return FALSE;
6915 switch (kind)
6917 default:
6918 abort ();
6919 return FALSE;
6920 case DEBUG_GLOBAL:
6921 if (! ieee_write_number (info, 8)
6922 || ! ieee_add_range (info, FALSE, val, val + size))
6923 return FALSE;
6924 refflag = 0;
6925 asn = TRUE;
6926 break;
6927 case DEBUG_STATIC:
6928 if (! ieee_write_number (info, 3)
6929 || ! ieee_add_range (info, FALSE, val, val + size))
6930 return FALSE;
6931 refflag = 1;
6932 asn = TRUE;
6933 break;
6934 case DEBUG_LOCAL_STATIC:
6935 if (! ieee_write_number (info, 3)
6936 || ! ieee_add_range (info, FALSE, val, val + size))
6937 return FALSE;
6938 refflag = 2;
6939 asn = TRUE;
6940 break;
6941 case DEBUG_LOCAL:
6942 if (! ieee_write_number (info, 1)
6943 || ! ieee_write_number (info, val))
6944 return FALSE;
6945 refflag = 2;
6946 asn = FALSE;
6947 break;
6948 case DEBUG_REGISTER:
6949 if (! ieee_write_number (info, 2)
6950 || ! ieee_write_number (info,
6951 ieee_genreg_to_regno (info->abfd, val)))
6952 return FALSE;
6953 refflag = 2;
6954 asn = FALSE;
6955 break;
6958 if (asn)
6960 if (! ieee_write_asn (info, name_indx, val))
6961 return FALSE;
6964 /* If this is really a reference type, then we just output it with
6965 pointer type, and must now output a C++ record indicating that it
6966 is really reference type. */
6967 if (referencep)
6969 unsigned int nindx;
6971 nindx = info->name_indx;
6972 ++info->name_indx;
6974 /* If this is a global variable, we want to output the misc
6975 record in the C++ misc record block. Otherwise, we want to
6976 output it just after the variable definition, which is where
6977 the current buffer is. */
6978 if (refflag != 2)
6980 if (! ieee_change_buffer (info, &info->cxx))
6981 return FALSE;
6984 if (! ieee_write_byte (info, (int) ieee_nn_record)
6985 || ! ieee_write_number (info, nindx)
6986 || ! ieee_write_id (info, "")
6987 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6988 || ! ieee_write_number (info, nindx)
6989 || ! ieee_write_number (info, 0)
6990 || ! ieee_write_number (info, 62)
6991 || ! ieee_write_number (info, 80)
6992 || ! ieee_write_number (info, 3)
6993 || ! ieee_write_asn (info, nindx, 'R')
6994 || ! ieee_write_asn (info, nindx, refflag)
6995 || ! ieee_write_atn65 (info, nindx, name))
6996 return FALSE;
6999 return TRUE;
7002 /* Start outputting information for a function. */
7004 static bfd_boolean
7005 ieee_start_function (void *p, const char *name, bfd_boolean global)
7007 struct ieee_handle *info = (struct ieee_handle *) p;
7008 bfd_boolean referencep;
7009 unsigned int retindx, typeindx;
7011 referencep = info->type_stack->type.referencep;
7012 retindx = ieee_pop_type (info);
7014 /* Besides recording a BB4 or BB6 block, we record the type of the
7015 function in the BB1 typedef block. We can't write out the full
7016 type until we have seen all the parameters, so we accumulate it
7017 in info->fntype and info->fnargs. */
7018 if (! ieee_buffer_emptyp (&info->fntype))
7020 /* FIXME: This might happen someday if we support nested
7021 functions. */
7022 abort ();
7025 info->fnname = name;
7027 /* An attribute of 0x40 means that the push mask is unknown. */
7028 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
7029 &info->fntype)
7030 || ! ieee_write_number (info, 'x')
7031 || ! ieee_write_number (info, 0x40)
7032 || ! ieee_write_number (info, 0)
7033 || ! ieee_write_number (info, 0)
7034 || ! ieee_write_number (info, retindx))
7035 return FALSE;
7037 typeindx = ieee_pop_type (info);
7039 if (! ieee_init_buffer (info, &info->fnargs))
7040 return FALSE;
7041 info->fnargcount = 0;
7043 /* If the function return value is actually a reference type, we
7044 must add a record indicating that. */
7045 if (referencep)
7047 unsigned int nindx;
7049 nindx = info->name_indx;
7050 ++info->name_indx;
7051 if (! ieee_change_buffer (info, &info->cxx)
7052 || ! ieee_write_byte (info, (int) ieee_nn_record)
7053 || ! ieee_write_number (info, nindx)
7054 || ! ieee_write_id (info, "")
7055 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7056 || ! ieee_write_number (info, nindx)
7057 || ! ieee_write_number (info, 0)
7058 || ! ieee_write_number (info, 62)
7059 || ! ieee_write_number (info, 80)
7060 || ! ieee_write_number (info, 3)
7061 || ! ieee_write_asn (info, nindx, 'R')
7062 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7063 || ! ieee_write_atn65 (info, nindx, name))
7064 return FALSE;
7067 assert (! ieee_buffer_emptyp (&info->vars));
7068 if (! ieee_change_buffer (info, &info->vars))
7069 return FALSE;
7071 /* The address is written out as the first block. */
7073 ++info->block_depth;
7075 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7076 && ieee_write_byte (info, global ? 4 : 6)
7077 && ieee_write_number (info, 0)
7078 && ieee_write_id (info, name)
7079 && ieee_write_number (info, 0)
7080 && ieee_write_number (info, typeindx));
7083 /* Add a function parameter. This will normally be called before the
7084 first block, so we postpone them until we see the block. */
7086 static bfd_boolean
7087 ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
7088 bfd_vma val)
7090 struct ieee_handle *info = (struct ieee_handle *) p;
7091 struct ieee_pending_parm *m, **pm;
7093 assert (info->block_depth == 1);
7095 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7096 memset (m, 0, sizeof *m);
7098 m->next = NULL;
7099 m->name = name;
7100 m->referencep = info->type_stack->type.referencep;
7101 m->type = ieee_pop_type (info);
7102 m->kind = kind;
7103 m->val = val;
7105 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7107 *pm = m;
7109 /* Add the type to the fnargs list. */
7110 if (! ieee_change_buffer (info, &info->fnargs)
7111 || ! ieee_write_number (info, m->type))
7112 return FALSE;
7113 ++info->fnargcount;
7115 return TRUE;
7118 /* Output pending function parameters. */
7120 static bfd_boolean
7121 ieee_output_pending_parms (struct ieee_handle *info)
7123 struct ieee_pending_parm *m;
7124 unsigned int refcount;
7126 refcount = 0;
7127 for (m = info->pending_parms; m != NULL; m = m->next)
7129 enum debug_var_kind vkind;
7131 switch (m->kind)
7133 default:
7134 abort ();
7135 return FALSE;
7136 case DEBUG_PARM_STACK:
7137 case DEBUG_PARM_REFERENCE:
7138 vkind = DEBUG_LOCAL;
7139 break;
7140 case DEBUG_PARM_REG:
7141 case DEBUG_PARM_REF_REG:
7142 vkind = DEBUG_REGISTER;
7143 break;
7146 if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
7147 return FALSE;
7148 info->type_stack->type.referencep = m->referencep;
7149 if (m->referencep)
7150 ++refcount;
7151 if (! ieee_variable ((void *) info, m->name, vkind, m->val))
7152 return FALSE;
7155 /* If there are any reference parameters, we need to output a
7156 miscellaneous record indicating them. */
7157 if (refcount > 0)
7159 unsigned int nindx, varindx;
7161 /* FIXME: The MRI compiler outputs the demangled function name
7162 here, but we are outputting the mangled name. */
7163 nindx = info->name_indx;
7164 ++info->name_indx;
7165 if (! ieee_change_buffer (info, &info->vars)
7166 || ! ieee_write_byte (info, (int) ieee_nn_record)
7167 || ! ieee_write_number (info, nindx)
7168 || ! ieee_write_id (info, "")
7169 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7170 || ! ieee_write_number (info, nindx)
7171 || ! ieee_write_number (info, 0)
7172 || ! ieee_write_number (info, 62)
7173 || ! ieee_write_number (info, 80)
7174 || ! ieee_write_number (info, refcount + 3)
7175 || ! ieee_write_asn (info, nindx, 'B')
7176 || ! ieee_write_atn65 (info, nindx, info->fnname)
7177 || ! ieee_write_asn (info, nindx, 0))
7178 return FALSE;
7179 for (m = info->pending_parms, varindx = 1;
7180 m != NULL;
7181 m = m->next, varindx++)
7183 if (m->referencep)
7185 if (! ieee_write_asn (info, nindx, varindx))
7186 return FALSE;
7191 m = info->pending_parms;
7192 while (m != NULL)
7194 struct ieee_pending_parm *next;
7196 next = m->next;
7197 free (m);
7198 m = next;
7201 info->pending_parms = NULL;
7203 return TRUE;
7206 /* Start a block. If this is the first block, we output the address
7207 to finish the BB4 or BB6, and then output the function parameters. */
7209 static bfd_boolean
7210 ieee_start_block (void *p, bfd_vma addr)
7212 struct ieee_handle *info = (struct ieee_handle *) p;
7214 if (! ieee_change_buffer (info, &info->vars))
7215 return FALSE;
7217 if (info->block_depth == 1)
7219 if (! ieee_write_number (info, addr)
7220 || ! ieee_output_pending_parms (info))
7221 return FALSE;
7223 else
7225 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7226 || ! ieee_write_byte (info, 6)
7227 || ! ieee_write_number (info, 0)
7228 || ! ieee_write_id (info, "")
7229 || ! ieee_write_number (info, 0)
7230 || ! ieee_write_number (info, 0)
7231 || ! ieee_write_number (info, addr))
7232 return FALSE;
7235 if (! ieee_start_range (info, addr))
7236 return FALSE;
7238 ++info->block_depth;
7240 return TRUE;
7243 /* End a block. */
7245 static bfd_boolean
7246 ieee_end_block (void *p, bfd_vma addr)
7248 struct ieee_handle *info = (struct ieee_handle *) p;
7250 /* The address we are given is the end of the block, but IEEE seems
7251 to want to the address of the last byte in the block, so we
7252 subtract one. */
7253 if (! ieee_change_buffer (info, &info->vars)
7254 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7255 || ! ieee_write_number (info, addr - 1))
7256 return FALSE;
7258 if (! ieee_end_range (info, addr))
7259 return FALSE;
7261 --info->block_depth;
7263 if (addr > info->highaddr)
7264 info->highaddr = addr;
7266 return TRUE;
7269 /* End a function. */
7271 static bfd_boolean
7272 ieee_end_function (void *p)
7274 struct ieee_handle *info = (struct ieee_handle *) p;
7276 assert (info->block_depth == 1);
7278 --info->block_depth;
7280 /* Now we can finish up fntype, and add it to the typdef section.
7281 At this point, fntype is the 'x' type up to the argument count,
7282 and fnargs is the argument types. We must add the argument
7283 count, and we must add the level. FIXME: We don't record varargs
7284 functions correctly. In fact, stabs debugging does not give us
7285 enough information to do so. */
7286 if (! ieee_change_buffer (info, &info->fntype)
7287 || ! ieee_write_number (info, info->fnargcount)
7288 || ! ieee_change_buffer (info, &info->fnargs)
7289 || ! ieee_write_number (info, 0))
7290 return FALSE;
7292 /* Make sure the typdef block has been started. */
7293 if (ieee_buffer_emptyp (&info->types))
7295 if (! ieee_change_buffer (info, &info->types)
7296 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7297 || ! ieee_write_byte (info, 1)
7298 || ! ieee_write_number (info, 0)
7299 || ! ieee_write_id (info, info->modname))
7300 return FALSE;
7303 if (! ieee_append_buffer (info, &info->types, &info->fntype)
7304 || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7305 return FALSE;
7307 info->fnname = NULL;
7308 if (! ieee_init_buffer (info, &info->fntype)
7309 || ! ieee_init_buffer (info, &info->fnargs))
7310 return FALSE;
7311 info->fnargcount = 0;
7313 return TRUE;
7316 /* Record line number information. */
7318 static bfd_boolean
7319 ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
7321 struct ieee_handle *info = (struct ieee_handle *) p;
7323 assert (info->filename != NULL);
7325 /* The HP simulator seems to get confused when more than one line is
7326 listed for the same address, at least if they are in different
7327 files. We handle this by always listing the last line for a
7328 given address, since that seems to be the one that gdb uses. */
7329 if (info->pending_lineno_filename != NULL
7330 && addr != info->pending_lineno_addr)
7332 /* Make sure we have a line number block. */
7333 if (! ieee_buffer_emptyp (&info->linenos))
7335 if (! ieee_change_buffer (info, &info->linenos))
7336 return FALSE;
7338 else
7340 info->lineno_name_indx = info->name_indx;
7341 ++info->name_indx;
7342 if (! ieee_change_buffer (info, &info->linenos)
7343 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7344 || ! ieee_write_byte (info, 5)
7345 || ! ieee_write_number (info, 0)
7346 || ! ieee_write_id (info, info->filename)
7347 || ! ieee_write_byte (info, (int) ieee_nn_record)
7348 || ! ieee_write_number (info, info->lineno_name_indx)
7349 || ! ieee_write_id (info, ""))
7350 return FALSE;
7351 info->lineno_filename = info->filename;
7354 if (filename_cmp (info->pending_lineno_filename,
7355 info->lineno_filename) != 0)
7357 if (filename_cmp (info->filename, info->lineno_filename) != 0)
7359 /* We were not in the main file. Close the block for the
7360 included file. */
7361 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7362 return FALSE;
7363 if (filename_cmp (info->filename,
7364 info->pending_lineno_filename) == 0)
7366 /* We need a new NN record, and we aren't about to
7367 output one. */
7368 info->lineno_name_indx = info->name_indx;
7369 ++info->name_indx;
7370 if (! ieee_write_byte (info, (int) ieee_nn_record)
7371 || ! ieee_write_number (info, info->lineno_name_indx)
7372 || ! ieee_write_id (info, ""))
7373 return FALSE;
7376 if (filename_cmp (info->filename,
7377 info->pending_lineno_filename) != 0)
7379 /* We are not changing to the main file. Open a block for
7380 the new included file. */
7381 info->lineno_name_indx = info->name_indx;
7382 ++info->name_indx;
7383 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7384 || ! ieee_write_byte (info, 5)
7385 || ! ieee_write_number (info, 0)
7386 || ! ieee_write_id (info, info->pending_lineno_filename)
7387 || ! ieee_write_byte (info, (int) ieee_nn_record)
7388 || ! ieee_write_number (info, info->lineno_name_indx)
7389 || ! ieee_write_id (info, ""))
7390 return FALSE;
7392 info->lineno_filename = info->pending_lineno_filename;
7395 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7396 || ! ieee_write_number (info, info->lineno_name_indx)
7397 || ! ieee_write_number (info, 0)
7398 || ! ieee_write_number (info, 7)
7399 || ! ieee_write_number (info, info->pending_lineno)
7400 || ! ieee_write_number (info, 0)
7401 || ! ieee_write_asn (info, info->lineno_name_indx,
7402 info->pending_lineno_addr))
7403 return FALSE;
7406 info->pending_lineno_filename = filename;
7407 info->pending_lineno = lineno;
7408 info->pending_lineno_addr = addr;
7410 return TRUE;