1 /* ieee.c -- Read and write IEEE-695 debugging information.
2 Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2006, 2007,
3 2008, 2009 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
23 /* This file reads and writes IEEE-695 debugging information. */
29 #include "libiberty.h"
32 #include "filenames.h"
34 /* This structure holds an entry on the block stack. */
38 /* The kind of block. */
40 /* The source file name, for a BB5 block. */
42 /* The index of the function type, for a BB4 or BB6 block. */
44 /* TRUE if this function is being skipped. */
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;
57 struct ieee_block stack[BLOCKSTACK_SIZE];
60 /* This structure holds information for a variable. */
70 /* Slot if we make an indirect type. */
72 /* Kind of variable or function. */
84 /* This structure holds all the variables. */
88 /* Number of slots allocated. */
91 struct ieee_var *vars;
94 /* This structure holds information for a type. We need this because
95 we don't want to represent bitfields as real types. */
101 /* Slot if this is type is referenced before it is defined. */
103 /* Slots for arguments if we make indirect types for them. */
104 debug_type *arg_slots;
105 /* If this is a bitfield, this is the size in bits. If this is not
106 a bitfield, this is zero. */
107 unsigned long bitsize;
110 /* This structure holds all the type information. */
114 /* Number of slots allocated. */
117 struct ieee_type *types;
119 #define BUILTIN_TYPE_COUNT (60)
120 debug_type builtins[BUILTIN_TYPE_COUNT];
123 /* This structure holds a linked last of structs with their tag names,
124 so that we can convert them to C++ classes if necessary. */
129 struct ieee_tag *next;
132 /* The type of the tag. */
134 /* The tagged type is an indirect type pointing at this slot. */
136 /* This is an array of slots used when a field type is converted
137 into a indirect type, in case it needs to be later converted into
142 /* This structure holds the information we pass around to the parsing
147 /* The debugging handle. */
151 /* The start of the bytes to be parsed. */
152 const bfd_byte *bytes;
153 /* The end of the bytes to be parsed. */
154 const bfd_byte *pend;
155 /* The block stack. */
156 struct ieee_blockstack blockstack;
157 /* Whether we have seen a BB1 or BB2. */
158 bfd_boolean saw_filename;
160 struct ieee_vars vars;
161 /* The global variables, after a global typedef block. */
162 struct ieee_vars *global_vars;
164 struct ieee_types types;
165 /* The global types, after a global typedef block. */
166 struct ieee_types *global_types;
167 /* The list of tagged structs. */
168 struct ieee_tag *tags;
171 /* Basic builtin types, not including the pointers. */
177 builtin_signed_char = 2,
178 builtin_unsigned_char = 3,
179 builtin_signed_short_int = 4,
180 builtin_unsigned_short_int = 5,
181 builtin_signed_long = 6,
182 builtin_unsigned_long = 7,
183 builtin_signed_long_long = 8,
184 builtin_unsigned_long_long = 9,
187 builtin_long_double = 12,
188 builtin_long_long_double = 13,
189 builtin_quoted_string = 14,
190 builtin_instruction_address = 15,
192 builtin_unsigned = 17,
193 builtin_unsigned_int = 18,
197 builtin_unsigned_short = 22,
198 builtin_short_int = 23,
199 builtin_signed_short = 24,
200 builtin_bcd_float = 25
203 /* These are the values found in the derivation flags of a 'b'
204 component record of a 'T' type extension record in a C++ pmisc
205 record. These are bitmasks. */
207 /* Set for a private base class, clear for a public base class.
208 Protected base classes are not supported. */
209 #define BASEFLAGS_PRIVATE (0x1)
210 /* Set for a virtual base class. */
211 #define BASEFLAGS_VIRTUAL (0x2)
212 /* Set for a friend class, clear for a base class. */
213 #define BASEFLAGS_FRIEND (0x10)
215 /* These are the values found in the specs flags of a 'd', 'm', or 'v'
216 component record of a 'T' type extension record in a C++ pmisc
217 record. The same flags are used for a 'M' record in a C++ pmisc
220 /* The lower two bits hold visibility information. */
221 #define CXXFLAGS_VISIBILITY (0x3)
222 /* This value in the lower two bits indicates a public member. */
223 #define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
224 /* This value in the lower two bits indicates a private member. */
225 #define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
226 /* This value in the lower two bits indicates a protected member. */
227 #define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
228 /* Set for a static member. */
229 #define CXXFLAGS_STATIC (0x4)
230 /* Set for a virtual override. */
231 #define CXXFLAGS_OVERRIDE (0x8)
232 /* Set for a friend function. */
233 #define CXXFLAGS_FRIEND (0x10)
234 /* Set for a const function. */
235 #define CXXFLAGS_CONST (0x20)
236 /* Set for a volatile function. */
237 #define CXXFLAGS_VOLATILE (0x40)
238 /* Set for an overloaded function. */
239 #define CXXFLAGS_OVERLOADED (0x80)
240 /* Set for an operator function. */
241 #define CXXFLAGS_OPERATOR (0x100)
242 /* Set for a constructor or destructor. */
243 #define CXXFLAGS_CTORDTOR (0x400)
244 /* Set for a constructor. */
245 #define CXXFLAGS_CTOR (0x200)
246 /* Set for an inline function. */
247 #define CXXFLAGS_INLINE (0x800)
249 /* Local functions. */
251 static void ieee_error (struct ieee_info *, const bfd_byte *, const char *);
252 static void ieee_eof (struct ieee_info *);
253 static char *savestring (const char *, unsigned long);
254 static bfd_boolean ieee_read_number
255 (struct ieee_info *, const bfd_byte **, bfd_vma *);
256 static bfd_boolean ieee_read_optional_number
257 (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *);
258 static bfd_boolean ieee_read_id
259 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
260 static bfd_boolean ieee_read_optional_id
261 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *,
263 static bfd_boolean ieee_read_expression
264 (struct ieee_info *, const bfd_byte **, bfd_vma *);
265 static debug_type ieee_builtin_type
266 (struct ieee_info *, const bfd_byte *, unsigned int);
267 static bfd_boolean ieee_alloc_type
268 (struct ieee_info *, unsigned int, bfd_boolean);
269 static bfd_boolean ieee_read_type_index
270 (struct ieee_info *, const bfd_byte **, debug_type *);
271 static int ieee_regno_to_genreg (bfd *, int);
272 static int ieee_genreg_to_regno (bfd *, int);
273 static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **);
274 static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **);
275 static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **);
276 static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **);
277 static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **);
278 static bfd_boolean ieee_read_cxx_misc
279 (struct ieee_info *, const bfd_byte **, unsigned long);
280 static bfd_boolean ieee_read_cxx_class
281 (struct ieee_info *, const bfd_byte **, unsigned long);
282 static bfd_boolean ieee_read_cxx_defaults
283 (struct ieee_info *, const bfd_byte **, unsigned long);
284 static bfd_boolean ieee_read_reference
285 (struct ieee_info *, const bfd_byte **);
286 static bfd_boolean ieee_require_asn
287 (struct ieee_info *, const bfd_byte **, bfd_vma *);
288 static bfd_boolean ieee_require_atn65
289 (struct ieee_info *, const bfd_byte **, const char **, unsigned long *);
291 /* Report an error in the IEEE debugging information. */
294 ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s)
297 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
298 (unsigned long) (p - info->bytes), s, *p);
300 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
303 /* Report an unexpected EOF in the IEEE debugging information. */
306 ieee_eof (struct ieee_info *info)
308 ieee_error (info, (const bfd_byte *) NULL,
309 _("unexpected end of debugging information"));
312 /* Save a string in memory. */
315 savestring (const char *start, unsigned long len)
319 ret = (char *) xmalloc (len + 1);
320 memcpy (ret, start, len);
325 /* Read a number which must be present in an IEEE file. */
328 ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
330 return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
333 /* Read a number in an IEEE file. If ppresent is not NULL, the number
334 need not be there. */
337 ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp,
338 bfd_vma *pv, bfd_boolean *ppresent)
340 ieee_record_enum_type b;
342 if (*pp >= info->pend)
344 if (ppresent != NULL)
353 b = (ieee_record_enum_type) **pp;
356 if (b <= ieee_number_end_enum)
359 if (ppresent != NULL)
364 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
368 i = (int) b - (int) ieee_number_repeat_start_enum;
369 if (*pp + i - 1 >= info->pend)
383 if (ppresent != NULL)
389 if (ppresent != NULL)
396 ieee_error (info, *pp - 1, _("invalid number"));
400 /* Read a required string from an IEEE file. */
403 ieee_read_id (struct ieee_info *info, const bfd_byte **pp,
404 const char **pname, unsigned long *pnamlen)
406 return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
409 /* Read a string from an IEEE file. If ppresent is not NULL, the
410 string is optional. */
413 ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp,
414 const char **pname, unsigned long *pnamlen,
415 bfd_boolean *ppresent)
420 if (*pp >= info->pend)
431 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
436 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
438 len = (**pp << 8) + (*pp)[1];
443 if (ppresent != NULL)
449 ieee_error (info, *pp - 1, _("invalid string length"));
453 if ((unsigned long) (info->pend - *pp) < len)
459 *pname = (const char *) *pp;
463 if (ppresent != NULL)
469 /* Read an expression from an IEEE file. Since this code is only used
470 to parse debugging information, I haven't bothered to write a full
471 blown IEEE expression parser. I've only thrown in the things I've
472 seen in debugging information. This can be easily extended if
476 ieee_read_expression (struct ieee_info *info, const bfd_byte **pp,
479 const bfd_byte *expr_start;
480 #define EXPR_STACK_SIZE (10)
481 bfd_vma expr_stack[EXPR_STACK_SIZE];
490 const bfd_byte *start;
493 ieee_record_enum_type c;
497 if (! ieee_read_optional_number (info, pp, &val, &present))
502 if (esp - expr_stack >= EXPR_STACK_SIZE)
504 ieee_error (info, start, _("expression stack overflow"));
511 c = (ieee_record_enum_type) **pp;
513 if (c >= ieee_module_beginning_enum)
524 ieee_error (info, start, _("unsupported IEEE expression operator"));
527 case ieee_variable_R_enum:
532 if (! ieee_read_number (info, pp, &indx))
534 for (s = info->abfd->sections; s != NULL; s = s->next)
535 if ((bfd_vma) s->target_index == indx)
539 ieee_error (info, start, _("unknown section"));
543 if (esp - expr_stack >= EXPR_STACK_SIZE)
545 ieee_error (info, start, _("expression stack overflow"));
549 *esp++ = bfd_get_section_vma (info->abfd, s);
553 case ieee_function_plus_enum:
554 case ieee_function_minus_enum:
558 if (esp - expr_stack < 2)
560 ieee_error (info, start, _("expression stack underflow"));
572 if (esp - 1 != expr_stack)
574 ieee_error (info, expr_start, _("expression stack mismatch"));
583 /* Return an IEEE builtin type. */
586 ieee_builtin_type (struct ieee_info *info, const bfd_byte *p,
593 if (indx < BUILTIN_TYPE_COUNT
594 && info->types.builtins[indx] != DEBUG_TYPE_NULL)
595 return info->types.builtins[indx];
597 dhandle = info->dhandle;
599 if (indx >= 32 && indx < 64)
601 type = debug_make_pointer_type (dhandle,
602 ieee_builtin_type (info, p, indx - 32));
603 assert (indx < BUILTIN_TYPE_COUNT);
604 info->types.builtins[indx] = type;
608 switch ((enum builtin_types) indx)
611 ieee_error (info, p, _("unknown builtin type"));
614 case builtin_unknown:
615 type = debug_make_void_type (dhandle);
620 type = debug_make_void_type (dhandle);
624 case builtin_signed_char:
625 type = debug_make_int_type (dhandle, 1, FALSE);
626 name = "signed char";
629 case builtin_unsigned_char:
630 type = debug_make_int_type (dhandle, 1, TRUE);
631 name = "unsigned char";
634 case builtin_signed_short_int:
635 type = debug_make_int_type (dhandle, 2, FALSE);
636 name = "signed short int";
639 case builtin_unsigned_short_int:
640 type = debug_make_int_type (dhandle, 2, TRUE);
641 name = "unsigned short int";
644 case builtin_signed_long:
645 type = debug_make_int_type (dhandle, 4, FALSE);
646 name = "signed long";
649 case builtin_unsigned_long:
650 type = debug_make_int_type (dhandle, 4, TRUE);
651 name = "unsigned long";
654 case builtin_signed_long_long:
655 type = debug_make_int_type (dhandle, 8, FALSE);
656 name = "signed long long";
659 case builtin_unsigned_long_long:
660 type = debug_make_int_type (dhandle, 8, TRUE);
661 name = "unsigned long long";
665 type = debug_make_float_type (dhandle, 4);
670 type = debug_make_float_type (dhandle, 8);
674 case builtin_long_double:
675 /* FIXME: The size for this type should depend upon the
677 type = debug_make_float_type (dhandle, 12);
678 name = "long double";
681 case builtin_long_long_double:
682 type = debug_make_float_type (dhandle, 16);
683 name = "long long double";
686 case builtin_quoted_string:
687 type = debug_make_array_type (dhandle,
688 ieee_builtin_type (info, p,
691 ieee_builtin_type (info, p,
695 name = "QUOTED STRING";
698 case builtin_instruction_address:
699 /* FIXME: This should be a code address. */
700 type = debug_make_int_type (dhandle, 4, TRUE);
701 name = "instruction address";
705 /* FIXME: The size for this type should depend upon the
707 type = debug_make_int_type (dhandle, 4, FALSE);
711 case builtin_unsigned:
712 /* FIXME: The size for this type should depend upon the
714 type = debug_make_int_type (dhandle, 4, TRUE);
718 case builtin_unsigned_int:
719 /* FIXME: The size for this type should depend upon the
721 type = debug_make_int_type (dhandle, 4, TRUE);
722 name = "unsigned int";
726 type = debug_make_int_type (dhandle, 1, FALSE);
731 type = debug_make_int_type (dhandle, 4, FALSE);
736 type = debug_make_int_type (dhandle, 2, FALSE);
740 case builtin_unsigned_short:
741 type = debug_make_int_type (dhandle, 2, TRUE);
742 name = "unsigned short";
745 case builtin_short_int:
746 type = debug_make_int_type (dhandle, 2, FALSE);
750 case builtin_signed_short:
751 type = debug_make_int_type (dhandle, 2, FALSE);
752 name = "signed short";
755 case builtin_bcd_float:
756 ieee_error (info, p, _("BCD float type not supported"));
757 return DEBUG_TYPE_NULL;
761 type = debug_name_type (dhandle, name, type);
763 assert (indx < BUILTIN_TYPE_COUNT);
765 info->types.builtins[indx] = type;
770 /* Allocate more space in the type table. If ref is TRUE, this is a
771 reference to the type; if it is not already defined, we should set
772 up an indirect type. */
775 ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref)
778 register struct ieee_type *t;
779 struct ieee_type *tend;
781 if (indx >= info->types.alloc)
783 nalloc = info->types.alloc;
786 while (indx >= nalloc)
789 info->types.types = ((struct ieee_type *)
790 xrealloc (info->types.types,
791 nalloc * sizeof *info->types.types));
793 memset (info->types.types + info->types.alloc, 0,
794 (nalloc - info->types.alloc) * sizeof *info->types.types);
796 tend = info->types.types + nalloc;
797 for (t = info->types.types + info->types.alloc; t < tend; t++)
798 t->type = DEBUG_TYPE_NULL;
800 info->types.alloc = nalloc;
805 t = info->types.types + indx;
808 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
809 *t->pslot = DEBUG_TYPE_NULL;
810 t->type = debug_make_indirect_type (info->dhandle, t->pslot,
811 (const char *) NULL);
820 /* Read a type index and return the corresponding type. */
823 ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp,
826 const bfd_byte *start;
831 if (! ieee_read_number (info, pp, &indx))
836 *ptype = ieee_builtin_type (info, start, indx);
843 if (! ieee_alloc_type (info, indx, TRUE))
846 *ptype = info->types.types[indx].type;
851 /* Parse IEEE debugging information for a file. This is passed the
852 bytes which compose the Debug Information Part of an IEEE file. */
855 parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len)
857 struct ieee_info info;
859 const bfd_byte *p, *pend;
861 info.dhandle = dhandle;
864 info.pend = bytes + len;
865 info.blockstack.bsp = info.blockstack.stack;
866 info.saw_filename = FALSE;
868 info.vars.vars = NULL;
869 info.global_vars = NULL;
870 info.types.alloc = 0;
871 info.types.types = NULL;
872 info.global_types = NULL;
874 for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
875 info.types.builtins[i] = DEBUG_TYPE_NULL;
881 const bfd_byte *record_start;
882 ieee_record_enum_type c;
886 c = (ieee_record_enum_type) *p++;
888 if (c == ieee_at_record_enum)
889 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
891 if (c <= ieee_number_repeat_end_enum)
893 ieee_error (&info, record_start, _("unexpected number"));
900 ieee_error (&info, record_start, _("unexpected record type"));
903 case ieee_bb_record_enum:
904 if (! parse_ieee_bb (&info, &p))
908 case ieee_be_record_enum:
909 if (! parse_ieee_be (&info, &p))
914 if (! parse_ieee_nn (&info, &p))
918 case ieee_ty_record_enum:
919 if (! parse_ieee_ty (&info, &p))
923 case ieee_atn_record_enum:
924 if (! parse_ieee_atn (&info, &p))
930 if (info.blockstack.bsp != info.blockstack.stack)
932 ieee_error (&info, (const bfd_byte *) NULL,
933 _("blocks left on stack at end"));
940 /* Handle an IEEE BB record. */
943 parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp)
945 const bfd_byte *block_start;
949 unsigned long namlen;
950 char *namcopy = NULL;
959 if (! ieee_read_number (info, pp, &size)
960 || ! ieee_read_id (info, pp, &name, &namlen))
963 fnindx = (unsigned int) -1;
969 /* BB1: Type definitions local to a module. */
970 namcopy = savestring (name, namlen);
973 if (! debug_set_filename (info->dhandle, namcopy))
975 info->saw_filename = TRUE;
977 /* Discard any variables or types we may have seen before. */
978 if (info->vars.vars != NULL)
979 free (info->vars.vars);
980 info->vars.vars = NULL;
981 info->vars.alloc = 0;
982 if (info->types.types != NULL)
983 free (info->types.types);
984 info->types.types = NULL;
985 info->types.alloc = 0;
987 /* Initialize the types to the global types. */
988 if (info->global_types != NULL)
990 info->types.alloc = info->global_types->alloc;
991 info->types.types = ((struct ieee_type *)
992 xmalloc (info->types.alloc
993 * sizeof (*info->types.types)));
994 memcpy (info->types.types, info->global_types->types,
995 info->types.alloc * sizeof (*info->types.types));
1001 /* BB2: Global type definitions. The name is supposed to be
1002 empty, but we don't check. */
1003 if (! debug_set_filename (info->dhandle, "*global*"))
1005 info->saw_filename = TRUE;
1009 /* BB3: High level module block begin. We don't have to do
1010 anything here. The name is supposed to be the same as for
1011 the BB1, but we don't check. */
1015 /* BB4: Global function. */
1017 bfd_vma stackspace, typindx, offset;
1018 debug_type return_type;
1020 if (! ieee_read_number (info, pp, &stackspace)
1021 || ! ieee_read_number (info, pp, &typindx)
1022 || ! ieee_read_expression (info, pp, &offset))
1025 /* We have no way to record the stack space. FIXME. */
1029 return_type = ieee_builtin_type (info, block_start, typindx);
1030 if (return_type == DEBUG_TYPE_NULL)
1036 if (! ieee_alloc_type (info, typindx, TRUE))
1039 return_type = info->types.types[typindx].type;
1040 if (debug_get_type_kind (info->dhandle, return_type)
1041 == DEBUG_KIND_FUNCTION)
1042 return_type = debug_get_return_type (info->dhandle,
1046 namcopy = savestring (name, namlen);
1047 if (namcopy == NULL)
1049 if (! debug_record_function (info->dhandle, namcopy, return_type,
1056 /* BB5: File name for source line numbers. */
1060 /* We ignore the date and time. FIXME. */
1061 for (i = 0; i < 6; i++)
1064 bfd_boolean present;
1066 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1072 if (! info->saw_filename)
1074 namcopy = savestring (name, namlen);
1075 if (namcopy == NULL)
1077 if (! debug_set_filename (info->dhandle, namcopy))
1079 info->saw_filename = TRUE;
1082 namcopy = savestring (name, namlen);
1083 if (namcopy == NULL)
1085 if (! debug_start_source (info->dhandle, namcopy))
1091 /* BB6: Local function or block. */
1093 bfd_vma stackspace, typindx, offset;
1095 if (! ieee_read_number (info, pp, &stackspace)
1096 || ! ieee_read_number (info, pp, &typindx)
1097 || ! ieee_read_expression (info, pp, &offset))
1100 /* We have no way to record the stack space. FIXME. */
1104 if (! debug_start_block (info->dhandle, offset))
1106 /* Change b to indicate that this is a block
1107 rather than a function. */
1112 /* The MRI C++ compiler will output a fake function named
1113 __XRYCPP to hold C++ debugging information. We skip
1114 that function. This is not crucial, but it makes
1115 converting from IEEE to other debug formats work
1117 if (strncmp (name, "__XRYCPP", namlen) == 0)
1121 debug_type return_type;
1125 return_type = ieee_builtin_type (info, block_start,
1127 if (return_type == NULL)
1133 if (! ieee_alloc_type (info, typindx, TRUE))
1136 return_type = info->types.types[typindx].type;
1137 if (debug_get_type_kind (info->dhandle, return_type)
1138 == DEBUG_KIND_FUNCTION)
1139 return_type = debug_get_return_type (info->dhandle,
1143 namcopy = savestring (name, namlen);
1144 if (namcopy == NULL)
1146 if (! debug_record_function (info->dhandle, namcopy,
1147 return_type, FALSE, offset))
1155 /* BB10: Assembler module scope. In the normal case, we
1156 completely ignore all this information. FIXME. */
1158 const char *inam, *vstr;
1159 unsigned long inamlen, vstrlen;
1161 bfd_boolean present;
1164 if (! info->saw_filename)
1166 namcopy = savestring (name, namlen);
1167 if (namcopy == NULL)
1169 if (! debug_set_filename (info->dhandle, namcopy))
1171 info->saw_filename = TRUE;
1174 if (! ieee_read_id (info, pp, &inam, &inamlen)
1175 || ! ieee_read_number (info, pp, &tool_type)
1176 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1178 for (i = 0; i < 6; i++)
1182 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1191 /* BB11: Module section. We completely ignore all this
1192 information. FIXME. */
1194 bfd_vma sectype, secindx, offset, map;
1195 bfd_boolean present;
1197 if (! ieee_read_number (info, pp, §ype)
1198 || ! ieee_read_number (info, pp, &secindx)
1199 || ! ieee_read_expression (info, pp, &offset)
1200 || ! ieee_read_optional_number (info, pp, &map, &present))
1206 ieee_error (info, block_start, _("unknown BB type"));
1211 /* Push this block on the block stack. */
1213 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1215 ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
1219 info->blockstack.bsp->kind = b;
1221 info->blockstack.bsp->filename = namcopy;
1222 info->blockstack.bsp->fnindx = fnindx;
1223 info->blockstack.bsp->skip = skip;
1224 ++info->blockstack.bsp;
1229 /* Handle an IEEE BE record. */
1232 parse_ieee_be (struct ieee_info *info, const bfd_byte **pp)
1236 if (info->blockstack.bsp <= info->blockstack.stack)
1238 ieee_error (info, *pp, _("stack underflow"));
1241 --info->blockstack.bsp;
1243 switch (info->blockstack.bsp->kind)
1246 /* When we end the global typedefs block, we copy out the
1247 contents of info->vars. This is because the variable indices
1248 may be reused in the local blocks. However, we need to
1249 preserve them so that we can locate a function returning a
1250 reference variable whose type is named in the global typedef
1252 info->global_vars = ((struct ieee_vars *)
1253 xmalloc (sizeof *info->global_vars));
1254 info->global_vars->alloc = info->vars.alloc;
1255 info->global_vars->vars = ((struct ieee_var *)
1256 xmalloc (info->vars.alloc
1257 * sizeof (*info->vars.vars)));
1258 memcpy (info->global_vars->vars, info->vars.vars,
1259 info->vars.alloc * sizeof (*info->vars.vars));
1261 /* We also copy out the non builtin parts of info->types, since
1262 the types are discarded when we start a new block. */
1263 info->global_types = ((struct ieee_types *)
1264 xmalloc (sizeof *info->global_types));
1265 info->global_types->alloc = info->types.alloc;
1266 info->global_types->types = ((struct ieee_type *)
1267 xmalloc (info->types.alloc
1268 * sizeof (*info->types.types)));
1269 memcpy (info->global_types->types, info->types.types,
1270 info->types.alloc * sizeof (*info->types.types));
1271 memset (info->global_types->builtins, 0,
1272 sizeof (info->global_types->builtins));
1278 if (! ieee_read_expression (info, pp, &offset))
1280 if (! info->blockstack.bsp->skip)
1282 if (! debug_end_function (info->dhandle, offset + 1))
1288 /* This is BE6 when BB6 started a block rather than a local
1290 if (! ieee_read_expression (info, pp, &offset))
1292 if (! debug_end_block (info->dhandle, offset + 1))
1297 /* When we end a BB5, we look up the stack for the last BB5, if
1298 there is one, so that we can call debug_start_source. */
1299 if (info->blockstack.bsp > info->blockstack.stack)
1301 struct ieee_block *bl;
1303 bl = info->blockstack.bsp;
1309 if (! debug_start_source (info->dhandle, bl->filename))
1314 while (bl != info->blockstack.stack);
1319 if (! ieee_read_expression (info, pp, &offset))
1321 /* We just ignore the module size. FIXME. */
1325 /* Other block types do not have any trailing information. */
1332 /* Parse an NN record. */
1335 parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp)
1337 const bfd_byte *nn_start;
1340 unsigned long namlen;
1344 if (! ieee_read_number (info, pp, &varindx)
1345 || ! ieee_read_id (info, pp, &name, &namlen))
1350 ieee_error (info, nn_start, _("illegal variable index"));
1355 if (varindx >= info->vars.alloc)
1359 alloc = info->vars.alloc;
1362 while (varindx >= alloc)
1364 info->vars.vars = ((struct ieee_var *)
1365 xrealloc (info->vars.vars,
1366 alloc * sizeof *info->vars.vars));
1367 memset (info->vars.vars + info->vars.alloc, 0,
1368 (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1369 info->vars.alloc = alloc;
1372 info->vars.vars[varindx].name = name;
1373 info->vars.vars[varindx].namlen = namlen;
1378 /* Parse a TY record. */
1381 parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp)
1383 const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1384 bfd_vma typeindx, varindx, tc;
1386 bfd_boolean tag, typdef;
1387 debug_type *arg_slots;
1388 unsigned long type_bitsize;
1393 if (! ieee_read_number (info, pp, &typeindx))
1398 ieee_error (info, ty_start, _("illegal type index"));
1403 if (! ieee_alloc_type (info, typeindx, FALSE))
1408 ieee_error (info, *pp, _("unknown TY code"));
1415 if (! ieee_read_number (info, pp, &varindx))
1420 ieee_error (info, ty_var_start, _("illegal variable index"));
1425 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1427 ieee_error (info, ty_var_start, _("undefined variable in TY"));
1431 ty_code_start = *pp;
1433 if (! ieee_read_number (info, pp, &tc))
1436 dhandle = info->dhandle;
1445 ieee_error (info, ty_code_start, _("unknown TY code"));
1449 /* Unknown type, with size. We treat it as int. FIXME. */
1453 if (! ieee_read_number (info, pp, &size))
1455 type = debug_make_int_type (dhandle, size, FALSE);
1459 case 'A': /* Array. */
1460 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1461 distinguished from normal array. */
1463 debug_type ele_type;
1464 bfd_vma lower, upper;
1466 if (! ieee_read_type_index (info, pp, &ele_type)
1467 || ! ieee_read_number (info, pp, &lower)
1468 || ! ieee_read_number (info, pp, &upper))
1470 type = debug_make_array_type (dhandle, ele_type,
1471 ieee_builtin_type (info, ty_code_start,
1474 (bfd_signed_vma) lower,
1475 (bfd_signed_vma) upper,
1481 /* Simple enumeration. */
1487 bfd_signed_vma *vals;
1490 if (! ieee_read_number (info, pp, &size))
1492 /* FIXME: we ignore the enumeration size. */
1495 names = (const char **) xmalloc (alloc * sizeof *names);
1496 memset (names, 0, alloc * sizeof *names);
1501 unsigned long namlen;
1502 bfd_boolean present;
1504 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1512 names = ((const char **)
1513 xrealloc (names, alloc * sizeof *names));
1516 names[c] = savestring (name, namlen);
1517 if (names[c] == NULL)
1524 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1525 for (i = 0; i < c; i++)
1528 type = debug_make_enum_type (dhandle, names, vals);
1534 /* Struct with bit fields. */
1538 debug_field *fields;
1541 if (! ieee_read_number (info, pp, &size))
1545 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1550 unsigned long namlen;
1551 bfd_boolean present;
1553 bfd_vma bitpos, bitsize;
1555 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1559 if (! ieee_read_type_index (info, pp, &ftype)
1560 || ! ieee_read_number (info, pp, &bitpos)
1561 || ! ieee_read_number (info, pp, &bitsize))
1567 fields = ((debug_field *)
1568 xrealloc (fields, alloc * sizeof *fields));
1571 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1572 ftype, bitpos, bitsize,
1573 DEBUG_VISIBILITY_PUBLIC);
1574 if (fields[c] == NULL)
1581 type = debug_make_struct_type (dhandle, TRUE, size, fields);
1591 bfd_signed_vma *vals;
1595 names = (const char **) xmalloc (alloc * sizeof *names);
1596 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1601 unsigned long namlen;
1602 bfd_boolean present;
1605 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1609 if (! ieee_read_number (info, pp, &val))
1612 /* If the length of the name is zero, then the value is
1613 actually the size of the enum. We ignore this
1614 information. FIXME. */
1621 names = ((const char **)
1622 xrealloc (names, alloc * sizeof *names));
1623 vals = ((bfd_signed_vma *)
1624 xrealloc (vals, alloc * sizeof *vals));
1627 names[c] = savestring (name, namlen);
1628 if (names[c] == NULL)
1630 vals[c] = (bfd_signed_vma) val;
1636 type = debug_make_enum_type (dhandle, names, vals);
1641 case 'O': /* Small pointer. We don't distinguish small and large
1643 case 'P': /* Large pointer. */
1647 if (! ieee_read_type_index (info, pp, &t))
1649 type = debug_make_pointer_type (dhandle, t);
1656 bfd_vma low, high, signedp, size;
1658 if (! ieee_read_number (info, pp, &low)
1659 || ! ieee_read_number (info, pp, &high)
1660 || ! ieee_read_number (info, pp, &signedp)
1661 || ! ieee_read_number (info, pp, &size))
1664 type = debug_make_range_type (dhandle,
1665 debug_make_int_type (dhandle, size,
1667 (bfd_signed_vma) low,
1668 (bfd_signed_vma) high);
1672 case 'S': /* Struct. */
1673 case 'U': /* Union. */
1677 debug_field *fields;
1680 if (! ieee_read_number (info, pp, &size))
1684 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1689 unsigned long namlen;
1690 bfd_boolean present;
1696 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1700 if (! ieee_read_number (info, pp, &tindx)
1701 || ! ieee_read_number (info, pp, &offset))
1706 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1712 struct ieee_type *t;
1715 if (! ieee_alloc_type (info, tindx, TRUE))
1717 t = info->types.types + tindx;
1719 bitsize = t->bitsize;
1727 fields = ((debug_field *)
1728 xrealloc (fields, alloc * sizeof *fields));
1731 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1732 ftype, offset, bitsize,
1733 DEBUG_VISIBILITY_PUBLIC);
1734 if (fields[c] == NULL)
1741 type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1748 if (! ieee_read_type_index (info, pp, &type))
1754 /* Procedure. FIXME: This is an extern declaration, which we
1755 have no way of representing. */
1760 bfd_boolean present;
1761 struct ieee_var *pv;
1763 /* FIXME: We ignore the attribute and the argument names. */
1765 if (! ieee_read_number (info, pp, &attr)
1766 || ! ieee_read_type_index (info, pp, &rtype)
1767 || ! ieee_read_number (info, pp, &nargs))
1772 unsigned long namlen;
1774 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1779 pv = info->vars.vars + varindx;
1780 pv->kind = IEEE_EXTERNAL;
1782 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1784 /* Set up the return type as an indirect type pointing to
1785 the variable slot, so that we can change it to a
1786 reference later if appropriate. */
1787 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1789 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1790 (const char *) NULL);
1793 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1800 /* Void. This is not documented, but the MRI compiler emits it. */
1801 type = debug_make_void_type (dhandle);
1805 /* Array with 0 lower bound. */
1810 if (! ieee_read_type_index (info, pp, &etype)
1811 || ! ieee_read_number (info, pp, &high))
1814 type = debug_make_array_type (dhandle, etype,
1815 ieee_builtin_type (info, ty_code_start,
1818 0, (bfd_signed_vma) high, FALSE);
1822 case 'c': /* Complex. */
1823 case 'd': /* Double complex. */
1826 unsigned long namlen;
1828 /* FIXME: I don't know what the name means. */
1830 if (! ieee_read_id (info, pp, &name, &namlen))
1833 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1838 /* Pascal file name. FIXME. */
1839 ieee_error (info, ty_code_start, _("Pascal file name not supported"));
1843 /* Bitfield type. */
1845 bfd_vma signedp, bitsize, dummy;
1846 const bfd_byte *hold;
1847 bfd_boolean present;
1849 if (! ieee_read_number (info, pp, &signedp)
1850 || ! ieee_read_number (info, pp, &bitsize))
1853 /* I think the documentation says that there is a type index,
1854 but some actual files do not have one. */
1856 if (! ieee_read_optional_number (info, pp, &dummy, &present))
1860 /* FIXME: This is just a guess. */
1861 type = debug_make_int_type (dhandle, 4,
1862 signedp ? FALSE : TRUE);
1867 if (! ieee_read_type_index (info, pp, &type))
1870 type_bitsize = bitsize;
1880 if (! ieee_read_number (info, pp, &kind)
1881 || ! ieee_read_type_index (info, pp, &t))
1887 ieee_error (info, ty_start, _("unsupported qualifier"));
1891 type = debug_make_const_type (dhandle, t);
1895 type = debug_make_volatile_type (dhandle, t);
1907 if (! ieee_read_number (info, pp, &size)
1908 || ! ieee_read_type_index (info, pp, &etype))
1911 /* FIXME: We ignore the size. */
1913 type = debug_make_set_type (dhandle, etype, FALSE);
1918 /* Procedure with compiler dependencies. */
1920 struct ieee_var *pv;
1921 bfd_vma attr, frame_type, push_mask, nargs, level, father;
1923 debug_type *arg_types;
1924 bfd_boolean varargs;
1925 bfd_boolean present;
1927 /* FIXME: We ignore some of this information. */
1929 pv = info->vars.vars + varindx;
1931 if (! ieee_read_number (info, pp, &attr)
1932 || ! ieee_read_number (info, pp, &frame_type)
1933 || ! ieee_read_number (info, pp, &push_mask)
1934 || ! ieee_read_type_index (info, pp, &rtype)
1935 || ! ieee_read_number (info, pp, &nargs))
1937 if (nargs == (bfd_vma) -1)
1946 arg_types = ((debug_type *)
1947 xmalloc ((nargs + 1) * sizeof *arg_types));
1948 for (i = 0; i < nargs; i++)
1949 if (! ieee_read_type_index (info, pp, arg_types + i))
1952 /* If the last type is pointer to void, this is really a
1953 varargs function. */
1959 last = arg_types[nargs - 1];
1960 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1961 && (debug_get_type_kind (dhandle,
1962 debug_get_target_type (dhandle,
1964 == DEBUG_KIND_VOID))
1971 /* If there are any pointer arguments, turn them into
1972 indirect types in case we later need to convert them to
1974 for (i = 0; i < nargs; i++)
1976 if (debug_get_type_kind (dhandle, arg_types[i])
1977 == DEBUG_KIND_POINTER)
1979 if (arg_slots == NULL)
1981 arg_slots = ((debug_type *)
1982 xmalloc (nargs * sizeof *arg_slots));
1983 memset (arg_slots, 0, nargs * sizeof *arg_slots);
1985 arg_slots[i] = arg_types[i];
1987 debug_make_indirect_type (dhandle,
1989 (const char *) NULL);
1993 arg_types[nargs] = DEBUG_TYPE_NULL;
1995 if (! ieee_read_number (info, pp, &level)
1996 || ! ieee_read_optional_number (info, pp, &father, &present))
1999 /* We can't distinguish between a global function and a static
2001 pv->kind = IEEE_FUNCTION;
2004 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
2006 /* Set up the return type as an indirect type pointing to
2007 the variable slot, so that we can change it to a
2008 reference later if appropriate. */
2009 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
2011 rtype = debug_make_indirect_type (dhandle, pv->pslot,
2012 (const char *) NULL);
2015 type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
2020 /* Record the type in the table. */
2022 if (type == DEBUG_TYPE_NULL)
2025 info->vars.vars[varindx].type = type;
2028 && info->vars.vars[varindx].namlen > 0)
2032 name = savestring (info->vars.vars[varindx].name,
2033 info->vars.vars[varindx].namlen);
2035 type = debug_name_type (dhandle, name, type);
2036 else if (tc == 'E' || tc == 'N')
2037 type = debug_tag_type (dhandle, name, type);
2040 struct ieee_tag *it;
2042 /* We must allocate all struct tags as indirect types, so
2043 that if we later see a definition of the tag as a C++
2044 record we can update the indirect slot and automatically
2045 change all the existing references. */
2046 it = (struct ieee_tag *) xmalloc (sizeof *it);
2047 memset (it, 0, sizeof *it);
2048 it->next = info->tags;
2053 type = debug_make_indirect_type (dhandle, &it->slot, name);
2054 type = debug_tag_type (dhandle, name, type);
2062 info->types.types[typeindx].type = type;
2063 info->types.types[typeindx].arg_slots = arg_slots;
2064 info->types.types[typeindx].bitsize = type_bitsize;
2066 /* We may have already allocated type as an indirect type pointing
2067 to slot. It does no harm to replace the indirect type with the
2068 real type. Filling in slot as well handles the indirect types
2069 which are already hanging around. */
2070 if (info->types.types[typeindx].pslot != NULL)
2071 *info->types.types[typeindx].pslot = type;
2076 /* Parse an ATN record. */
2079 parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp)
2081 const bfd_byte *atn_start, *atn_code_start;
2083 struct ieee_var *pvar;
2087 bfd_vma v, v2, v3, v4, v5;
2089 unsigned long namlen;
2091 bfd_boolean present;
2096 if (! ieee_read_number (info, pp, &varindx)
2097 || ! ieee_read_type_index (info, pp, &type))
2100 atn_code_start = *pp;
2102 if (! ieee_read_number (info, pp, &atn_code))
2111 else if (varindx < 32)
2113 /* The MRI compiler reportedly sometimes emits variable lifetime
2114 information for a register. We just ignore it. */
2116 return ieee_read_number (info, pp, &v);
2118 ieee_error (info, atn_start, _("illegal variable index"));
2124 if (varindx >= info->vars.alloc
2125 || info->vars.vars[varindx].name == NULL)
2127 /* The MRI compiler or linker sometimes omits the NN record
2128 for a pmisc record. */
2131 if (varindx >= info->vars.alloc)
2135 alloc = info->vars.alloc;
2138 while (varindx >= alloc)
2140 info->vars.vars = ((struct ieee_var *)
2141 xrealloc (info->vars.vars,
2143 * sizeof *info->vars.vars)));
2144 memset (info->vars.vars + info->vars.alloc, 0,
2145 ((alloc - info->vars.alloc)
2146 * sizeof *info->vars.vars));
2147 info->vars.alloc = alloc;
2150 pvar = info->vars.vars + varindx;
2156 ieee_error (info, atn_start, _("undefined variable in ATN"));
2161 pvar = info->vars.vars + varindx;
2166 namlen = pvar->namlen;
2169 dhandle = info->dhandle;
2171 /* If we are going to call debug_record_variable with a pointer
2172 type, change the type to an indirect type so that we can later
2173 change it to a reference type if we encounter a C++ pmisc 'R'
2176 && type != DEBUG_TYPE_NULL
2177 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2187 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2188 *pvar->pslot = type;
2189 type = debug_make_indirect_type (dhandle, pvar->pslot,
2190 (const char *) NULL);
2199 ieee_error (info, atn_code_start, _("unknown ATN type"));
2203 /* Automatic variable. */
2204 if (! ieee_read_number (info, pp, &v))
2206 namcopy = savestring (name, namlen);
2208 type = debug_make_void_type (dhandle);
2210 pvar->kind = IEEE_LOCAL;
2211 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2214 /* Register variable. */
2215 if (! ieee_read_number (info, pp, &v))
2217 namcopy = savestring (name, namlen);
2219 type = debug_make_void_type (dhandle);
2221 pvar->kind = IEEE_LOCAL;
2222 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2223 ieee_regno_to_genreg (info->abfd, v));
2226 /* Static variable. */
2227 if (! ieee_require_asn (info, pp, &v))
2229 namcopy = savestring (name, namlen);
2231 type = debug_make_void_type (dhandle);
2232 if (info->blockstack.bsp <= info->blockstack.stack)
2235 blocktype = info->blockstack.bsp[-1].kind;
2238 if (blocktype == 4 || blocktype == 6)
2239 pvar->kind = IEEE_LOCAL;
2241 pvar->kind = IEEE_STATIC;
2243 return debug_record_variable (dhandle, namcopy, type,
2244 (blocktype == 4 || blocktype == 6
2245 ? DEBUG_LOCAL_STATIC
2250 /* External function. We don't currently record these. FIXME. */
2252 pvar->kind = IEEE_EXTERNAL;
2256 /* External variable. We don't currently record these. FIXME. */
2258 pvar->kind = IEEE_EXTERNAL;
2262 if (! ieee_read_number (info, pp, &v)
2263 || ! ieee_read_number (info, pp, &v2)
2264 || ! ieee_read_optional_number (info, pp, &v3, &present))
2268 if (! ieee_read_optional_number (info, pp, &v4, &present))
2272 /* We just ignore the two optional fields in v3 and v4, since
2273 they are not defined. */
2275 if (! ieee_require_asn (info, pp, &v3))
2278 /* We have no way to record the column number. FIXME. */
2280 return debug_record_line (dhandle, v, v3);
2283 /* Global variable. */
2284 if (! ieee_require_asn (info, pp, &v))
2286 namcopy = savestring (name, namlen);
2288 type = debug_make_void_type (dhandle);
2290 pvar->kind = IEEE_GLOBAL;
2291 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2294 /* Variable lifetime information. */
2295 if (! ieee_read_number (info, pp, &v))
2298 /* We have no way to record this information. FIXME. */
2302 /* Locked register. The spec says that there are two required
2303 fields, but at least on occasion the MRI compiler only emits
2305 if (! ieee_read_number (info, pp, &v)
2306 || ! ieee_read_optional_number (info, pp, &v2, &present))
2309 /* I think this means a variable that is both in a register and
2310 a frame slot. We ignore the frame slot. FIXME. */
2312 namcopy = savestring (name, namlen);
2314 type = debug_make_void_type (dhandle);
2316 pvar->kind = IEEE_LOCAL;
2317 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2320 /* Reserved for FORTRAN common. */
2321 ieee_error (info, atn_code_start, _("unsupported ATN11"));
2323 /* Return TRUE to keep going. */
2327 /* Based variable. */
2331 if (! ieee_read_number (info, pp, &v)
2332 || ! ieee_read_number (info, pp, &v2)
2333 || ! ieee_read_optional_number (info, pp, &v3, &present))
2337 if (! ieee_read_optional_number (info, pp, &v4, &present))
2341 if (! ieee_read_optional_number (info, pp, &v5, &present))
2346 /* We have no way to record this information. FIXME. */
2348 ieee_error (info, atn_code_start, _("unsupported ATN12"));
2350 /* Return TRUE to keep going. */
2354 /* Constant. The description of this that I have is ambiguous,
2355 so I'm not going to try to implement it. */
2356 if (! ieee_read_number (info, pp, &v)
2357 || ! ieee_read_optional_number (info, pp, &v2, &present))
2361 if (! ieee_read_optional_number (info, pp, &v2, &present))
2365 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2370 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2372 if (! ieee_require_asn (info, pp, &v3))
2379 /* Static variable from assembler. */
2381 if (! ieee_read_number (info, pp, &v)
2382 || ! ieee_read_optional_number (info, pp, &v2, &present)
2383 || ! ieee_require_asn (info, pp, &v3))
2385 namcopy = savestring (name, namlen);
2386 /* We don't really handle this correctly. FIXME. */
2387 return debug_record_variable (dhandle, namcopy,
2388 debug_make_void_type (dhandle),
2389 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2393 /* Procedure miscellaneous information. */
2395 /* Variable miscellaneous information. */
2397 /* Module miscellaneous information. */
2398 if (! ieee_read_number (info, pp, &v)
2399 || ! ieee_read_number (info, pp, &v2)
2400 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2403 if (atn_code == 62 && v == 80)
2407 ieee_error (info, atn_code_start,
2408 _("unexpected string in C++ misc"));
2411 return ieee_read_cxx_misc (info, pp, v2);
2414 /* We just ignore all of this stuff. FIXME. */
2416 for (; v2 > 0; --v2)
2418 switch ((ieee_record_enum_type) **pp)
2421 ieee_error (info, *pp, _("bad misc record"));
2424 case ieee_at_record_enum:
2425 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2429 case ieee_e2_first_byte_enum:
2430 if (! ieee_require_asn (info, pp, &v3))
2442 /* Handle C++ debugging miscellaneous records. This is called for
2443 procedure miscellaneous records of type 80. */
2446 ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp,
2447 unsigned long count)
2449 const bfd_byte *start;
2454 /* Get the category of C++ misc record. */
2455 if (! ieee_require_asn (info, pp, &category))
2462 ieee_error (info, start, _("unrecognized C++ misc record"));
2466 if (! ieee_read_cxx_class (info, pp, count))
2474 unsigned long namlen;
2476 /* The IEEE spec indicates that the 'M' record only has a
2477 flags field. The MRI compiler also emits the name of the
2480 if (! ieee_require_asn (info, pp, &flags))
2482 if (*pp < info->pend
2483 && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2485 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2489 /* This is emitted for method functions, but I don't think we
2490 care very much. It might help if it told us useful
2491 information like the class with which this function is
2492 associated, but it doesn't, so it isn't helpful. */
2497 if (! ieee_read_cxx_defaults (info, pp, count))
2503 const char *name, *mangled, *class;
2504 unsigned long namlen, mangledlen, classlen;
2507 /* Pointer to member. */
2509 if (! ieee_require_atn65 (info, pp, &name, &namlen)
2510 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2511 || ! ieee_require_atn65 (info, pp, &class, &classlen)
2512 || ! ieee_require_asn (info, pp, &control))
2515 /* FIXME: We should now track down name and change its type. */
2520 if (! ieee_read_reference (info, pp))
2528 /* Read a C++ class definition. This is a pmisc type 80 record of
2532 ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp,
2533 unsigned long count)
2535 const bfd_byte *start;
2538 unsigned long taglen;
2539 struct ieee_tag *it;
2541 debug_field *fields;
2542 unsigned int field_count, field_alloc;
2543 debug_baseclass *baseclasses;
2544 unsigned int baseclasses_count, baseclasses_alloc;
2545 const debug_field *structfields;
2549 unsigned long namlen;
2550 debug_method_variant *variants;
2554 unsigned int methods_count, methods_alloc;
2555 debug_type vptrbase;
2556 bfd_boolean ownvptr;
2557 debug_method *dmethods;
2561 if (! ieee_require_asn (info, pp, &class))
2565 if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2569 /* Find the C struct with this name. */
2570 for (it = info->tags; it != NULL; it = it->next)
2571 if (it->name[0] == tag[0]
2572 && strncmp (it->name, tag, taglen) == 0
2573 && strlen (it->name) == taglen)
2577 ieee_error (info, start, _("undefined C++ object"));
2581 dhandle = info->dhandle;
2587 baseclasses_count = 0;
2588 baseclasses_alloc = 0;
2592 vptrbase = DEBUG_TYPE_NULL;
2595 structfields = debug_get_fields (dhandle, it->type);
2600 const bfd_byte *spec_start;
2604 if (! ieee_require_asn (info, pp, &id))
2611 ieee_error (info, spec_start, _("unrecognized C++ object spec"));
2616 bfd_vma flags, cinline;
2617 const char *basename, *fieldname;
2618 unsigned long baselen, fieldlen;
2620 debug_type basetype;
2622 bfd_boolean virtualp;
2623 enum debug_visibility visibility;
2624 debug_baseclass baseclass;
2626 /* This represents a base or friend class. */
2628 if (! ieee_require_asn (info, pp, &flags)
2629 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
2630 || ! ieee_require_asn (info, pp, &cinline)
2631 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2635 /* We have no way of recording friend information, so we
2637 if ((flags & BASEFLAGS_FRIEND) != 0)
2640 /* I assume that either all of the members of the
2641 baseclass are included in the object, starting at the
2642 beginning of the object, or that none of them are
2645 if ((fieldlen == 0) == (cinline == 0))
2647 ieee_error (info, start, _("unsupported C++ object type"));
2651 basecopy = savestring (basename, baselen);
2652 basetype = debug_find_tagged_type (dhandle, basecopy,
2653 DEBUG_KIND_ILLEGAL);
2655 if (basetype == DEBUG_TYPE_NULL)
2657 ieee_error (info, start, _("C++ base class not defined"));
2665 const debug_field *pf;
2667 if (structfields == NULL)
2669 ieee_error (info, start, _("C++ object has no fields"));
2673 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2677 fname = debug_get_field_name (dhandle, *pf);
2680 if (fname[0] == fieldname[0]
2681 && strncmp (fname, fieldname, fieldlen) == 0
2682 && strlen (fname) == fieldlen)
2685 if (*pf == DEBUG_FIELD_NULL)
2687 ieee_error (info, start,
2688 _("C++ base class not found in container"));
2692 bitpos = debug_get_field_bitpos (dhandle, *pf);
2695 if ((flags & BASEFLAGS_VIRTUAL) != 0)
2699 if ((flags & BASEFLAGS_PRIVATE) != 0)
2700 visibility = DEBUG_VISIBILITY_PRIVATE;
2702 visibility = DEBUG_VISIBILITY_PUBLIC;
2704 baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2705 virtualp, visibility);
2706 if (baseclass == DEBUG_BASECLASS_NULL)
2709 if (baseclasses_count + 1 >= baseclasses_alloc)
2711 baseclasses_alloc += 10;
2712 baseclasses = ((debug_baseclass *)
2713 xrealloc (baseclasses,
2715 * sizeof *baseclasses)));
2718 baseclasses[baseclasses_count] = baseclass;
2719 ++baseclasses_count;
2720 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2727 const char *fieldname, *mangledname;
2728 unsigned long fieldlen, mangledlen;
2730 bfd_boolean staticp;
2732 const debug_field *pf = NULL;
2733 enum debug_visibility visibility;
2736 /* This represents a data member. */
2738 if (! ieee_require_asn (info, pp, &flags)
2739 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2740 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2744 fieldcopy = savestring (fieldname, fieldlen);
2746 staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;
2750 struct ieee_var *pv, *pvend;
2752 /* See if we can find a definition for this variable. */
2753 pv = info->vars.vars;
2754 pvend = pv + info->vars.alloc;
2755 for (; pv < pvend; pv++)
2756 if (pv->namlen == mangledlen
2757 && strncmp (pv->name, mangledname, mangledlen) == 0)
2763 /* This can happen if the variable is never used. */
2764 ftype = ieee_builtin_type (info, start,
2765 (unsigned int) builtin_void);
2772 if (structfields == NULL)
2774 ieee_error (info, start, _("C++ object has no fields"));
2778 for (pf = structfields, findx = 0;
2779 *pf != DEBUG_FIELD_NULL;
2784 fname = debug_get_field_name (dhandle, *pf);
2787 if (fname[0] == mangledname[0]
2788 && strncmp (fname, mangledname, mangledlen) == 0
2789 && strlen (fname) == mangledlen)
2792 if (*pf == DEBUG_FIELD_NULL)
2794 ieee_error (info, start,
2795 _("C++ data member not found in container"));
2799 ftype = debug_get_field_type (dhandle, *pf);
2801 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2803 /* We might need to convert this field into a
2804 reference type later on, so make it an indirect
2806 if (it->fslots == NULL)
2809 const debug_field *pfcnt;
2812 for (pfcnt = structfields;
2813 *pfcnt != DEBUG_FIELD_NULL;
2816 it->fslots = ((debug_type *)
2817 xmalloc (fcnt * sizeof *it->fslots));
2818 memset (it->fslots, 0,
2819 fcnt * sizeof *it->fslots);
2822 if (ftype == DEBUG_TYPE_NULL)
2824 it->fslots[findx] = ftype;
2825 ftype = debug_make_indirect_type (dhandle,
2827 (const char *) NULL);
2830 if (ftype == DEBUG_TYPE_NULL)
2833 switch (flags & CXXFLAGS_VISIBILITY)
2836 ieee_error (info, start, _("unknown C++ visibility"));
2839 case CXXFLAGS_VISIBILITY_PUBLIC:
2840 visibility = DEBUG_VISIBILITY_PUBLIC;
2843 case CXXFLAGS_VISIBILITY_PRIVATE:
2844 visibility = DEBUG_VISIBILITY_PRIVATE;
2847 case CXXFLAGS_VISIBILITY_PROTECTED:
2848 visibility = DEBUG_VISIBILITY_PROTECTED;
2856 mangledcopy = savestring (mangledname, mangledlen);
2858 field = debug_make_static_member (dhandle, fieldcopy,
2864 bfd_vma bitpos, bitsize;
2866 bitpos = debug_get_field_bitpos (dhandle, *pf);
2867 bitsize = debug_get_field_bitsize (dhandle, *pf);
2868 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2870 ieee_error (info, start, _("bad C++ field bit pos or size"));
2873 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2874 bitsize, visibility);
2877 if (field == DEBUG_FIELD_NULL)
2880 if (field_count + 1 >= field_alloc)
2883 fields = ((debug_field *)
2884 xrealloc (fields, field_alloc * sizeof *fields));
2887 fields[field_count] = field;
2889 fields[field_count] = DEBUG_FIELD_NULL;
2896 bfd_vma flags, voffset, control;
2897 const char *name, *mangled;
2898 unsigned long namlen, mangledlen;
2899 struct ieee_var *pv, *pvend;
2901 enum debug_visibility visibility;
2902 bfd_boolean constp, volatilep;
2904 debug_method_variant mv;
2905 struct ieee_method *meth;
2908 if (! ieee_require_asn (info, pp, &flags)
2909 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2910 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2917 if (! ieee_require_asn (info, pp, &voffset))
2921 if (! ieee_require_asn (info, pp, &control))
2925 /* We just ignore the control information. */
2927 /* We have no way to represent friend information, so we
2929 if ((flags & CXXFLAGS_FRIEND) != 0)
2932 /* We should already have seen a type for the function. */
2933 pv = info->vars.vars;
2934 pvend = pv + info->vars.alloc;
2935 for (; pv < pvend; pv++)
2936 if (pv->namlen == mangledlen
2937 && strncmp (pv->name, mangled, mangledlen) == 0)
2942 /* We won't have type information for this function if
2943 it is not included in this file. We don't try to
2944 handle this case. FIXME. */
2945 type = (debug_make_function_type
2947 ieee_builtin_type (info, start,
2948 (unsigned int) builtin_void),
2949 (debug_type *) NULL,
2954 debug_type return_type;
2955 const debug_type *arg_types;
2956 bfd_boolean varargs;
2958 if (debug_get_type_kind (dhandle, pv->type)
2959 != DEBUG_KIND_FUNCTION)
2961 ieee_error (info, start,
2962 _("bad type for C++ method function"));
2966 return_type = debug_get_return_type (dhandle, pv->type);
2967 arg_types = debug_get_parameter_types (dhandle, pv->type,
2969 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
2971 ieee_error (info, start,
2972 _("no type information for C++ method function"));
2976 type = debug_make_method_type (dhandle, return_type, it->type,
2977 (debug_type *) arg_types,
2980 if (type == DEBUG_TYPE_NULL)
2983 switch (flags & CXXFLAGS_VISIBILITY)
2986 ieee_error (info, start, _("unknown C++ visibility"));
2989 case CXXFLAGS_VISIBILITY_PUBLIC:
2990 visibility = DEBUG_VISIBILITY_PUBLIC;
2993 case CXXFLAGS_VISIBILITY_PRIVATE:
2994 visibility = DEBUG_VISIBILITY_PRIVATE;
2997 case CXXFLAGS_VISIBILITY_PROTECTED:
2998 visibility = DEBUG_VISIBILITY_PROTECTED;
3002 constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
3003 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;
3005 mangledcopy = savestring (mangled, mangledlen);
3007 if ((flags & CXXFLAGS_STATIC) != 0)
3011 ieee_error (info, start, _("C++ static virtual method"));
3014 mv = debug_make_static_method_variant (dhandle, mangledcopy,
3020 debug_type vcontext;
3023 vcontext = DEBUG_TYPE_NULL;
3026 /* FIXME: How can we calculate this correctly? */
3027 vcontext = it->type;
3029 mv = debug_make_method_variant (dhandle, mangledcopy, type,
3034 if (mv == DEBUG_METHOD_VARIANT_NULL)
3037 for (meth = methods, im = 0; im < methods_count; meth++, im++)
3038 if (meth->namlen == namlen
3039 && strncmp (meth->name, name, namlen) == 0)
3041 if (im >= methods_count)
3043 if (methods_count >= methods_alloc)
3045 methods_alloc += 10;
3046 methods = ((struct ieee_method *)
3048 methods_alloc * sizeof *methods));
3050 methods[methods_count].name = name;
3051 methods[methods_count].namlen = namlen;
3052 methods[methods_count].variants = NULL;
3053 methods[methods_count].count = 0;
3054 methods[methods_count].alloc = 0;
3055 meth = methods + methods_count;
3059 if (meth->count + 1 >= meth->alloc)
3062 meth->variants = ((debug_method_variant *)
3063 xrealloc (meth->variants,
3065 * sizeof *meth->variants)));
3068 meth->variants[meth->count] = mv;
3070 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
3078 /* We have no way to store this information, so we just
3080 if (! ieee_require_asn (info, pp, &spec))
3083 if ((spec & 4) != 0)
3085 const char *filename;
3086 unsigned long filenamlen;
3089 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
3090 || ! ieee_require_asn (info, pp, &lineno))
3094 else if ((spec & 8) != 0)
3096 const char *mangled;
3097 unsigned long mangledlen;
3099 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
3105 ieee_error (info, start,
3106 _("unrecognized C++ object overhead spec"));
3114 const char *vname, *basename;
3115 unsigned long vnamelen, baselen;
3116 bfd_vma vsize, control;
3118 /* A virtual table pointer. */
3120 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3121 || ! ieee_require_asn (info, pp, &vsize)
3122 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
3123 || ! ieee_require_asn (info, pp, &control))
3127 /* We just ignore the control number. We don't care what
3128 the virtual table name is. We have no way to store the
3129 virtual table size, and I don't think we care anyhow. */
3131 /* FIXME: We can't handle multiple virtual table pointers. */
3139 basecopy = savestring (basename, baselen);
3140 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3141 DEBUG_KIND_ILLEGAL);
3143 if (vptrbase == DEBUG_TYPE_NULL)
3145 ieee_error (info, start, _("undefined C++ vtable"));
3154 /* Now that we have seen all the method variants, we can call
3155 debug_make_method for each one. */
3157 if (methods_count == 0)
3163 dmethods = ((debug_method *)
3164 xmalloc ((methods_count + 1) * sizeof *dmethods));
3165 for (i = 0; i < methods_count; i++)
3169 namcopy = savestring (methods[i].name, methods[i].namlen);
3170 dmethods[i] = debug_make_method (dhandle, namcopy,
3171 methods[i].variants);
3172 if (dmethods[i] == DEBUG_METHOD_NULL)
3175 dmethods[i] = DEBUG_METHOD_NULL;
3179 /* The struct type was created as an indirect type pointing at
3180 it->slot. We update it->slot to automatically update all
3181 references to this struct. */
3182 it->slot = debug_make_object_type (dhandle,
3184 debug_get_type_size (dhandle,
3186 fields, baseclasses, dmethods,
3188 if (it->slot == DEBUG_TYPE_NULL)
3194 /* Read C++ default argument value and reference type information. */
3197 ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp,
3198 unsigned long count)
3200 const bfd_byte *start;
3202 unsigned long fnlen;
3207 /* Giving the function name before the argument count is an addendum
3208 to the spec. The function name is demangled, though, so this
3209 record must always refer to the current function. */
3211 if (info->blockstack.bsp <= info->blockstack.stack
3212 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3214 ieee_error (info, start, _("C++ default values not in a function"));
3218 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3219 || ! ieee_require_asn (info, pp, &defcount))
3223 while (defcount-- > 0)
3227 unsigned long strvallen;
3229 if (! ieee_require_asn (info, pp, &type))
3241 if (! ieee_require_asn (info, pp, &val))
3248 if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3254 ieee_error (info, start, _("unrecognized C++ default type"));
3258 /* We have no way to record the default argument values, so we
3259 just ignore them. FIXME. */
3262 /* Any remaining arguments are indices of parameters that are really
3267 debug_type *arg_slots;
3269 dhandle = info->dhandle;
3270 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3276 if (! ieee_require_asn (info, pp, &indx))
3278 /* The index is 1 based. */
3280 if (arg_slots == NULL
3281 || arg_slots[indx] == DEBUG_TYPE_NULL
3282 || (debug_get_type_kind (dhandle, arg_slots[indx])
3283 != DEBUG_KIND_POINTER))
3285 ieee_error (info, start, _("reference parameter is not a pointer"));
3289 target = debug_get_target_type (dhandle, arg_slots[indx]);
3290 arg_slots[indx] = debug_make_reference_type (dhandle, target);
3291 if (arg_slots[indx] == DEBUG_TYPE_NULL)
3299 /* Read a C++ reference definition. */
3302 ieee_read_reference (struct ieee_info *info, const bfd_byte **pp)
3304 const bfd_byte *start;
3306 const char *class, *name;
3307 unsigned long classlen, namlen;
3313 if (! ieee_require_asn (info, pp, &flags))
3316 /* Giving the class name before the member name is in an addendum to
3320 if (! ieee_require_atn65 (info, pp, &class, &classlen))
3324 if (! ieee_require_atn65 (info, pp, &name, &namlen))
3332 /* We search from the last variable indices to the first in
3333 hopes of finding local variables correctly. We search the
3334 local variables on the first pass, and the global variables
3335 on the second. FIXME: This probably won't work in all cases.
3336 On the other hand, I don't know what will. */
3337 for (pass = 0; pass < 2; pass++)
3339 struct ieee_vars *vars;
3341 struct ieee_var *pv = NULL;
3347 vars = info->global_vars;
3352 for (i = (int) vars->alloc - 1; i >= 0; i--)
3356 pv = vars->vars + i;
3358 if (pv->pslot == NULL
3359 || pv->namlen != namlen
3360 || strncmp (pv->name, name, namlen) != 0)
3367 ieee_error (info, start,
3368 _("unrecognized C++ reference type"));
3372 /* Global variable or function. */
3373 if (pv->kind == IEEE_GLOBAL
3374 || pv->kind == IEEE_EXTERNAL
3375 || pv->kind == IEEE_FUNCTION)
3380 /* Global static variable or function. */
3381 if (pv->kind == IEEE_STATIC
3382 || pv->kind == IEEE_FUNCTION)
3387 /* Local variable. */
3388 if (pv->kind == IEEE_LOCAL)
3406 struct ieee_tag *it;
3408 for (it = info->tags; it != NULL; it = it->next)
3410 if (it->name[0] == class[0]
3411 && strncmp (it->name, class, classlen) == 0
3412 && strlen (it->name) == classlen)
3414 if (it->fslots != NULL)
3416 const debug_field *pf;
3419 pf = debug_get_fields (info->dhandle, it->type);
3422 ieee_error (info, start,
3423 "C++ reference in class with no fields");
3427 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3431 fname = debug_get_field_name (info->dhandle, *pf);
3434 if (strncmp (fname, name, namlen) == 0
3435 && strlen (fname) == namlen)
3437 pslot = it->fslots + findx;
3450 ieee_error (info, start, _("C++ reference not found"));
3454 /* We allocated the type of the object as an indirect type pointing
3455 to *pslot, which we can now update to be a reference type. */
3456 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3458 ieee_error (info, start, _("C++ reference is not pointer"));
3462 target = debug_get_target_type (info->dhandle, *pslot);
3463 *pslot = debug_make_reference_type (info->dhandle, target);
3464 if (*pslot == DEBUG_TYPE_NULL)
3470 /* Require an ASN record. */
3473 ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv)
3475 const bfd_byte *start;
3476 ieee_record_enum_type c;
3481 c = (ieee_record_enum_type) **pp;
3482 if (c != ieee_e2_first_byte_enum)
3484 ieee_error (info, start, _("missing required ASN"));
3489 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3490 if (c != ieee_asn_record_enum)
3492 ieee_error (info, start, _("missing required ASN"));
3497 /* Just ignore the variable index. */
3498 if (! ieee_read_number (info, pp, &varindx))
3501 return ieee_read_expression (info, pp, pv);
3504 /* Require an ATN65 record. */
3507 ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp,
3508 const char **pname, unsigned long *pnamlen)
3510 const bfd_byte *start;
3511 ieee_record_enum_type c;
3512 bfd_vma name_indx, type_indx, atn_code;
3516 c = (ieee_record_enum_type) **pp;
3517 if (c != ieee_at_record_enum)
3519 ieee_error (info, start, _("missing required ATN65"));
3524 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3525 if (c != ieee_atn_record_enum)
3527 ieee_error (info, start, _("missing required ATN65"));
3532 if (! ieee_read_number (info, pp, &name_indx)
3533 || ! ieee_read_number (info, pp, &type_indx)
3534 || ! ieee_read_number (info, pp, &atn_code))
3537 /* Just ignore name_indx. */
3539 if (type_indx != 0 || atn_code != 65)
3541 ieee_error (info, start, _("bad ATN65 record"));
3545 return ieee_read_id (info, pp, pname, pnamlen);
3548 /* Convert a register number in IEEE debugging information into a
3549 generic register number. */
3552 ieee_regno_to_genreg (bfd *abfd, int r)
3554 switch (bfd_get_arch (abfd))
3557 /* For some reasons stabs adds 2 to the floating point register
3564 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3565 32 to 35 for fp0 to fp3. */
3576 /* Convert a generic register number to an IEEE specific one. */
3579 ieee_genreg_to_regno (bfd *abfd, int r)
3581 switch (bfd_get_arch (abfd))
3584 /* For some reason stabs add 2 to the floating point register
3591 /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
3592 32 to 35 for fp0 to fp3. */
3603 /* These routines build IEEE debugging information out of the generic
3604 debugging information. */
3606 /* We build the IEEE debugging information byte by byte. Rather than
3607 waste time copying data around, we use a linked list of buffers to
3610 #define IEEE_BUFSIZE (490)
3615 struct ieee_buf *next;
3616 /* Number of data bytes in this buffer. */
3619 bfd_byte buf[IEEE_BUFSIZE];
3622 /* A list of buffers. */
3627 struct ieee_buf *head;
3628 /* Tail--last buffer on list. */
3629 struct ieee_buf *tail;
3632 /* In order to generate the BB11 blocks required by the HP emulator,
3633 we keep track of ranges of addresses which correspond to a given
3634 compilation unit. */
3639 struct ieee_range *next;
3646 /* This structure holds information for a class on the type stack. */
3648 struct ieee_type_class
3650 /* The name index in the debugging information. */
3652 /* The pmisc records for the class. */
3653 struct ieee_buflist pmiscbuf;
3654 /* The number of pmisc records. */
3655 unsigned int pmisccount;
3656 /* The name of the class holding the virtual table, if not this
3659 /* Whether this class holds its own virtual table. */
3660 bfd_boolean ownvptr;
3661 /* The largest virtual table offset seen so far. */
3663 /* The current method. */
3665 /* Additional pmisc records used to record fields of reference type. */
3666 struct ieee_buflist refs;
3669 /* This is how we store types for the writing routines. Most types
3670 are simply represented by a type index. */
3672 struct ieee_write_type
3676 /* The size of the type, if known. */
3678 /* The name of the type, if any. */
3680 /* If this is a function or method type, we build the type here, and
3681 only add it to the output buffers if we need it. */
3682 struct ieee_buflist fndef;
3683 /* If this is a struct, this is where the struct definition is
3685 struct ieee_buflist strdef;
3686 /* If this is a class, this is where the class information is built. */
3687 struct ieee_type_class *classdef;
3688 /* Whether the type is unsigned. */
3689 unsigned int unsignedp : 1;
3690 /* Whether this is a reference type. */
3691 unsigned int referencep : 1;
3692 /* Whether this is in the local type block. */
3693 unsigned int localp : 1;
3694 /* Whether this is a duplicate struct definition which we are
3696 unsigned int ignorep : 1;
3699 /* This is the type stack used by the debug writing routines. FIXME:
3700 We could generate more efficient output if we remembered when we
3701 have output a particular type before. */
3703 struct ieee_type_stack
3705 /* Next entry on stack. */
3706 struct ieee_type_stack *next;
3707 /* Type information. */
3708 struct ieee_write_type type;
3711 /* This is a list of associations between a name and some types.
3712 These are used for typedefs and tags. */
3714 struct ieee_name_type
3716 /* Next type for this name. */
3717 struct ieee_name_type *next;
3718 /* ID number. For a typedef, this is the index of the type to which
3719 this name is typedefed. */
3722 struct ieee_write_type type;
3723 /* If this is a tag which has not yet been defined, this is the
3724 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3725 enum debug_type_kind kind;
3728 /* We use a hash table to associate names and types. */
3730 struct ieee_name_type_hash_table
3732 struct bfd_hash_table root;
3735 struct ieee_name_type_hash_entry
3737 struct bfd_hash_entry root;
3738 /* Information for this name. */
3739 struct ieee_name_type *types;
3742 /* This is a list of enums. */
3744 struct ieee_defined_enum
3747 struct ieee_defined_enum *next;
3750 /* Whether this enum has been defined. */
3751 bfd_boolean defined;
3757 bfd_signed_vma *vals;
3760 /* We keep a list of modified versions of types, so that we don't
3761 output them more than once. */
3763 struct ieee_modified_type
3765 /* Pointer to this type. */
3766 unsigned int pointer;
3767 /* Function with unknown arguments returning this type. */
3768 unsigned int function;
3769 /* Const version of this type. */
3770 unsigned int const_qualified;
3771 /* Volatile version of this type. */
3772 unsigned int volatile_qualified;
3773 /* List of arrays of this type of various bounds. */
3774 struct ieee_modified_array_type *arrays;
3777 /* A list of arrays bounds. */
3779 struct ieee_modified_array_type
3781 /* Next array bounds. */
3782 struct ieee_modified_array_type *next;
3783 /* Type index with these bounds. */
3788 bfd_signed_vma high;
3791 /* This is a list of pending function parameter information. We don't
3792 output them until we see the first block. */
3794 struct ieee_pending_parm
3796 /* Next pending parameter. */
3797 struct ieee_pending_parm *next;
3802 /* Whether the type is a reference. */
3803 bfd_boolean referencep;
3805 enum debug_parm_kind kind;
3810 /* This is the handle passed down by debug_write. */
3814 /* BFD we are writing to. */
3816 /* Whether we got an error in a subroutine called via traverse or
3817 map_over_sections. */
3819 /* Current data buffer list. */
3820 struct ieee_buflist *current;
3821 /* Current data buffer. */
3822 struct ieee_buf *curbuf;
3823 /* Filename of current compilation unit. */
3824 const char *filename;
3825 /* Module name of current compilation unit. */
3826 const char *modname;
3827 /* List of buffer for global types. */
3828 struct ieee_buflist global_types;
3829 /* List of finished data buffers. */
3830 struct ieee_buflist data;
3831 /* List of buffers for typedefs in the current compilation unit. */
3832 struct ieee_buflist types;
3833 /* List of buffers for variables and functions in the current
3834 compilation unit. */
3835 struct ieee_buflist vars;
3836 /* List of buffers for C++ class definitions in the current
3837 compilation unit. */
3838 struct ieee_buflist cxx;
3839 /* List of buffers for line numbers in the current compilation unit. */
3840 struct ieee_buflist linenos;
3841 /* Ranges for the current compilation unit. */
3842 struct ieee_range *ranges;
3843 /* Ranges for all debugging information. */
3844 struct ieee_range *global_ranges;
3845 /* Nested pending ranges. */
3846 struct ieee_range *pending_ranges;
3848 struct ieee_type_stack *type_stack;
3849 /* Next unallocated type index. */
3850 unsigned int type_indx;
3851 /* Next unallocated name index. */
3852 unsigned int name_indx;
3854 struct ieee_name_type_hash_table typedefs;
3856 struct ieee_name_type_hash_table tags;
3858 struct ieee_defined_enum *enums;
3859 /* Modified versions of types. */
3860 struct ieee_modified_type *modified;
3861 /* Number of entries allocated in modified. */
3862 unsigned int modified_alloc;
3863 /* 4 byte complex type. */
3864 unsigned int complex_float_index;
3865 /* 8 byte complex type. */
3866 unsigned int complex_double_index;
3867 /* The depth of block nesting. This is 0 outside a function, and 1
3868 just after start_function is called. */
3869 unsigned int block_depth;
3870 /* The name of the current function. */
3872 /* List of buffers for the type of the function we are currently
3874 struct ieee_buflist fntype;
3875 /* List of buffers for the parameters of the function we are
3876 currently writing out. */
3877 struct ieee_buflist fnargs;
3878 /* Number of arguments written to fnargs. */
3879 unsigned int fnargcount;
3880 /* Pending function parameters. */
3881 struct ieee_pending_parm *pending_parms;
3882 /* Current line number filename. */
3883 const char *lineno_filename;
3884 /* Line number name index. */
3885 unsigned int lineno_name_indx;
3886 /* Filename of pending line number. */
3887 const char *pending_lineno_filename;
3888 /* Pending line number. */
3889 unsigned long pending_lineno;
3890 /* Address of pending line number. */
3891 bfd_vma pending_lineno_addr;
3892 /* Highest address seen at end of procedure. */
3896 static bfd_boolean ieee_init_buffer
3897 (struct ieee_handle *, struct ieee_buflist *);
3898 static bfd_boolean ieee_change_buffer
3899 (struct ieee_handle *, struct ieee_buflist *);
3900 static bfd_boolean ieee_append_buffer
3901 (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *);
3902 static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int);
3903 static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int);
3904 static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma);
3905 static bfd_boolean ieee_write_id (struct ieee_handle *, const char *);
3906 static bfd_boolean ieee_write_asn
3907 (struct ieee_handle *, unsigned int, bfd_vma);
3908 static bfd_boolean ieee_write_atn65
3909 (struct ieee_handle *, unsigned int, const char *);
3910 static bfd_boolean ieee_push_type
3911 (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean,
3913 static unsigned int ieee_pop_type (struct ieee_handle *);
3914 static void ieee_pop_unused_type (struct ieee_handle *);
3915 static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean);
3916 static bfd_boolean ieee_add_range
3917 (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma);
3918 static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma);
3919 static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma);
3920 static bfd_boolean ieee_define_type
3921 (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean);
3922 static bfd_boolean ieee_define_named_type
3923 (struct ieee_handle *, const char *, unsigned int, unsigned int,
3924 bfd_boolean, bfd_boolean, struct ieee_buflist *);
3925 static struct ieee_modified_type *ieee_get_modified_info
3926 (struct ieee_handle *, unsigned int);
3927 static struct bfd_hash_entry *ieee_name_type_newfunc
3928 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
3929 static bfd_boolean ieee_write_undefined_tag
3930 (struct ieee_name_type_hash_entry *, void *);
3931 static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *);
3932 static void ieee_add_bb11_blocks (bfd *, asection *, void *);
3933 static bfd_boolean ieee_add_bb11
3934 (struct ieee_handle *, asection *, bfd_vma, bfd_vma);
3935 static bfd_boolean ieee_output_pending_parms (struct ieee_handle *);
3936 static unsigned int ieee_vis_to_flags (enum debug_visibility);
3937 static bfd_boolean ieee_class_method_var
3938 (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean,
3939 bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
3941 static bfd_boolean ieee_start_compilation_unit (void *, const char *);
3942 static bfd_boolean ieee_start_source (void *, const char *);
3943 static bfd_boolean ieee_empty_type (void *);
3944 static bfd_boolean ieee_void_type (void *);
3945 static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean);
3946 static bfd_boolean ieee_float_type (void *, unsigned int);
3947 static bfd_boolean ieee_complex_type (void *, unsigned int);
3948 static bfd_boolean ieee_bool_type (void *, unsigned int);
3949 static bfd_boolean ieee_enum_type
3950 (void *, const char *, const char **, bfd_signed_vma *);
3951 static bfd_boolean ieee_pointer_type (void *);
3952 static bfd_boolean ieee_function_type (void *, int, bfd_boolean);
3953 static bfd_boolean ieee_reference_type (void *);
3954 static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma);
3955 static bfd_boolean ieee_array_type
3956 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
3957 static bfd_boolean ieee_set_type (void *, bfd_boolean);
3958 static bfd_boolean ieee_offset_type (void *);
3959 static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean);
3960 static bfd_boolean ieee_const_type (void *);
3961 static bfd_boolean ieee_volatile_type (void *);
3962 static bfd_boolean ieee_start_struct_type
3963 (void *, const char *, unsigned int, bfd_boolean, unsigned int);
3964 static bfd_boolean ieee_struct_field
3965 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
3966 static bfd_boolean ieee_end_struct_type (void *);
3967 static bfd_boolean ieee_start_class_type
3968 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean,
3970 static bfd_boolean ieee_class_static_member
3971 (void *, const char *, const char *, enum debug_visibility);
3972 static bfd_boolean ieee_class_baseclass
3973 (void *, bfd_vma, bfd_boolean, enum debug_visibility);
3974 static bfd_boolean ieee_class_start_method (void *, const char *);
3975 static bfd_boolean ieee_class_method_variant
3976 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
3977 bfd_vma, bfd_boolean);
3978 static bfd_boolean ieee_class_static_method_variant
3979 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
3980 static bfd_boolean ieee_class_end_method (void *);
3981 static bfd_boolean ieee_end_class_type (void *);
3982 static bfd_boolean ieee_typedef_type (void *, const char *);
3983 static bfd_boolean ieee_tag_type
3984 (void *, const char *, unsigned int, enum debug_type_kind);
3985 static bfd_boolean ieee_typdef (void *, const char *);
3986 static bfd_boolean ieee_tag (void *, const char *);
3987 static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma);
3988 static bfd_boolean ieee_float_constant (void *, const char *, double);
3989 static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma);
3990 static bfd_boolean ieee_variable
3991 (void *, const char *, enum debug_var_kind, bfd_vma);
3992 static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean);
3993 static bfd_boolean ieee_function_parameter
3994 (void *, const char *, enum debug_parm_kind, bfd_vma);
3995 static bfd_boolean ieee_start_block (void *, bfd_vma);
3996 static bfd_boolean ieee_end_block (void *, bfd_vma);
3997 static bfd_boolean ieee_end_function (void *);
3998 static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma);
4000 static const struct debug_write_fns ieee_fns =
4002 ieee_start_compilation_unit,
4013 ieee_reference_type,
4021 ieee_start_struct_type,
4023 ieee_end_struct_type,
4024 ieee_start_class_type,
4025 ieee_class_static_member,
4026 ieee_class_baseclass,
4027 ieee_class_start_method,
4028 ieee_class_method_variant,
4029 ieee_class_static_method_variant,
4030 ieee_class_end_method,
4031 ieee_end_class_type,
4037 ieee_float_constant,
4038 ieee_typed_constant,
4040 ieee_start_function,
4041 ieee_function_parameter,
4048 /* Initialize a buffer to be empty. */
4051 ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4052 struct ieee_buflist *buflist)
4054 buflist->head = NULL;
4055 buflist->tail = NULL;
4059 /* See whether a buffer list has any data. */
4061 #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
4063 /* Change the current buffer to a specified buffer chain. */
4066 ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist)
4068 if (buflist->head == NULL)
4070 struct ieee_buf *buf;
4072 buf = (struct ieee_buf *) xmalloc (sizeof *buf);
4075 buflist->head = buf;
4076 buflist->tail = buf;
4079 info->current = buflist;
4080 info->curbuf = buflist->tail;
4085 /* Append a buffer chain. */
4088 ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
4089 struct ieee_buflist *mainbuf,
4090 struct ieee_buflist *newbuf)
4092 if (newbuf->head != NULL)
4094 if (mainbuf->head == NULL)
4095 mainbuf->head = newbuf->head;
4097 mainbuf->tail->next = newbuf->head;
4098 mainbuf->tail = newbuf->tail;
4103 /* Write a byte into the buffer. We use a macro for speed and a
4104 function for the complex cases. */
4106 #define ieee_write_byte(info, b) \
4107 ((info)->curbuf->c < IEEE_BUFSIZE \
4108 ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \
4109 : ieee_real_write_byte ((info), (b)))
4112 ieee_real_write_byte (struct ieee_handle *info, int b)
4114 if (info->curbuf->c >= IEEE_BUFSIZE)
4118 n = (struct ieee_buf *) xmalloc (sizeof *n);
4121 if (info->current->head == NULL)
4122 info->current->head = n;
4124 info->current->tail->next = n;
4125 info->current->tail = n;
4129 info->curbuf->buf[info->curbuf->c] = b;
4135 /* Write out two bytes. */
4138 ieee_write_2bytes (struct ieee_handle *info, int i)
4140 return (ieee_write_byte (info, i >> 8)
4141 && ieee_write_byte (info, i & 0xff));
4144 /* Write out an integer. */
4147 ieee_write_number (struct ieee_handle *info, bfd_vma v)
4154 if (v <= (bfd_vma) ieee_number_end_enum)
4155 return ieee_write_byte (info, (int) v);
4166 if (c > (unsigned int) (ieee_number_repeat_end_enum
4167 - ieee_number_repeat_start_enum))
4169 fprintf (stderr, _("IEEE numeric overflow: 0x"));
4170 fprintf_vma (stderr, v);
4171 fprintf (stderr, "\n");
4175 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
4177 for (; c > 0; --c, ++p)
4179 if (! ieee_write_byte (info, *p))
4186 /* Write out a string. */
4189 ieee_write_id (struct ieee_handle *info, const char *s)
4196 if (! ieee_write_byte (info, len))
4199 else if (len <= 0xff)
4201 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
4202 || ! ieee_write_byte (info, len))
4205 else if (len <= 0xffff)
4207 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
4208 || ! ieee_write_2bytes (info, len))
4213 fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
4217 for (; *s != '\0'; s++)
4218 if (! ieee_write_byte (info, *s))
4224 /* Write out an ASN record. */
4227 ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val)
4229 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
4230 && ieee_write_number (info, indx)
4231 && ieee_write_number (info, val));
4234 /* Write out an ATN65 record. */
4237 ieee_write_atn65 (struct ieee_handle *info, unsigned int indx, const char *s)
4239 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
4240 && ieee_write_number (info, indx)
4241 && ieee_write_number (info, 0)
4242 && ieee_write_number (info, 65)
4243 && ieee_write_id (info, s));
4246 /* Push a type index onto the type stack. */
4249 ieee_push_type (struct ieee_handle *info, unsigned int indx,
4250 unsigned int size, bfd_boolean unsignedp, bfd_boolean localp)
4252 struct ieee_type_stack *ts;
4254 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
4255 memset (ts, 0, sizeof *ts);
4257 ts->type.indx = indx;
4258 ts->type.size = size;
4259 ts->type.unsignedp = unsignedp;
4260 ts->type.localp = localp;
4262 ts->next = info->type_stack;
4263 info->type_stack = ts;
4268 /* Pop a type index off the type stack. */
4271 ieee_pop_type (struct ieee_handle *info)
4273 return ieee_pop_type_used (info, TRUE);
4276 /* Pop an unused type index off the type stack. */
4279 ieee_pop_unused_type (struct ieee_handle *info)
4281 (void) ieee_pop_type_used (info, FALSE);
4284 /* Pop a used or unused type index off the type stack. */
4287 ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used)
4289 struct ieee_type_stack *ts;
4292 ts = info->type_stack;
4293 assert (ts != NULL);
4295 /* If this is a function type, and we need it, we need to append the
4296 actual definition to the typedef block now. */
4297 if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
4299 struct ieee_buflist *buflist;
4301 if (ts->type.localp)
4303 /* Make sure we have started the types block. */
4304 if (ieee_buffer_emptyp (&info->types))
4306 if (! ieee_change_buffer (info, &info->types)
4307 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4308 || ! ieee_write_byte (info, 1)
4309 || ! ieee_write_number (info, 0)
4310 || ! ieee_write_id (info, info->modname))
4313 buflist = &info->types;
4317 /* Make sure we started the global type block. */
4318 if (ieee_buffer_emptyp (&info->global_types))
4320 if (! ieee_change_buffer (info, &info->global_types)
4321 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4322 || ! ieee_write_byte (info, 2)
4323 || ! ieee_write_number (info, 0)
4324 || ! ieee_write_id (info, ""))
4327 buflist = &info->global_types;
4330 if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
4334 ret = ts->type.indx;
4335 info->type_stack = ts->next;
4340 /* Add a range of bytes included in the current compilation unit. */
4343 ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low,
4346 struct ieee_range **plist, *r, **pr;
4348 if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high)
4352 plist = &info->global_ranges;
4354 plist = &info->ranges;
4356 for (r = *plist; r != NULL; r = r->next)
4358 if (high >= r->low && low <= r->high)
4360 /* The new range overlaps r. */
4366 while (*pr != NULL && (*pr)->low <= r->high)
4368 struct ieee_range *n;
4370 if ((*pr)->high > r->high)
4371 r->high = (*pr)->high;
4380 r = (struct ieee_range *) xmalloc (sizeof *r);
4381 memset (r, 0, sizeof *r);
4386 /* Store the ranges sorted by address. */
4387 for (pr = plist; *pr != NULL; pr = &(*pr)->next)
4388 if ((*pr)->low > high)
4396 /* Start a new range for which we only have the low address. */
4399 ieee_start_range (struct ieee_handle *info, bfd_vma low)
4401 struct ieee_range *r;
4403 r = (struct ieee_range *) xmalloc (sizeof *r);
4404 memset (r, 0, sizeof *r);
4406 r->next = info->pending_ranges;
4407 info->pending_ranges = r;
4411 /* Finish a range started by ieee_start_range. */
4414 ieee_end_range (struct ieee_handle *info, bfd_vma high)
4416 struct ieee_range *r;
4419 assert (info->pending_ranges != NULL);
4420 r = info->pending_ranges;
4422 info->pending_ranges = r->next;
4424 return ieee_add_range (info, FALSE, low, high);
4427 /* Start defining a type. */
4430 ieee_define_type (struct ieee_handle *info, unsigned int size,
4431 bfd_boolean unsignedp, bfd_boolean localp)
4433 return ieee_define_named_type (info, (const char *) NULL,
4434 (unsigned int) -1, size, unsignedp,
4435 localp, (struct ieee_buflist *) NULL);
4438 /* Start defining a named type. */
4441 ieee_define_named_type (struct ieee_handle *info, const char *name,
4442 unsigned int indx, unsigned int size,
4443 bfd_boolean unsignedp, bfd_boolean localp,
4444 struct ieee_buflist *buflist)
4446 unsigned int type_indx;
4447 unsigned int name_indx;
4449 if (indx != (unsigned int) -1)
4453 type_indx = info->type_indx;
4457 name_indx = info->name_indx;
4463 /* If we were given a buffer, use it; otherwise, use either the
4464 local or the global type information, and make sure that the type
4465 block is started. */
4466 if (buflist != NULL)
4468 if (! ieee_change_buffer (info, buflist))
4473 if (! ieee_buffer_emptyp (&info->types))
4475 if (! ieee_change_buffer (info, &info->types))
4480 if (! ieee_change_buffer (info, &info->types)
4481 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4482 || ! ieee_write_byte (info, 1)
4483 || ! ieee_write_number (info, 0)
4484 || ! ieee_write_id (info, info->modname))
4490 if (! ieee_buffer_emptyp (&info->global_types))
4492 if (! ieee_change_buffer (info, &info->global_types))
4497 if (! ieee_change_buffer (info, &info->global_types)
4498 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4499 || ! ieee_write_byte (info, 2)
4500 || ! ieee_write_number (info, 0)
4501 || ! ieee_write_id (info, ""))
4506 /* Push the new type on the type stack, write out an NN record, and
4507 write out the start of a TY record. The caller will then finish
4509 if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
4512 return (ieee_write_byte (info, (int) ieee_nn_record)
4513 && ieee_write_number (info, name_indx)
4514 && ieee_write_id (info, name)
4515 && ieee_write_byte (info, (int) ieee_ty_record_enum)
4516 && ieee_write_number (info, type_indx)
4517 && ieee_write_byte (info, 0xce)
4518 && ieee_write_number (info, name_indx));
4521 /* Get an entry to the list of modified versions of a type. */
4523 static struct ieee_modified_type *
4524 ieee_get_modified_info (struct ieee_handle *info, unsigned int indx)
4526 if (indx >= info->modified_alloc)
4528 unsigned int nalloc;
4530 nalloc = info->modified_alloc;
4533 while (indx >= nalloc)
4535 info->modified = ((struct ieee_modified_type *)
4536 xrealloc (info->modified,
4537 nalloc * sizeof *info->modified));
4538 memset (info->modified + info->modified_alloc, 0,
4539 (nalloc - info->modified_alloc) * sizeof *info->modified);
4540 info->modified_alloc = nalloc;
4543 return info->modified + indx;
4546 /* Routines for the hash table mapping names to types. */
4548 /* Initialize an entry in the hash table. */
4550 static struct bfd_hash_entry *
4551 ieee_name_type_newfunc (struct bfd_hash_entry *entry,
4552 struct bfd_hash_table *table, const char *string)
4554 struct ieee_name_type_hash_entry *ret =
4555 (struct ieee_name_type_hash_entry *) entry;
4557 /* Allocate the structure if it has not already been allocated by a
4560 ret = ((struct ieee_name_type_hash_entry *)
4561 bfd_hash_allocate (table, sizeof *ret));
4565 /* Call the allocation method of the superclass. */
4566 ret = ((struct ieee_name_type_hash_entry *)
4567 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
4570 /* Set local fields. */
4574 return (struct bfd_hash_entry *) ret;
4577 /* Look up an entry in the hash table. */
4579 #define ieee_name_type_hash_lookup(table, string, create, copy) \
4580 ((struct ieee_name_type_hash_entry *) \
4581 bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
4583 /* Traverse the hash table. */
4585 #define ieee_name_type_hash_traverse(table, func, info) \
4586 (bfd_hash_traverse \
4588 (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \
4591 /* The general routine to write out IEEE debugging information. */
4594 write_ieee_debugging_info (bfd *abfd, void *dhandle)
4596 struct ieee_handle info;
4601 memset (&info, 0, sizeof info);
4603 info.type_indx = 256;
4604 info.name_indx = 32;
4606 if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc,
4607 sizeof (struct ieee_name_type_hash_entry))
4608 || !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc,
4609 sizeof (struct ieee_name_type_hash_entry)))
4612 if (! ieee_init_buffer (&info, &info.global_types)
4613 || ! ieee_init_buffer (&info, &info.data)
4614 || ! ieee_init_buffer (&info, &info.types)
4615 || ! ieee_init_buffer (&info, &info.vars)
4616 || ! ieee_init_buffer (&info, &info.cxx)
4617 || ! ieee_init_buffer (&info, &info.linenos)
4618 || ! ieee_init_buffer (&info, &info.fntype)
4619 || ! ieee_init_buffer (&info, &info.fnargs))
4622 if (! debug_write (dhandle, &ieee_fns, (void *) &info))
4625 if (info.filename != NULL)
4627 if (! ieee_finish_compilation_unit (&info))
4631 /* Put any undefined tags in the global typedef information. */
4633 ieee_name_type_hash_traverse (&info.tags,
4634 ieee_write_undefined_tag,
4639 /* Prepend the global typedef information to the other data. */
4640 if (! ieee_buffer_emptyp (&info.global_types))
4642 /* The HP debugger seems to have a bug in which it ignores the
4643 last entry in the global types, so we add a dummy entry. */
4644 if (! ieee_change_buffer (&info, &info.global_types)
4645 || ! ieee_write_byte (&info, (int) ieee_nn_record)
4646 || ! ieee_write_number (&info, info.name_indx)
4647 || ! ieee_write_id (&info, "")
4648 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
4649 || ! ieee_write_number (&info, info.type_indx)
4650 || ! ieee_write_byte (&info, 0xce)
4651 || ! ieee_write_number (&info, info.name_indx)
4652 || ! ieee_write_number (&info, 'P')
4653 || ! ieee_write_number (&info, (int) builtin_void + 32)
4654 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4657 if (! ieee_append_buffer (&info, &info.global_types, &info.data))
4659 info.data = info.global_types;
4662 /* Make sure that we have declare BB11 blocks for each range in the
4663 file. They are added to info->vars. */
4665 if (! ieee_init_buffer (&info, &info.vars))
4667 bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info);
4670 if (! ieee_buffer_emptyp (&info.vars))
4672 if (! ieee_change_buffer (&info, &info.vars)
4673 || ! ieee_write_byte (&info, (int) ieee_be_record_enum))
4676 if (! ieee_append_buffer (&info, &info.data, &info.vars))
4680 /* Now all the data is in info.data. Write it out to the BFD. We
4681 normally would need to worry about whether all the other sections
4682 are set up yet, but the IEEE backend will handle this particular
4683 case correctly regardless. */
4684 if (ieee_buffer_emptyp (&info.data))
4686 /* There is no debugging information. */
4690 s = bfd_make_section_with_flags (abfd, ".debug",
4691 SEC_DEBUGGING | SEC_HAS_CONTENTS);
4693 err = "bfd_make_section";
4699 for (b = info.data.head; b != NULL; b = b->next)
4701 if (! bfd_set_section_size (abfd, s, size))
4702 err = "bfd_set_section_size";
4709 for (b = info.data.head; b != NULL; b = b->next)
4711 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4713 err = "bfd_set_section_contents";
4722 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4723 bfd_errmsg (bfd_get_error ()));
4727 bfd_hash_table_free (&info.typedefs.root);
4728 bfd_hash_table_free (&info.tags.root);
4733 /* Write out information for an undefined tag. This is called via
4734 ieee_name_type_hash_traverse. */
4737 ieee_write_undefined_tag (struct ieee_name_type_hash_entry *h, void *p)
4739 struct ieee_handle *info = (struct ieee_handle *) p;
4740 struct ieee_name_type *nt;
4742 for (nt = h->types; nt != NULL; nt = nt->next)
4744 unsigned int name_indx;
4747 if (nt->kind == DEBUG_KIND_ILLEGAL)
4750 if (ieee_buffer_emptyp (&info->global_types))
4752 if (! ieee_change_buffer (info, &info->global_types)
4753 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4754 || ! ieee_write_byte (info, 2)
4755 || ! ieee_write_number (info, 0)
4756 || ! ieee_write_id (info, ""))
4764 if (! ieee_change_buffer (info, &info->global_types))
4771 name_indx = info->name_indx;
4773 if (! ieee_write_byte (info, (int) ieee_nn_record)
4774 || ! ieee_write_number (info, name_indx)
4775 || ! ieee_write_id (info, nt->type.name)
4776 || ! ieee_write_byte (info, (int) ieee_ty_record_enum)
4777 || ! ieee_write_number (info, nt->type.indx)
4778 || ! ieee_write_byte (info, 0xce)
4779 || ! ieee_write_number (info, name_indx))
4791 case DEBUG_KIND_STRUCT:
4792 case DEBUG_KIND_CLASS:
4795 case DEBUG_KIND_UNION:
4796 case DEBUG_KIND_UNION_CLASS:
4799 case DEBUG_KIND_ENUM:
4803 if (! ieee_write_number (info, code)
4804 || ! ieee_write_number (info, 0))
4814 /* Start writing out information for a compilation unit. */
4817 ieee_start_compilation_unit (void *p, const char *filename)
4819 struct ieee_handle *info = (struct ieee_handle *) p;
4820 const char *modname;
4821 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4822 const char *backslash;
4827 if (info->filename != NULL)
4829 if (! ieee_finish_compilation_unit (info))
4833 info->filename = filename;
4834 modname = strrchr (filename, '/');
4835 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4836 /* We could have a mixed forward/back slash case. */
4837 backslash = strrchr (filename, '\\');
4838 if (modname == NULL || (backslash != NULL && backslash > modname))
4839 modname = backslash;
4842 if (modname != NULL)
4844 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4845 else if (filename[0] && filename[1] == ':')
4846 modname = filename + 2;
4851 c = xstrdup (modname);
4852 s = strrchr (c, '.');
4857 if (! ieee_init_buffer (info, &info->types)
4858 || ! ieee_init_buffer (info, &info->vars)
4859 || ! ieee_init_buffer (info, &info->cxx)
4860 || ! ieee_init_buffer (info, &info->linenos))
4862 info->ranges = NULL;
4864 /* Always include a BB1 and a BB3 block. That is what the output of
4865 the MRI linker seems to look like. */
4866 if (! ieee_change_buffer (info, &info->types)
4867 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4868 || ! ieee_write_byte (info, 1)
4869 || ! ieee_write_number (info, 0)
4870 || ! ieee_write_id (info, info->modname))
4873 nindx = 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))
4885 /* Finish up a compilation unit. */
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))
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))
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))
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))
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))
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))
4941 if (strcmp (info->filename, info->lineno_filename) != 0)
4943 /* We were not in the main file. We just closed the
4944 included line number block, and now we must close the
4945 main line number block. */
4946 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
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))
4956 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4957 if (! ieee_change_buffer (info, &info->data))
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"))
4969 for (r = info->ranges; r != NULL; r = r->next)
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)))
4989 /* Just ignore this range. */
4993 /* Coalesce ranges if it seems reasonable. */
4994 while (r->next != NULL
4995 && high + 0x1000 >= r->next->low
4997 <= (bfd_get_section_vma (info->abfd, s)
4998 + bfd_section_size (info->abfd, s))))
5004 if ((s->flags & SEC_CODE) != 0)
5006 else if ((s->flags & SEC_READONLY) != 0)
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))
5022 /* Add this range to the list of global ranges. */
5023 if (! ieee_add_range (info, TRUE, low, high))
5027 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
5033 /* Add BB11 blocks describing each range that we have not already
5037 ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data)
5039 struct ieee_handle *info = (struct ieee_handle *) data;
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)
5054 if (r == NULL || r->low >= high)
5056 if (! ieee_add_bb11 (info, sec, low, high))
5062 && r->low - low > 0x100)
5064 if (! ieee_add_bb11 (info, sec, low, r->low))
5076 /* Add a single BB11 block for a range. We add it to info->vars. */
5079 ieee_add_bb11 (struct ieee_handle *info, asection *sec, bfd_vma low,
5084 if (! ieee_buffer_emptyp (&info->vars))
5086 if (! ieee_change_buffer (info, &info->vars))
5091 const char *filename, *modname;
5092 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5093 const char *backslash;
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;
5106 if (modname != NULL)
5108 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5109 else if (filename[0] && filename[1] == ':')
5110 modname = filename + 2;
5115 c = xstrdup (modname);
5116 s = strrchr (c, '.');
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"))
5133 if ((sec->flags & SEC_CODE) != 0)
5135 else if ((sec->flags & SEC_READONLY) != 0)
5140 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
5141 || ! ieee_write_byte (info, 11)
5142 || ! ieee_write_number (info, 0)
5143 || ! ieee_write_id (info, "")
5144 || ! ieee_write_number (info, kind)
5145 || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
5146 || ! ieee_write_number (info, low)
5147 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
5148 || ! ieee_write_number (info, high - low))
5154 /* Start recording information from a particular source file. This is
5155 used to record which file defined which types, variables, etc. It
5156 is not used for line numbers, since the lineno entry point passes
5157 down the file name anyhow. IEEE debugging information doesn't seem
5158 to store this information anywhere. */
5161 ieee_start_source (void *p ATTRIBUTE_UNUSED,
5162 const char *filename ATTRIBUTE_UNUSED)
5167 /* Make an empty type. */
5170 ieee_empty_type (void *p)
5172 struct ieee_handle *info = (struct ieee_handle *) p;
5174 return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
5177 /* Make a void type. */
5180 ieee_void_type (void *p)
5182 struct ieee_handle *info = (struct ieee_handle *) p;
5184 return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
5187 /* Make an integer type. */
5190 ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
5192 struct ieee_handle *info = (struct ieee_handle *) p;
5198 indx = (int) builtin_signed_char;
5201 indx = (int) builtin_signed_short_int;
5204 indx = (int) builtin_signed_long;
5207 indx = (int) builtin_signed_long_long;
5210 fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
5217 return ieee_push_type (info, indx, size, unsignedp, FALSE);
5220 /* Make a floating point type. */
5223 ieee_float_type (void *p, unsigned int size)
5225 struct ieee_handle *info = (struct ieee_handle *) p;
5231 indx = (int) builtin_float;
5234 indx = (int) builtin_double;
5237 /* FIXME: This size really depends upon the processor. */
5238 indx = (int) builtin_long_double;
5241 indx = (int) builtin_long_long_double;
5244 fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
5248 return ieee_push_type (info, indx, size, FALSE, FALSE);
5251 /* Make a complex type. */
5254 ieee_complex_type (void *p, unsigned int size)
5256 struct ieee_handle *info = (struct ieee_handle *) p;
5262 if (info->complex_float_index != 0)
5263 return ieee_push_type (info, info->complex_float_index, size * 2,
5269 /* These cases can be output by gcc -gstabs. Outputting the
5270 wrong type is better than crashing. */
5272 if (info->complex_double_index != 0)
5273 return ieee_push_type (info, info->complex_double_index, size * 2,
5278 fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
5282 /* FIXME: I don't know what the string is for. */
5283 if (! ieee_define_type (info, size * 2, FALSE, FALSE)
5284 || ! ieee_write_number (info, code)
5285 || ! ieee_write_id (info, ""))
5289 info->complex_float_index = info->type_stack->type.indx;
5291 info->complex_double_index = info->type_stack->type.indx;
5296 /* Make a boolean type. IEEE doesn't support these, so we just make
5297 an integer type instead. */
5300 ieee_bool_type (void *p, unsigned int size)
5302 return ieee_int_type (p, size, TRUE);
5305 /* Make an enumeration. */
5308 ieee_enum_type (void *p, const char *tag, const char **names,
5309 bfd_signed_vma *vals)
5311 struct ieee_handle *info = (struct ieee_handle *) p;
5312 struct ieee_defined_enum *e;
5313 bfd_boolean localp, simple;
5318 indx = (unsigned int) -1;
5319 for (e = info->enums; e != NULL; e = e->next)
5329 || tag[0] != e->tag[0]
5330 || strcmp (tag, e->tag) != 0)
5336 /* This enum tag has been seen but not defined. */
5341 if (names != NULL && e->names != NULL)
5343 for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
5345 if (names[i][0] != e->names[i][0]
5346 || vals[i] != e->vals[i]
5347 || strcmp (names[i], e->names[i]) != 0)
5352 if ((names == NULL && e->names == NULL)
5356 && e->names[i] == NULL))
5358 /* We've seen this enum before. */
5359 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
5364 /* We've already seen an enum of the same name, so we must make
5365 sure to output this one locally. */
5371 /* If this is a simple enumeration, in which the values start at 0
5372 and always increment by 1, we can use type E. Otherwise we must
5378 for (i = 0; names[i] != NULL; i++)
5388 if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
5389 (struct ieee_buflist *) NULL)
5390 || ! ieee_write_number (info, simple ? 'E' : 'N'))
5394 /* FIXME: This is supposed to be the enumeration size, but we
5395 don't store that. */
5396 if (! ieee_write_number (info, 4))
5401 for (i = 0; names[i] != NULL; i++)
5403 if (! ieee_write_id (info, names[i]))
5407 if (! ieee_write_number (info, vals[i]))
5415 if (indx == (unsigned int) -1)
5417 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
5418 memset (e, 0, sizeof *e);
5419 e->indx = info->type_stack->type.indx;
5422 e->next = info->enums;
5434 /* Make a pointer type. */
5437 ieee_pointer_type (void *p)
5439 struct ieee_handle *info = (struct ieee_handle *) p;
5442 struct ieee_modified_type *m = NULL;
5444 localp = info->type_stack->type.localp;
5445 indx = ieee_pop_type (info);
5447 /* A pointer to a simple builtin type can be obtained by adding 32.
5448 FIXME: Will this be a short pointer, and will that matter? */
5450 return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);
5454 m = ieee_get_modified_info (p, indx);
5458 /* FIXME: The size should depend upon the architecture. */
5460 return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
5463 if (! ieee_define_type (info, 4, TRUE, localp)
5464 || ! ieee_write_number (info, 'P')
5465 || ! ieee_write_number (info, indx))
5469 m->pointer = info->type_stack->type.indx;
5474 /* Make a function type. This will be called for a method, but we
5475 don't want to actually add it to the type table in that case. We
5476 handle this by defining the type in a private buffer, and only
5477 adding that buffer to the typedef block if we are going to use it. */
5480 ieee_function_type (void *p, int argcount, bfd_boolean varargs)
5482 struct ieee_handle *info = (struct ieee_handle *) p;
5484 unsigned int *args = NULL;
5486 unsigned int retindx;
5487 struct ieee_buflist fndef;
5488 struct ieee_modified_type *m;
5494 args = (unsigned int *) xmalloc (argcount * sizeof *args);
5495 for (i = argcount - 1; i >= 0; i--)
5497 if (info->type_stack->type.localp)
5499 args[i] = ieee_pop_type (info);
5502 else if (argcount < 0)
5505 if (info->type_stack->type.localp)
5507 retindx = ieee_pop_type (info);
5510 if (argcount < 0 && ! localp)
5512 m = ieee_get_modified_info (p, retindx);
5516 if (m->function > 0)
5517 return ieee_push_type (info, m->function, 0, TRUE, FALSE);
5520 /* An attribute of 0x41 means that the frame and push mask are
5522 if (! ieee_init_buffer (info, &fndef)
5523 || ! ieee_define_named_type (info, (const char *) NULL,
5524 (unsigned int) -1, 0, TRUE, localp,
5526 || ! ieee_write_number (info, 'x')
5527 || ! ieee_write_number (info, 0x41)
5528 || ! ieee_write_number (info, 0)
5529 || ! ieee_write_number (info, 0)
5530 || ! ieee_write_number (info, retindx)
5531 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
5535 for (i = 0; i < argcount; i++)
5536 if (! ieee_write_number (info, args[i]))
5542 /* A varargs function is represented by writing out the last
5543 argument as type void *, although this makes little sense. */
5544 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
5548 if (! ieee_write_number (info, 0))
5551 /* We wrote the information into fndef, in case we don't need it.
5552 It will be appended to info->types by ieee_pop_type. */
5553 info->type_stack->type.fndef = fndef;
5556 m->function = info->type_stack->type.indx;
5561 /* Make a reference type. */
5564 ieee_reference_type (void *p)
5566 struct ieee_handle *info = (struct ieee_handle *) p;
5568 /* IEEE appears to record a normal pointer type, and then use a
5569 pmisc record to indicate that it is really a reference. */
5571 if (! ieee_pointer_type (p))
5573 info->type_stack->type.referencep = TRUE;
5577 /* Make a range type. */
5580 ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
5582 struct ieee_handle *info = (struct ieee_handle *) p;
5584 bfd_boolean unsignedp, localp;
5586 size = info->type_stack->type.size;
5587 unsignedp = info->type_stack->type.unsignedp;
5588 localp = info->type_stack->type.localp;
5589 ieee_pop_unused_type (info);
5590 return (ieee_define_type (info, size, unsignedp, localp)
5591 && ieee_write_number (info, 'R')
5592 && ieee_write_number (info, (bfd_vma) low)
5593 && ieee_write_number (info, (bfd_vma) high)
5594 && ieee_write_number (info, unsignedp ? 0 : 1)
5595 && ieee_write_number (info, size));
5598 /* Make an array type. */
5601 ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
5602 bfd_boolean stringp ATTRIBUTE_UNUSED)
5604 struct ieee_handle *info = (struct ieee_handle *) p;
5605 unsigned int eleindx;
5608 struct ieee_modified_type *m = NULL;
5609 struct ieee_modified_array_type *a;
5611 /* IEEE does not store the range, so we just ignore it. */
5612 ieee_pop_unused_type (info);
5613 localp = info->type_stack->type.localp;
5614 size = info->type_stack->type.size;
5615 eleindx = ieee_pop_type (info);
5617 /* If we don't know the range, treat the size as exactly one
5620 size *= (high - low) + 1;
5624 m = ieee_get_modified_info (info, eleindx);
5628 for (a = m->arrays; a != NULL; a = a->next)
5630 if (a->low == low && a->high == high)
5631 return ieee_push_type (info, a->indx, size, FALSE, FALSE);
5635 if (! ieee_define_type (info, size, FALSE, localp)
5636 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
5637 || ! ieee_write_number (info, eleindx))
5641 if (! ieee_write_number (info, low))
5645 if (! ieee_write_number (info, high + 1))
5650 a = (struct ieee_modified_array_type *) xmalloc (sizeof *a);
5651 memset (a, 0, sizeof *a);
5653 a->indx = info->type_stack->type.indx;
5657 a->next = m->arrays;
5664 /* Make a set type. */
5667 ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
5669 struct ieee_handle *info = (struct ieee_handle *) p;
5671 unsigned int eleindx;
5673 localp = info->type_stack->type.localp;
5674 eleindx = ieee_pop_type (info);
5676 /* FIXME: We don't know the size, so we just use 4. */
5678 return (ieee_define_type (info, 0, TRUE, localp)
5679 && ieee_write_number (info, 's')
5680 && ieee_write_number (info, 4)
5681 && ieee_write_number (info, eleindx));
5684 /* Make an offset type. */
5687 ieee_offset_type (void *p)
5689 struct ieee_handle *info = (struct ieee_handle *) p;
5690 unsigned int targetindx, baseindx;
5692 targetindx = ieee_pop_type (info);
5693 baseindx = ieee_pop_type (info);
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. */
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'
5718 ieee_pop_unused_type (info);
5720 return ieee_function_type (p, argcount, varargs);
5723 /* Make a const qualified type. */
5726 ieee_const_type (void *p)
5728 struct ieee_handle *info = (struct ieee_handle *) p;
5730 bfd_boolean unsignedp, localp;
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);
5741 m = ieee_get_modified_info (info, indx);
5745 if (m->const_qualified > 0)
5746 return ieee_push_type (info, m->const_qualified, size, unsignedp,
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))
5757 m->const_qualified = info->type_stack->type.indx;
5762 /* Make a volatile qualified type. */
5765 ieee_volatile_type (void *p)
5767 struct ieee_handle *info = (struct ieee_handle *) p;
5769 bfd_boolean unsignedp, localp;
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);
5780 m = ieee_get_modified_info (info, indx);
5784 if (m->volatile_qualified > 0)
5785 return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
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))
5796 m->volatile_qualified = info->type_stack->type.indx;
5801 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5804 ieee_vis_to_flags (enum debug_visibility visibility)
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;
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. */
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;
5833 struct ieee_name_type_hash_entry *h;
5834 struct ieee_name_type *nt, *ntlook;
5835 struct ieee_buflist strdef;
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
5850 sprintf (ab, "__anon%u", id);
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);
5862 for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
5864 if (ntlook->id == id)
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
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. */
5887 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5888 memset (nt, 0, sizeof *nt);
5890 nt->type.name = h->root.string;
5891 nt->next = h->types;
5893 nt->type.indx = 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,
5902 || ! ieee_write_number (info, structp ? 'S' : 'U')
5903 || ! ieee_write_number (info, size))
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;
5925 /* Add a field to a struct. */
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;
5933 bfd_boolean unsignedp;
5934 bfd_boolean referencep;
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
5945 if (info->type_stack->next->type.ignorep)
5947 ieee_pop_unused_type (info);
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);
5958 info->type_stack->type.localp = TRUE;
5960 if (info->type_stack->type.classdef != NULL)
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))
5977 info->type_stack->type.classdef->pmisccount += 4;
5983 /* We need to output a record recording that this field is
5984 really of reference type. We put this on the refs field
5985 of classdef, so that it can be appended to the C++
5986 records after the class is defined. */
5988 nindx = info->name_indx;
5991 if (! ieee_change_buffer (info,
5992 &info->type_stack->type.classdef->refs)
5993 || ! ieee_write_byte (info, (int) ieee_nn_record)
5994 || ! ieee_write_number (info, nindx)
5995 || ! ieee_write_id (info, "")
5996 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5997 || ! ieee_write_number (info, nindx)
5998 || ! ieee_write_number (info, 0)
5999 || ! ieee_write_number (info, 62)
6000 || ! ieee_write_number (info, 80)
6001 || ! ieee_write_number (info, 4)
6002 || ! ieee_write_asn (info, nindx, 'R')
6003 || ! ieee_write_asn (info, nindx, 3)
6004 || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
6005 || ! ieee_write_atn65 (info, nindx, name))
6010 /* If the bitsize doesn't match the expected size, we need to output
6012 if (size == 0 || bitsize == 0 || bitsize == size * 8)
6013 offset = bitpos / 8;
6016 if (! ieee_define_type (info, 0, unsignedp,
6017 info->type_stack->type.localp)
6018 || ! ieee_write_number (info, 'g')
6019 || ! ieee_write_number (info, unsignedp ? 0 : 1)
6020 || ! ieee_write_number (info, bitsize)
6021 || ! ieee_write_number (info, indx))
6023 indx = ieee_pop_type (info);
6027 /* Switch to the struct we are building in order to output this
6028 field definition. */
6029 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
6030 && ieee_write_id (info, name)
6031 && ieee_write_number (info, indx)
6032 && ieee_write_number (info, offset));
6035 /* Finish up a struct type. */
6038 ieee_end_struct_type (void *p)
6040 struct ieee_handle *info = (struct ieee_handle *) p;
6041 struct ieee_buflist *pb;
6043 assert (info->type_stack != NULL
6044 && ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
6046 /* If we were ignoring this struct definition because it was a
6047 duplicate definition, just through away whatever bytes we have
6048 accumulated. Leave the type on the stack. */
6049 if (info->type_stack->type.ignorep)
6052 /* If this is not a duplicate definition of this tag, then localp
6053 will be FALSE, and we can put it in the global type block.
6054 FIXME: We should avoid outputting duplicate definitions which are
6056 if (! info->type_stack->type.localp)
6058 /* Make sure we have started the global type block. */
6059 if (ieee_buffer_emptyp (&info->global_types))
6061 if (! ieee_change_buffer (info, &info->global_types)
6062 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6063 || ! ieee_write_byte (info, 2)
6064 || ! ieee_write_number (info, 0)
6065 || ! ieee_write_id (info, ""))
6068 pb = &info->global_types;
6072 /* Make sure we have started the types block. */
6073 if (ieee_buffer_emptyp (&info->types))
6075 if (! ieee_change_buffer (info, &info->types)
6076 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6077 || ! ieee_write_byte (info, 1)
6078 || ! ieee_write_number (info, 0)
6079 || ! ieee_write_id (info, info->modname))
6085 /* Append the struct definition to the types. */
6086 if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
6087 || ! ieee_init_buffer (info, &info->type_stack->type.strdef))
6090 /* Leave the struct on the type stack. */
6095 /* Start a class type. */
6098 ieee_start_class_type (void *p, const char *tag, unsigned int id,
6099 bfd_boolean structp, unsigned int size,
6100 bfd_boolean vptr, bfd_boolean ownvptr)
6102 struct ieee_handle *info = (struct ieee_handle *) p;
6104 struct ieee_buflist pmiscbuf;
6106 struct ieee_type_class *classdef;
6108 /* A C++ class is output as a C++ struct along with a set of pmisc
6109 records describing the class. */
6111 /* We need to have a name so that we can associate the struct and
6117 t = (char *) xmalloc (20);
6118 sprintf (t, "__anon%u", id);
6122 /* We can't write out the virtual table information until we have
6123 finished the class, because we don't know the virtual table size.
6124 We get the size from the largest voffset we see. */
6126 if (vptr && ! ownvptr)
6128 vclass = info->type_stack->type.name;
6129 assert (vclass != NULL);
6130 /* We don't call ieee_pop_unused_type, since the class should
6132 (void) ieee_pop_type (info);
6135 if (! ieee_start_struct_type (p, tag, id, structp, size))
6138 indx = info->name_indx;
6141 /* We write out pmisc records into the classdef field. We will
6142 write out the pmisc start after we know the number of records we
6144 if (! ieee_init_buffer (info, &pmiscbuf)
6145 || ! ieee_change_buffer (info, &pmiscbuf)
6146 || ! ieee_write_asn (info, indx, 'T')
6147 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
6148 || ! ieee_write_atn65 (info, indx, tag))
6151 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
6152 memset (classdef, 0, sizeof *classdef);
6154 classdef->indx = indx;
6155 classdef->pmiscbuf = pmiscbuf;
6156 classdef->pmisccount = 3;
6157 classdef->vclass = vclass;
6158 classdef->ownvptr = ownvptr;
6160 info->type_stack->type.classdef = classdef;
6165 /* Add a static member to a class. */
6168 ieee_class_static_member (void *p, const char *name, const char *physname,
6169 enum debug_visibility visibility)
6171 struct ieee_handle *info = (struct ieee_handle *) p;
6175 /* We don't care about the type. Hopefully there will be a call to
6176 ieee_variable declaring the physical name and the type, since
6177 that is where an IEEE consumer must get the type. */
6178 ieee_pop_unused_type (info);
6180 assert (info->type_stack != NULL
6181 && info->type_stack->type.classdef != NULL);
6183 flags = ieee_vis_to_flags (visibility);
6184 flags |= CXXFLAGS_STATIC;
6186 nindx = info->type_stack->type.classdef->indx;
6188 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6189 || ! ieee_write_asn (info, nindx, 'd')
6190 || ! ieee_write_asn (info, nindx, flags)
6191 || ! ieee_write_atn65 (info, nindx, name)
6192 || ! ieee_write_atn65 (info, nindx, physname))
6194 info->type_stack->type.classdef->pmisccount += 4;
6199 /* Add a base class to a class. */
6202 ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual,
6203 enum debug_visibility visibility)
6205 struct ieee_handle *info = (struct ieee_handle *) p;
6213 assert (info->type_stack != NULL
6214 && info->type_stack->type.name != NULL
6215 && info->type_stack->next != NULL
6216 && info->type_stack->next->type.classdef != NULL
6217 && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
6219 bname = info->type_stack->type.name;
6220 localp = info->type_stack->type.localp;
6221 bindx = ieee_pop_type (info);
6223 /* We are currently defining both a struct and a class. We must
6224 write out a field definition in the struct which holds the base
6225 class. The stabs debugging reader will create a field named
6226 _vb$CLASS for a virtual base class, so we just use that. FIXME:
6227 we should not depend upon a detail of stabs debugging. */
6230 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
6231 sprintf (fname, "_vb$%s", bname);
6232 flags = BASEFLAGS_VIRTUAL;
6237 info->type_stack->type.localp = TRUE;
6239 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
6240 sprintf (fname, "_b$%s", bname);
6242 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
6243 || ! ieee_write_id (info, fname)
6244 || ! ieee_write_number (info, bindx)
6245 || ! ieee_write_number (info, bitpos / 8))
6250 if (visibility == DEBUG_VISIBILITY_PRIVATE)
6251 flags |= BASEFLAGS_PRIVATE;
6253 nindx = info->type_stack->type.classdef->indx;
6255 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
6256 || ! ieee_write_asn (info, nindx, 'b')
6257 || ! ieee_write_asn (info, nindx, flags)
6258 || ! ieee_write_atn65 (info, nindx, bname)
6259 || ! ieee_write_asn (info, nindx, 0)
6260 || ! ieee_write_atn65 (info, nindx, fname))
6262 info->type_stack->type.classdef->pmisccount += 5;
6269 /* Start building a method for a class. */
6272 ieee_class_start_method (void *p, const char *name)
6274 struct ieee_handle *info = (struct ieee_handle *) p;
6276 assert (info->type_stack != NULL
6277 && info->type_stack->type.classdef != NULL
6278 && info->type_stack->type.classdef->method == NULL);
6280 info->type_stack->type.classdef->method = name;
6285 /* Define a new method variant, either static or not. */
6288 ieee_class_method_var (struct ieee_handle *info, const char *physname,
6289 enum debug_visibility visibility,
6290 bfd_boolean staticp, bfd_boolean constp,
6291 bfd_boolean volatilep, bfd_vma voffset,
6292 bfd_boolean context)
6296 bfd_boolean virtual;
6298 /* We don't need the type of the method. An IEEE consumer which
6299 wants the type must track down the function by the physical name
6300 and get the type from that. */
6301 ieee_pop_unused_type (info);
6303 /* We don't use the context. FIXME: We probably ought to use it to
6304 adjust the voffset somehow, but I don't really know how. */
6306 ieee_pop_unused_type (info);
6308 assert (info->type_stack != NULL
6309 && info->type_stack->type.classdef != NULL
6310 && info->type_stack->type.classdef->method != NULL);
6312 flags = ieee_vis_to_flags (visibility);
6314 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
6315 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
6318 flags |= CXXFLAGS_STATIC;
6320 flags |= CXXFLAGS_CONST;
6322 flags |= CXXFLAGS_VOLATILE;
6324 nindx = info->type_stack->type.classdef->indx;
6326 virtual = context || voffset > 0;
6328 if (! ieee_change_buffer (info,
6329 &info->type_stack->type.classdef->pmiscbuf)
6330 || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm')
6331 || ! ieee_write_asn (info, nindx, flags)
6332 || ! ieee_write_atn65 (info, nindx,
6333 info->type_stack->type.classdef->method)
6334 || ! ieee_write_atn65 (info, nindx, physname))
6339 if (voffset > info->type_stack->type.classdef->voffset)
6340 info->type_stack->type.classdef->voffset = voffset;
6341 if (! ieee_write_asn (info, nindx, voffset))
6343 ++info->type_stack->type.classdef->pmisccount;
6346 if (! ieee_write_asn (info, nindx, 0))
6349 info->type_stack->type.classdef->pmisccount += 5;
6354 /* Define a new method variant. */
6357 ieee_class_method_variant (void *p, const char *physname,
6358 enum debug_visibility visibility,
6359 bfd_boolean constp, bfd_boolean volatilep,
6360 bfd_vma voffset, bfd_boolean context)
6362 struct ieee_handle *info = (struct ieee_handle *) p;
6364 return ieee_class_method_var (info, physname, visibility, FALSE, constp,
6365 volatilep, voffset, context);
6368 /* Define a new static method variant. */
6371 ieee_class_static_method_variant (void *p, const char *physname,
6372 enum debug_visibility visibility,
6373 bfd_boolean constp, bfd_boolean volatilep)
6375 struct ieee_handle *info = (struct ieee_handle *) p;
6377 return ieee_class_method_var (info, physname, visibility, TRUE, constp,
6378 volatilep, 0, FALSE);
6381 /* Finish up a method. */
6384 ieee_class_end_method (void *p)
6386 struct ieee_handle *info = (struct ieee_handle *) p;
6388 assert (info->type_stack != NULL
6389 && info->type_stack->type.classdef != NULL
6390 && info->type_stack->type.classdef->method != NULL);
6392 info->type_stack->type.classdef->method = NULL;
6397 /* Finish up a class. */
6400 ieee_end_class_type (void *p)
6402 struct ieee_handle *info = (struct ieee_handle *) p;
6405 assert (info->type_stack != NULL
6406 && info->type_stack->type.classdef != NULL);
6408 /* If we were ignoring this class definition because it was a
6409 duplicate definition, just through away whatever bytes we have
6410 accumulated. Leave the type on the stack. */
6411 if (info->type_stack->type.ignorep)
6414 nindx = info->type_stack->type.classdef->indx;
6416 /* If we have a virtual table, we can write out the information now. */
6417 if (info->type_stack->type.classdef->vclass != NULL
6418 || info->type_stack->type.classdef->ownvptr)
6420 if (! ieee_change_buffer (info,
6421 &info->type_stack->type.classdef->pmiscbuf)
6422 || ! ieee_write_asn (info, nindx, 'z')
6423 || ! ieee_write_atn65 (info, nindx, "")
6424 || ! ieee_write_asn (info, nindx,
6425 info->type_stack->type.classdef->voffset))
6427 if (info->type_stack->type.classdef->ownvptr)
6429 if (! ieee_write_atn65 (info, nindx, ""))
6434 if (! ieee_write_atn65 (info, nindx,
6435 info->type_stack->type.classdef->vclass))
6438 if (! ieee_write_asn (info, nindx, 0))
6440 info->type_stack->type.classdef->pmisccount += 5;
6443 /* Now that we know the number of pmisc records, we can write out
6444 the atn62 which starts the pmisc records, and append them to the
6447 if (! ieee_change_buffer (info, &info->cxx)
6448 || ! ieee_write_byte (info, (int) ieee_nn_record)
6449 || ! ieee_write_number (info, nindx)
6450 || ! ieee_write_id (info, "")
6451 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6452 || ! ieee_write_number (info, nindx)
6453 || ! ieee_write_number (info, 0)
6454 || ! ieee_write_number (info, 62)
6455 || ! ieee_write_number (info, 80)
6456 || ! ieee_write_number (info,
6457 info->type_stack->type.classdef->pmisccount))
6460 if (! ieee_append_buffer (info, &info->cxx,
6461 &info->type_stack->type.classdef->pmiscbuf))
6463 if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
6465 if (! ieee_append_buffer (info, &info->cxx,
6466 &info->type_stack->type.classdef->refs))
6470 return ieee_end_struct_type (p);
6473 /* Push a previously seen typedef onto the type stack. */
6476 ieee_typedef_type (void *p, const char *name)
6478 struct ieee_handle *info = (struct ieee_handle *) p;
6479 struct ieee_name_type_hash_entry *h;
6480 struct ieee_name_type *nt;
6482 h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);
6484 /* h should never be NULL, since that would imply that the generic
6485 debugging code has asked for a typedef which it has not yet
6489 /* We always use the most recently defined type for this name, which
6490 will be the first one on the list. */
6493 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6494 nt->type.unsignedp, nt->type.localp))
6497 /* Copy over any other type information we may have. */
6498 info->type_stack->type = nt->type;
6503 /* Push a tagged type onto the type stack. */
6506 ieee_tag_type (void *p, const char *name, unsigned int id,
6507 enum debug_type_kind kind)
6509 struct ieee_handle *info = (struct ieee_handle *) p;
6513 struct ieee_name_type_hash_entry *h;
6514 struct ieee_name_type *nt;
6516 if (kind == DEBUG_KIND_ENUM)
6518 struct ieee_defined_enum *e;
6522 for (e = info->enums; e != NULL; e = e->next)
6523 if (e->tag != NULL && strcmp (e->tag, name) == 0)
6524 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6526 e = (struct ieee_defined_enum *) xmalloc (sizeof *e);
6527 memset (e, 0, sizeof *e);
6529 e->indx = info->type_indx;
6534 e->next = info->enums;
6537 return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
6545 sprintf (ab, "__anon%u", id);
6550 h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
6554 for (nt = h->types; nt != NULL; nt = nt->next)
6558 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
6559 nt->type.unsignedp, nt->type.localp))
6561 /* Copy over any other type information we may have. */
6562 info->type_stack->type = nt->type;
6566 if (! nt->type.localp)
6568 /* This is a duplicate of a global type, so it must be
6574 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6575 memset (nt, 0, sizeof *nt);
6578 nt->type.name = h->root.string;
6579 nt->type.indx = info->type_indx;
6580 nt->type.localp = localp;
6584 nt->next = h->types;
6587 if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
6590 info->type_stack->type.name = h->root.string;
6595 /* Output a typedef. */
6598 ieee_typdef (void *p, const char *name)
6600 struct ieee_handle *info = (struct ieee_handle *) p;
6601 struct ieee_write_type type;
6605 struct ieee_name_type_hash_entry *h;
6606 struct ieee_name_type *nt;
6608 type = info->type_stack->type;
6611 /* If this is a simple builtin type using a builtin name, we don't
6612 want to output the typedef itself. We also want to change the
6613 type index to correspond to the name being used. We recognize
6614 names used in stabs debugging output even if they don't exactly
6615 correspond to the names used for the IEEE builtin types. */
6617 if (indx <= (unsigned int) builtin_bcd_float)
6619 switch ((enum builtin_types) indx)
6625 if (strcmp (name, "void") == 0)
6629 case builtin_signed_char:
6631 if (strcmp (name, "signed char") == 0)
6633 indx = (unsigned int) builtin_signed_char;
6636 else if (strcmp (name, "char") == 0)
6638 indx = (unsigned int) builtin_char;
6643 case builtin_unsigned_char:
6644 if (strcmp (name, "unsigned char") == 0)
6648 case builtin_signed_short_int:
6650 case builtin_short_int:
6651 case builtin_signed_short:
6652 if (strcmp (name, "signed short int") == 0)
6654 indx = (unsigned int) builtin_signed_short_int;
6657 else if (strcmp (name, "short") == 0)
6659 indx = (unsigned int) builtin_short;
6662 else if (strcmp (name, "short int") == 0)
6664 indx = (unsigned int) builtin_short_int;
6667 else if (strcmp (name, "signed short") == 0)
6669 indx = (unsigned int) builtin_signed_short;
6674 case builtin_unsigned_short_int:
6675 case builtin_unsigned_short:
6676 if (strcmp (name, "unsigned short int") == 0
6677 || strcmp (name, "short unsigned int") == 0)
6679 indx = builtin_unsigned_short_int;
6682 else if (strcmp (name, "unsigned short") == 0)
6684 indx = builtin_unsigned_short;
6689 case builtin_signed_long:
6690 case builtin_int: /* FIXME: Size depends upon architecture. */
6692 if (strcmp (name, "signed long") == 0)
6694 indx = builtin_signed_long;
6697 else if (strcmp (name, "int") == 0)
6702 else if (strcmp (name, "long") == 0
6703 || strcmp (name, "long int") == 0)
6705 indx = builtin_long;
6710 case builtin_unsigned_long:
6711 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
6712 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
6713 if (strcmp (name, "unsigned long") == 0
6714 || strcmp (name, "long unsigned int") == 0)
6716 indx = builtin_unsigned_long;
6719 else if (strcmp (name, "unsigned") == 0)
6721 indx = builtin_unsigned;
6724 else if (strcmp (name, "unsigned int") == 0)
6726 indx = builtin_unsigned_int;
6731 case builtin_signed_long_long:
6732 if (strcmp (name, "signed long long") == 0
6733 || strcmp (name, "long long int") == 0)
6737 case builtin_unsigned_long_long:
6738 if (strcmp (name, "unsigned long long") == 0
6739 || strcmp (name, "long long unsigned int") == 0)
6744 if (strcmp (name, "float") == 0)
6748 case builtin_double:
6749 if (strcmp (name, "double") == 0)
6753 case builtin_long_double:
6754 if (strcmp (name, "long double") == 0)
6758 case builtin_long_long_double:
6759 if (strcmp (name, "long long double") == 0)
6768 h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
6772 /* See if we have already defined this type with this name. */
6773 localp = type.localp;
6774 for (nt = h->types; nt != NULL; nt = nt->next)
6778 /* If this is a global definition, then we don't need to
6779 do anything here. */
6780 if (! nt->type.localp)
6782 ieee_pop_unused_type (info);
6788 /* This is a duplicate definition, so make this one local. */
6793 /* We need to add a new typedef for this type. */
6795 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
6796 memset (nt, 0, sizeof *nt);
6799 nt->type.name = name;
6800 nt->type.localp = localp;
6801 nt->kind = DEBUG_KIND_ILLEGAL;
6803 nt->next = h->types;
6808 /* This is one of the builtin typedefs, so we don't need to
6809 actually define it. */
6810 ieee_pop_unused_type (info);
6814 indx = ieee_pop_type (info);
6816 if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
6817 type.unsignedp, localp,
6818 (struct ieee_buflist *) NULL)
6819 || ! ieee_write_number (info, 'T')
6820 || ! ieee_write_number (info, indx))
6823 /* Remove the type we just added to the type stack. This should not
6824 be ieee_pop_unused_type, since the type is used, we just don't
6826 (void) ieee_pop_type (info);
6831 /* Output a tag for a type. We don't have to do anything here. */
6834 ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED)
6836 struct ieee_handle *info = (struct ieee_handle *) p;
6838 /* This should not be ieee_pop_unused_type, since we want the type
6840 (void) ieee_pop_type (info);
6844 /* Output an integer constant. */
6847 ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED,
6848 bfd_vma val ATTRIBUTE_UNUSED)
6854 /* Output a floating point constant. */
6857 ieee_float_constant (void *p ATTRIBUTE_UNUSED,
6858 const char *name ATTRIBUTE_UNUSED,
6859 double val ATTRIBUTE_UNUSED)
6865 /* Output a typed constant. */
6868 ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED,
6869 bfd_vma val ATTRIBUTE_UNUSED)
6871 struct ieee_handle *info = (struct ieee_handle *) p;
6874 ieee_pop_unused_type (info);
6878 /* Output a variable. */
6881 ieee_variable (void *p, const char *name, enum debug_var_kind kind,
6884 struct ieee_handle *info = (struct ieee_handle *) p;
6885 unsigned int name_indx;
6887 bfd_boolean referencep;
6888 unsigned int type_indx;
6892 size = info->type_stack->type.size;
6893 referencep = info->type_stack->type.referencep;
6894 type_indx = ieee_pop_type (info);
6896 assert (! ieee_buffer_emptyp (&info->vars));
6897 if (! ieee_change_buffer (info, &info->vars))
6900 name_indx = info->name_indx;
6903 /* Write out an NN and an ATN record for this variable. */
6904 if (! ieee_write_byte (info, (int) ieee_nn_record)
6905 || ! ieee_write_number (info, name_indx)
6906 || ! ieee_write_id (info, name)
6907 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6908 || ! ieee_write_number (info, name_indx)
6909 || ! ieee_write_number (info, type_indx))
6917 if (! ieee_write_number (info, 8)
6918 || ! ieee_add_range (info, FALSE, val, val + size))
6924 if (! ieee_write_number (info, 3)
6925 || ! ieee_add_range (info, FALSE, val, val + size))
6930 case DEBUG_LOCAL_STATIC:
6931 if (! ieee_write_number (info, 3)
6932 || ! ieee_add_range (info, FALSE, val, val + size))
6938 if (! ieee_write_number (info, 1)
6939 || ! ieee_write_number (info, val))
6944 case DEBUG_REGISTER:
6945 if (! ieee_write_number (info, 2)
6946 || ! ieee_write_number (info,
6947 ieee_genreg_to_regno (info->abfd, val)))
6956 if (! ieee_write_asn (info, name_indx, val))
6960 /* If this is really a reference type, then we just output it with
6961 pointer type, and must now output a C++ record indicating that it
6962 is really reference type. */
6967 nindx = info->name_indx;
6970 /* If this is a global variable, we want to output the misc
6971 record in the C++ misc record block. Otherwise, we want to
6972 output it just after the variable definition, which is where
6973 the current buffer is. */
6976 if (! ieee_change_buffer (info, &info->cxx))
6980 if (! ieee_write_byte (info, (int) ieee_nn_record)
6981 || ! ieee_write_number (info, nindx)
6982 || ! ieee_write_id (info, "")
6983 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6984 || ! ieee_write_number (info, nindx)
6985 || ! ieee_write_number (info, 0)
6986 || ! ieee_write_number (info, 62)
6987 || ! ieee_write_number (info, 80)
6988 || ! ieee_write_number (info, 3)
6989 || ! ieee_write_asn (info, nindx, 'R')
6990 || ! ieee_write_asn (info, nindx, refflag)
6991 || ! ieee_write_atn65 (info, nindx, name))
6998 /* Start outputting information for a function. */
7001 ieee_start_function (void *p, const char *name, bfd_boolean global)
7003 struct ieee_handle *info = (struct ieee_handle *) p;
7004 bfd_boolean referencep;
7005 unsigned int retindx, typeindx;
7007 referencep = info->type_stack->type.referencep;
7008 retindx = ieee_pop_type (info);
7010 /* Besides recording a BB4 or BB6 block, we record the type of the
7011 function in the BB1 typedef block. We can't write out the full
7012 type until we have seen all the parameters, so we accumulate it
7013 in info->fntype and info->fnargs. */
7014 if (! ieee_buffer_emptyp (&info->fntype))
7016 /* FIXME: This might happen someday if we support nested
7021 info->fnname = name;
7023 /* An attribute of 0x40 means that the push mask is unknown. */
7024 if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
7026 || ! ieee_write_number (info, 'x')
7027 || ! ieee_write_number (info, 0x40)
7028 || ! ieee_write_number (info, 0)
7029 || ! ieee_write_number (info, 0)
7030 || ! ieee_write_number (info, retindx))
7033 typeindx = ieee_pop_type (info);
7035 if (! ieee_init_buffer (info, &info->fnargs))
7037 info->fnargcount = 0;
7039 /* If the function return value is actually a reference type, we
7040 must add a record indicating that. */
7045 nindx = info->name_indx;
7047 if (! ieee_change_buffer (info, &info->cxx)
7048 || ! ieee_write_byte (info, (int) ieee_nn_record)
7049 || ! ieee_write_number (info, nindx)
7050 || ! ieee_write_id (info, "")
7051 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7052 || ! ieee_write_number (info, nindx)
7053 || ! ieee_write_number (info, 0)
7054 || ! ieee_write_number (info, 62)
7055 || ! ieee_write_number (info, 80)
7056 || ! ieee_write_number (info, 3)
7057 || ! ieee_write_asn (info, nindx, 'R')
7058 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
7059 || ! ieee_write_atn65 (info, nindx, name))
7063 assert (! ieee_buffer_emptyp (&info->vars));
7064 if (! ieee_change_buffer (info, &info->vars))
7067 /* The address is written out as the first block. */
7069 ++info->block_depth;
7071 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
7072 && ieee_write_byte (info, global ? 4 : 6)
7073 && ieee_write_number (info, 0)
7074 && ieee_write_id (info, name)
7075 && ieee_write_number (info, 0)
7076 && ieee_write_number (info, typeindx));
7079 /* Add a function parameter. This will normally be called before the
7080 first block, so we postpone them until we see the block. */
7083 ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
7086 struct ieee_handle *info = (struct ieee_handle *) p;
7087 struct ieee_pending_parm *m, **pm;
7089 assert (info->block_depth == 1);
7091 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
7092 memset (m, 0, sizeof *m);
7096 m->referencep = info->type_stack->type.referencep;
7097 m->type = ieee_pop_type (info);
7101 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
7105 /* Add the type to the fnargs list. */
7106 if (! ieee_change_buffer (info, &info->fnargs)
7107 || ! ieee_write_number (info, m->type))
7114 /* Output pending function parameters. */
7117 ieee_output_pending_parms (struct ieee_handle *info)
7119 struct ieee_pending_parm *m;
7120 unsigned int refcount;
7123 for (m = info->pending_parms; m != NULL; m = m->next)
7125 enum debug_var_kind vkind;
7132 case DEBUG_PARM_STACK:
7133 case DEBUG_PARM_REFERENCE:
7134 vkind = DEBUG_LOCAL;
7136 case DEBUG_PARM_REG:
7137 case DEBUG_PARM_REF_REG:
7138 vkind = DEBUG_REGISTER;
7142 if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
7144 info->type_stack->type.referencep = m->referencep;
7147 if (! ieee_variable ((void *) info, m->name, vkind, m->val))
7151 /* If there are any reference parameters, we need to output a
7152 miscellaneous record indicating them. */
7155 unsigned int nindx, varindx;
7157 /* FIXME: The MRI compiler outputs the demangled function name
7158 here, but we are outputting the mangled name. */
7159 nindx = info->name_indx;
7161 if (! ieee_change_buffer (info, &info->vars)
7162 || ! ieee_write_byte (info, (int) ieee_nn_record)
7163 || ! ieee_write_number (info, nindx)
7164 || ! ieee_write_id (info, "")
7165 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7166 || ! ieee_write_number (info, nindx)
7167 || ! ieee_write_number (info, 0)
7168 || ! ieee_write_number (info, 62)
7169 || ! ieee_write_number (info, 80)
7170 || ! ieee_write_number (info, refcount + 3)
7171 || ! ieee_write_asn (info, nindx, 'B')
7172 || ! ieee_write_atn65 (info, nindx, info->fnname)
7173 || ! ieee_write_asn (info, nindx, 0))
7175 for (m = info->pending_parms, varindx = 1;
7177 m = m->next, varindx++)
7181 if (! ieee_write_asn (info, nindx, varindx))
7187 m = info->pending_parms;
7190 struct ieee_pending_parm *next;
7197 info->pending_parms = NULL;
7202 /* Start a block. If this is the first block, we output the address
7203 to finish the BB4 or BB6, and then output the function parameters. */
7206 ieee_start_block (void *p, bfd_vma addr)
7208 struct ieee_handle *info = (struct ieee_handle *) p;
7210 if (! ieee_change_buffer (info, &info->vars))
7213 if (info->block_depth == 1)
7215 if (! ieee_write_number (info, addr)
7216 || ! ieee_output_pending_parms (info))
7221 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7222 || ! ieee_write_byte (info, 6)
7223 || ! ieee_write_number (info, 0)
7224 || ! ieee_write_id (info, "")
7225 || ! ieee_write_number (info, 0)
7226 || ! ieee_write_number (info, 0)
7227 || ! ieee_write_number (info, addr))
7231 if (! ieee_start_range (info, addr))
7234 ++info->block_depth;
7242 ieee_end_block (void *p, bfd_vma addr)
7244 struct ieee_handle *info = (struct ieee_handle *) p;
7246 /* The address we are given is the end of the block, but IEEE seems
7247 to want to the address of the last byte in the block, so we
7249 if (! ieee_change_buffer (info, &info->vars)
7250 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
7251 || ! ieee_write_number (info, addr - 1))
7254 if (! ieee_end_range (info, addr))
7257 --info->block_depth;
7259 if (addr > info->highaddr)
7260 info->highaddr = addr;
7265 /* End a function. */
7268 ieee_end_function (void *p)
7270 struct ieee_handle *info = (struct ieee_handle *) p;
7272 assert (info->block_depth == 1);
7274 --info->block_depth;
7276 /* Now we can finish up fntype, and add it to the typdef section.
7277 At this point, fntype is the 'x' type up to the argument count,
7278 and fnargs is the argument types. We must add the argument
7279 count, and we must add the level. FIXME: We don't record varargs
7280 functions correctly. In fact, stabs debugging does not give us
7281 enough information to do so. */
7282 if (! ieee_change_buffer (info, &info->fntype)
7283 || ! ieee_write_number (info, info->fnargcount)
7284 || ! ieee_change_buffer (info, &info->fnargs)
7285 || ! ieee_write_number (info, 0))
7288 /* Make sure the typdef block has been started. */
7289 if (ieee_buffer_emptyp (&info->types))
7291 if (! ieee_change_buffer (info, &info->types)
7292 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7293 || ! ieee_write_byte (info, 1)
7294 || ! ieee_write_number (info, 0)
7295 || ! ieee_write_id (info, info->modname))
7299 if (! ieee_append_buffer (info, &info->types, &info->fntype)
7300 || ! ieee_append_buffer (info, &info->types, &info->fnargs))
7303 info->fnname = NULL;
7304 if (! ieee_init_buffer (info, &info->fntype)
7305 || ! ieee_init_buffer (info, &info->fnargs))
7307 info->fnargcount = 0;
7312 /* Record line number information. */
7315 ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
7317 struct ieee_handle *info = (struct ieee_handle *) p;
7319 assert (info->filename != NULL);
7321 /* The HP simulator seems to get confused when more than one line is
7322 listed for the same address, at least if they are in different
7323 files. We handle this by always listing the last line for a
7324 given address, since that seems to be the one that gdb uses. */
7325 if (info->pending_lineno_filename != NULL
7326 && addr != info->pending_lineno_addr)
7328 /* Make sure we have a line number block. */
7329 if (! ieee_buffer_emptyp (&info->linenos))
7331 if (! ieee_change_buffer (info, &info->linenos))
7336 info->lineno_name_indx = info->name_indx;
7338 if (! ieee_change_buffer (info, &info->linenos)
7339 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
7340 || ! ieee_write_byte (info, 5)
7341 || ! ieee_write_number (info, 0)
7342 || ! ieee_write_id (info, info->filename)
7343 || ! ieee_write_byte (info, (int) ieee_nn_record)
7344 || ! ieee_write_number (info, info->lineno_name_indx)
7345 || ! ieee_write_id (info, ""))
7347 info->lineno_filename = info->filename;
7350 if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0)
7352 if (strcmp (info->filename, info->lineno_filename) != 0)
7354 /* We were not in the main file. Close the block for the
7356 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
7358 if (strcmp (info->filename, info->pending_lineno_filename) == 0)
7360 /* We need a new NN record, and we aren't about to
7362 info->lineno_name_indx = info->name_indx;
7364 if (! ieee_write_byte (info, (int) ieee_nn_record)
7365 || ! ieee_write_number (info, info->lineno_name_indx)
7366 || ! ieee_write_id (info, ""))
7370 if (strcmp (info->filename, info->pending_lineno_filename) != 0)
7372 /* We are not changing to the main file. Open a block for
7373 the new included file. */
7374 info->lineno_name_indx = info->name_indx;
7376 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
7377 || ! ieee_write_byte (info, 5)
7378 || ! ieee_write_number (info, 0)
7379 || ! ieee_write_id (info, info->pending_lineno_filename)
7380 || ! ieee_write_byte (info, (int) ieee_nn_record)
7381 || ! ieee_write_number (info, info->lineno_name_indx)
7382 || ! ieee_write_id (info, ""))
7385 info->lineno_filename = info->pending_lineno_filename;
7388 if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
7389 || ! ieee_write_number (info, info->lineno_name_indx)
7390 || ! ieee_write_number (info, 0)
7391 || ! ieee_write_number (info, 7)
7392 || ! ieee_write_number (info, info->pending_lineno)
7393 || ! ieee_write_number (info, 0)
7394 || ! ieee_write_asn (info, info->lineno_name_indx,
7395 info->pending_lineno_addr))
7399 info->pending_lineno_filename = filename;
7400 info->pending_lineno = lineno;
7401 info->pending_lineno_addr = addr;