1 /* ieee.c -- Read and write IEEE-695 debugging information.
2 Copyright (C) 1996 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 /* This file reads and writes IEEE-695 debugging information. */
30 #include "libiberty.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. */
46 /* This structure is the block stack. */
48 #define BLOCKSTACK_SIZE (16)
50 struct ieee_blockstack
52 /* The stack pointer. */
53 struct ieee_block *bsp;
55 struct ieee_block stack[BLOCKSTACK_SIZE];
58 /* This structure holds information for a variable. */
68 /* Slot if we make an indirect type. */
70 /* Kind of variable or function. */
82 /* This structure holds all the variables. */
86 /* Number of slots allocated. */
89 struct ieee_var *vars;
92 /* This structure holds information for a type. We need this because
93 we don't want to represent bitfields as real types. */
99 /* Slot if this is type is referenced before it is defined. */
101 /* Slots for arguments if we make indirect types for them. */
102 debug_type *arg_slots;
103 /* If this is a bitfield, this is the size in bits. If this is not
104 a bitfield, this is zero. */
105 unsigned long bitsize;
108 /* This structure holds all the type information. */
112 /* Number of slots allocated. */
115 struct ieee_type *types;
117 #define BUILTIN_TYPE_COUNT (60)
118 debug_type builtins[BUILTIN_TYPE_COUNT];
121 /* This structure holds a linked last of structs with their tag names,
122 so that we can convert them to C++ classes if necessary. */
127 struct ieee_tag *next;
130 /* The type of the tag. */
132 /* The tagged type is an indirect type pointing at this slot. */
134 /* This is an array of slots used when a field type is converted
135 into a indirect type, in case it needs to be later converted into
140 /* This structure holds the information we pass around to the parsing
145 /* The debugging handle. */
149 /* The start of the bytes to be parsed. */
150 const bfd_byte *bytes;
151 /* The end of the bytes to be parsed. */
152 const bfd_byte *pend;
153 /* The block stack. */
154 struct ieee_blockstack blockstack;
156 struct ieee_vars vars;
158 struct ieee_types types;
159 /* The list of tagged structs. */
160 struct ieee_tag *tags;
163 /* Basic builtin types, not including the pointers. */
169 builtin_signed_char = 2,
170 builtin_unsigned_char = 3,
171 builtin_signed_short_int = 4,
172 builtin_unsigned_short_int = 5,
173 builtin_signed_long = 6,
174 builtin_unsigned_long = 7,
175 builtin_signed_long_long = 8,
176 builtin_unsigned_long_long = 9,
179 builtin_long_double = 12,
180 builtin_long_long_double = 13,
181 builtin_quoted_string = 14,
182 builtin_instruction_address = 15,
184 builtin_unsigned = 17,
185 builtin_unsigned_int = 18,
189 builtin_unsigned_short = 22,
190 builtin_short_int = 23,
191 builtin_signed_short = 24,
192 builtin_bcd_float = 25
195 /* These are the values found in the derivation flags of a 'b'
196 component record of a 'T' type extension record in a C++ pmisc
197 record. These are bitmasks. */
199 /* Set for a private base class, clear for a public base class.
200 Protected base classes are not supported. */
201 #define BASEFLAGS_PRIVATE (0x1)
202 /* Set for a virtual base class. */
203 #define BASEFLAGS_VIRTUAL (0x2)
204 /* Set for a friend class, clear for a base class. */
205 #define BASEFLAGS_FRIEND (0x10)
207 /* These are the values found in the specs flags of a 'd', 'm', or 'v'
208 component record of a 'T' type extension record in a C++ pmisc
209 record. The same flags are used for a 'M' record in a C++ pmisc
212 /* The lower two bits hold visibility information. */
213 #define CXXFLAGS_VISIBILITY (0x3)
214 /* This value in the lower two bits indicates a public member. */
215 #define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
216 /* This value in the lower two bits indicates a private member. */
217 #define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
218 /* This value in the lower two bits indicates a protected member. */
219 #define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
220 /* Set for a static member. */
221 #define CXXFLAGS_STATIC (0x4)
222 /* Set for a virtual override. */
223 #define CXXFLAGS_OVERRIDE (0x8)
224 /* Set for a friend function. */
225 #define CXXFLAGS_FRIEND (0x10)
226 /* Set for a const function. */
227 #define CXXFLAGS_CONST (0x20)
228 /* Set for a volatile function. */
229 #define CXXFLAGS_VOLATILE (0x40)
230 /* Set for an overloaded function. */
231 #define CXXFLAGS_OVERLOADED (0x80)
232 /* Set for an operator function. */
233 #define CXXFLAGS_OPERATOR (0x100)
234 /* Set for a constructor or destructor. */
235 #define CXXFLAGS_CTORDTOR (0x400)
236 /* Set for a constructor. */
237 #define CXXFLAGS_CTOR (0x200)
238 /* Set for an inline function. */
239 #define CXXFLAGS_INLINE (0x800)
241 /* Local functions. */
243 static void ieee_error
244 PARAMS ((struct ieee_info *, const bfd_byte *, const char *));
245 static void ieee_eof PARAMS ((struct ieee_info *));
246 static char *savestring PARAMS ((const char *, unsigned long));
247 static boolean ieee_read_number
248 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
249 static boolean ieee_read_optional_number
250 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *, boolean *));
251 static boolean ieee_read_id
252 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
254 static boolean ieee_read_optional_id
255 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
256 unsigned long *, boolean *));
257 static boolean ieee_read_expression
258 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
259 static debug_type ieee_builtin_type
260 PARAMS ((struct ieee_info *, const bfd_byte *, unsigned int));
261 static boolean ieee_alloc_type
262 PARAMS ((struct ieee_info *, unsigned int, boolean));
263 static boolean ieee_read_type_index
264 PARAMS ((struct ieee_info *, const bfd_byte **, debug_type *));
265 static int ieee_regno_to_genreg PARAMS ((bfd *, int));
266 static int ieee_genreg_to_regno PARAMS ((bfd *, int));
267 static boolean parse_ieee_bb PARAMS ((struct ieee_info *, const bfd_byte **));
268 static boolean parse_ieee_be PARAMS ((struct ieee_info *, const bfd_byte **));
269 static boolean parse_ieee_nn PARAMS ((struct ieee_info *, const bfd_byte **));
270 static boolean parse_ieee_ty PARAMS ((struct ieee_info *, const bfd_byte **));
271 static boolean parse_ieee_atn PARAMS ((struct ieee_info *, const bfd_byte **));
272 static boolean ieee_read_cxx_misc
273 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
274 static boolean ieee_read_cxx_class
275 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
276 static boolean ieee_read_cxx_defaults
277 PARAMS ((struct ieee_info *, const bfd_byte **, unsigned long));
278 static boolean ieee_read_reference
279 PARAMS ((struct ieee_info *, const bfd_byte **));
280 static boolean ieee_require_asn
281 PARAMS ((struct ieee_info *, const bfd_byte **, bfd_vma *));
282 static boolean ieee_require_atn65
283 PARAMS ((struct ieee_info *, const bfd_byte **, const char **,
286 /* Report an error in the IEEE debugging information. */
289 ieee_error (info, p, s)
290 struct ieee_info *info;
295 fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
296 (unsigned long) (p - info->bytes), s, *p);
298 fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
301 /* Report an unexpected EOF in the IEEE debugging information. */
305 struct ieee_info *info;
307 ieee_error (info, (const bfd_byte *) NULL,
308 "unexpected end of debugging information");
311 /* Save a string in memory. */
314 savestring (start, len)
320 ret = (char *) xmalloc (len + 1);
321 memcpy (ret, start, len);
326 /* Read a number which must be present in an IEEE file. */
329 ieee_read_number (info, pp, pv)
330 struct ieee_info *info;
334 return ieee_read_optional_number (info, pp, pv, (boolean *) NULL);
337 /* Read a number in an IEEE file. If ppresent is not NULL, the number
338 need not be there. */
341 ieee_read_optional_number (info, pp, pv, ppresent)
342 struct ieee_info *info;
347 ieee_record_enum_type b;
349 if (*pp >= info->pend)
351 if (ppresent != NULL)
360 b = (ieee_record_enum_type) **pp;
363 if (b <= ieee_number_end_enum)
366 if (ppresent != NULL)
371 if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
375 i = (int) b - (int) ieee_number_repeat_start_enum;
376 if (*pp + i - 1 >= info->pend)
390 if (ppresent != NULL)
396 if (ppresent != NULL)
403 ieee_error (info, *pp - 1, "invalid number");
407 /* Read a required string from an IEEE file. */
410 ieee_read_id (info, pp, pname, pnamlen)
411 struct ieee_info *info;
414 unsigned long *pnamlen;
416 return ieee_read_optional_id (info, pp, pname, pnamlen, (boolean *) NULL);
419 /* Read a string from an IEEE file. If ppresent is not NULL, the
420 string is optional. */
423 ieee_read_optional_id (info, pp, pname, pnamlen, ppresent)
424 struct ieee_info *info;
427 unsigned long *pnamlen;
433 if (*pp >= info->pend)
444 else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
449 else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
451 len = (**pp << 8) + (*pp)[1];
456 if (ppresent != NULL)
462 ieee_error (info, *pp - 1, "invalid string length");
466 if ((unsigned long) (info->pend - *pp) < len)
472 *pname = (const char *) *pp;
476 if (ppresent != NULL)
482 /* Read an expression from an IEEE file. Since this code is only used
483 to parse debugging information, I haven't bothered to write a full
484 blown IEEE expression parser. I've only thrown in the things I've
485 seen in debugging information. This can be easily extended if
489 ieee_read_expression (info, pp, pv)
490 struct ieee_info *info;
494 const bfd_byte *expr_start;
495 #define EXPR_STACK_SIZE (10)
496 bfd_vma expr_stack[EXPR_STACK_SIZE];
505 const bfd_byte *start;
508 ieee_record_enum_type c;
512 if (! ieee_read_optional_number (info, pp, &val, &present))
517 if (esp - expr_stack >= EXPR_STACK_SIZE)
519 ieee_error (info, start, "expression stack overflow");
526 c = (ieee_record_enum_type) **pp;
528 if (c >= ieee_module_beginning_enum)
539 ieee_error (info, start, "unsupported IEEE expression operator");
542 case ieee_variable_R_enum:
547 if (! ieee_read_number (info, pp, &indx))
549 for (s = info->abfd->sections; s != NULL; s = s->next)
550 if ((bfd_vma) s->target_index == indx)
554 ieee_error (info, start, "unknown section");
558 if (esp - expr_stack >= EXPR_STACK_SIZE)
560 ieee_error (info, start, "expression stack overflow");
564 *esp++ = bfd_get_section_vma (info->abfd, s);
568 case ieee_function_plus_enum:
569 case ieee_function_minus_enum:
573 if (esp - expr_stack < 2)
575 ieee_error (info, start, "expression stack underflow");
587 if (esp - 1 != expr_stack)
589 ieee_error (info, expr_start, "expression stack mismatch");
598 /* Return an IEEE builtin type. */
601 ieee_builtin_type (info, p, indx)
602 struct ieee_info *info;
610 if (indx < BUILTIN_TYPE_COUNT
611 && info->types.builtins[indx] != DEBUG_TYPE_NULL)
612 return info->types.builtins[indx];
614 dhandle = info->dhandle;
616 if (indx >= 32 && indx < 64)
618 type = debug_make_pointer_type (dhandle,
619 ieee_builtin_type (info, p, indx - 32));
620 assert (indx < BUILTIN_TYPE_COUNT);
621 info->types.builtins[indx] = type;
625 switch ((enum builtin_types) indx)
628 ieee_error (info, p, "unknown builtin type");
631 case builtin_unknown:
632 type = debug_make_void_type (dhandle);
637 type = debug_make_void_type (dhandle);
641 case builtin_signed_char:
642 type = debug_make_int_type (dhandle, 1, false);
643 name = "signed char";
646 case builtin_unsigned_char:
647 type = debug_make_int_type (dhandle, 1, true);
648 name = "unsigned char";
651 case builtin_signed_short_int:
652 type = debug_make_int_type (dhandle, 2, false);
653 name = "signed short int";
656 case builtin_unsigned_short_int:
657 type = debug_make_int_type (dhandle, 2, true);
658 name = "unsigned short int";
661 case builtin_signed_long:
662 type = debug_make_int_type (dhandle, 4, false);
663 name = "signed long";
666 case builtin_unsigned_long:
667 type = debug_make_int_type (dhandle, 4, true);
668 name = "unsigned long";
671 case builtin_signed_long_long:
672 type = debug_make_int_type (dhandle, 8, false);
673 name = "signed long long";
676 case builtin_unsigned_long_long:
677 type = debug_make_int_type (dhandle, 8, true);
678 name = "unsigned long long";
682 type = debug_make_float_type (dhandle, 4);
687 type = debug_make_float_type (dhandle, 8);
691 case builtin_long_double:
692 /* FIXME: The size for this type should depend upon the
694 type = debug_make_float_type (dhandle, 12);
695 name = "long double";
698 case builtin_long_long_double:
699 type = debug_make_float_type (dhandle, 16);
700 name = "long long double";
703 case builtin_quoted_string:
704 type = debug_make_array_type (dhandle,
705 ieee_builtin_type (info, p,
708 ieee_builtin_type (info, p,
712 name = "QUOTED STRING";
715 case builtin_instruction_address:
716 /* FIXME: This should be a code address. */
717 type = debug_make_int_type (dhandle, 4, true);
718 name = "instruction address";
722 /* FIXME: The size for this type should depend upon the
724 type = debug_make_int_type (dhandle, 4, false);
728 case builtin_unsigned:
729 /* FIXME: The size for this type should depend upon the
731 type = debug_make_int_type (dhandle, 4, true);
735 case builtin_unsigned_int:
736 /* FIXME: The size for this type should depend upon the
738 type = debug_make_int_type (dhandle, 4, true);
739 name = "unsigned int";
743 type = debug_make_int_type (dhandle, 1, false);
748 type = debug_make_int_type (dhandle, 4, false);
753 type = debug_make_int_type (dhandle, 2, false);
757 case builtin_unsigned_short:
758 type = debug_make_int_type (dhandle, 2, true);
759 name = "unsigned short";
762 case builtin_short_int:
763 type = debug_make_int_type (dhandle, 2, false);
767 case builtin_signed_short:
768 type = debug_make_int_type (dhandle, 2, false);
769 name = "signed short";
772 case builtin_bcd_float:
773 ieee_error (info, p, "BCD float type not supported");
778 type = debug_name_type (dhandle, name, type);
780 assert (indx < BUILTIN_TYPE_COUNT);
782 info->types.builtins[indx] = type;
787 /* Allocate more space in the type table. If ref is true, this is a
788 reference to the type; if it is not already defined, we should set
789 up an indirect type. */
792 ieee_alloc_type (info, indx, ref)
793 struct ieee_info *info;
798 register struct ieee_type *t;
799 struct ieee_type *tend;
801 if (indx >= info->types.alloc)
803 nalloc = info->types.alloc;
806 while (indx >= nalloc)
809 info->types.types = ((struct ieee_type *)
810 xrealloc (info->types.types,
811 nalloc * sizeof *info->types.types));
813 memset (info->types.types + info->types.alloc, 0,
814 (nalloc - info->types.alloc) * sizeof *info->types.types);
816 tend = info->types.types + nalloc;
817 for (t = info->types.types + info->types.alloc; t < tend; t++)
818 t->type = DEBUG_TYPE_NULL;
820 info->types.alloc = nalloc;
825 t = info->types.types + indx;
828 t->pslot = (debug_type *) xmalloc (sizeof *t->pslot);
829 *t->pslot = DEBUG_TYPE_NULL;
830 t->type = debug_make_indirect_type (info->dhandle, t->pslot,
831 (const char *) NULL);
840 /* Read a type index and return the corresponding type. */
843 ieee_read_type_index (info, pp, ptype)
844 struct ieee_info *info;
848 const bfd_byte *start;
853 if (! ieee_read_number (info, pp, &indx))
858 *ptype = ieee_builtin_type (info, start, indx);
865 if (! ieee_alloc_type (info, indx, true))
868 *ptype = info->types.types[indx].type;
873 /* Parse IEEE debugging information for a file. This is passed the
874 bytes which compose the Debug Information Part of an IEEE file. */
877 parse_ieee (dhandle, abfd, bytes, len)
880 const bfd_byte *bytes;
883 struct ieee_info info;
885 const bfd_byte *p, *pend;
887 info.dhandle = dhandle;
890 info.pend = bytes + len;
891 info.blockstack.bsp = info.blockstack.stack;
893 info.vars.vars = NULL;
894 info.types.alloc = 0;
895 info.types.types = NULL;
897 for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
898 info.types.builtins[i] = DEBUG_TYPE_NULL;
904 const bfd_byte *record_start;
905 ieee_record_enum_type c;
909 c = (ieee_record_enum_type) *p++;
911 if (c == ieee_at_record_enum)
912 c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++);
914 if (c <= ieee_number_repeat_end_enum)
916 ieee_error (&info, record_start, "unexpected number");
923 ieee_error (&info, record_start, "unexpected record type");
926 case ieee_bb_record_enum:
927 if (! parse_ieee_bb (&info, &p))
931 case ieee_be_record_enum:
932 if (! parse_ieee_be (&info, &p))
937 if (! parse_ieee_nn (&info, &p))
941 case ieee_ty_record_enum:
942 if (! parse_ieee_ty (&info, &p))
946 case ieee_atn_record_enum:
947 if (! parse_ieee_atn (&info, &p))
953 if (info.blockstack.bsp != info.blockstack.stack)
955 ieee_error (&info, (const bfd_byte *) NULL,
956 "blocks left on stack at end");
963 /* Handle an IEEE BB record. */
966 parse_ieee_bb (info, pp)
967 struct ieee_info *info;
970 const bfd_byte *block_start;
974 unsigned long namlen;
983 if (! ieee_read_number (info, pp, &size)
984 || ! ieee_read_id (info, pp, &name, &namlen))
987 fnindx = (unsigned int) -1;
992 /* BB1: Type definitions local to a module. */
993 namcopy = savestring (name, namlen);
996 if (! debug_set_filename (info->dhandle, namcopy))
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*"))
1008 /* BB3: High level module block begin. We don't have to do
1009 anything here. The name is supposed to be the same as for
1010 the BB1, but we don't check. */
1014 /* BB4: Global function. */
1016 bfd_vma stackspace, typindx, offset;
1017 debug_type return_type;
1019 if (! ieee_read_number (info, pp, &stackspace)
1020 || ! ieee_read_number (info, pp, &typindx)
1021 || ! ieee_read_expression (info, pp, &offset))
1024 /* We have no way to record the stack space. FIXME. */
1028 return_type = ieee_builtin_type (info, block_start, typindx);
1029 if (return_type == DEBUG_TYPE_NULL)
1035 if (! ieee_alloc_type (info, typindx, true))
1038 return_type = info->types.types[typindx].type;
1039 if (debug_get_type_kind (info->dhandle, return_type)
1040 == DEBUG_KIND_FUNCTION)
1041 return_type = debug_get_return_type (info->dhandle,
1045 namcopy = savestring (name, namlen);
1046 if (namcopy == NULL)
1048 if (! debug_record_function (info->dhandle, namcopy, return_type,
1055 /* BB5: File name for source line numbers. */
1059 /* We ignore the date and time. FIXME. */
1060 for (i = 0; i < 6; i++)
1065 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1071 namcopy = savestring (name, namlen);
1072 if (namcopy == NULL)
1074 if (! debug_start_source (info->dhandle, namcopy))
1080 /* BB6: Local function or block. */
1082 bfd_vma stackspace, typindx, offset;
1084 if (! ieee_read_number (info, pp, &stackspace)
1085 || ! ieee_read_number (info, pp, &typindx)
1086 || ! ieee_read_expression (info, pp, &offset))
1089 /* We have no way to record the stack space. FIXME. */
1093 if (! debug_start_block (info->dhandle, offset))
1095 /* Change b to indicate that this is a block
1096 rather than a function. */
1101 debug_type return_type;
1105 return_type = ieee_builtin_type (info, block_start, typindx);
1106 if (return_type == NULL)
1112 if (! ieee_alloc_type (info, typindx, true))
1115 return_type = info->types.types[typindx].type;
1116 if (debug_get_type_kind (info->dhandle, return_type)
1117 == DEBUG_KIND_FUNCTION)
1118 return_type = debug_get_return_type (info->dhandle,
1122 namcopy = savestring (name, namlen);
1123 if (namcopy == NULL)
1125 if (! debug_record_function (info->dhandle, namcopy, return_type,
1133 /* BB10: Assembler module scope. We completely ignore all this
1134 information. FIXME. */
1136 const char *inam, *vstr;
1137 unsigned long inamlen, vstrlen;
1142 if (! ieee_read_id (info, pp, &inam, &inamlen)
1143 || ! ieee_read_number (info, pp, &tool_type)
1144 || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
1146 for (i = 0; i < 6; i++)
1150 if (! ieee_read_optional_number (info, pp, &ignore, &present))
1159 /* BB11: Module section. We completely ignore all this
1160 information. FIXME. */
1162 bfd_vma sectype, secindx, offset, map;
1165 if (! ieee_read_number (info, pp, §ype)
1166 || ! ieee_read_number (info, pp, &secindx)
1167 || ! ieee_read_expression (info, pp, &offset)
1168 || ! ieee_read_optional_number (info, pp, &map, &present))
1174 ieee_error (info, block_start, "unknown BB type");
1179 /* Push this block on the block stack. */
1181 if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
1183 ieee_error (info, (const bfd_byte *) NULL, "stack overflow");
1187 info->blockstack.bsp->kind = b;
1189 info->blockstack.bsp->filename = namcopy;
1190 info->blockstack.bsp->fnindx = fnindx;
1191 ++info->blockstack.bsp;
1196 /* Handle an IEEE BE record. */
1199 parse_ieee_be (info, pp)
1200 struct ieee_info *info;
1201 const bfd_byte **pp;
1205 if (info->blockstack.bsp <= info->blockstack.stack)
1207 ieee_error (info, *pp, "stack underflow");
1210 --info->blockstack.bsp;
1212 switch (info->blockstack.bsp->kind)
1216 if (! ieee_read_expression (info, pp, &offset))
1218 if (! debug_end_function (info->dhandle, offset))
1223 /* This is BE6 when BB6 started a block rather than a local
1225 if (! ieee_read_expression (info, pp, &offset))
1227 if (! debug_end_block (info->dhandle, offset))
1232 /* When we end a BB5, we look up the stack for the last BB5, if
1233 there is one, so that we can call debug_start_source. */
1234 if (info->blockstack.bsp > info->blockstack.stack)
1236 struct ieee_block *bl;
1238 bl = info->blockstack.bsp;
1244 if (! debug_start_source (info->dhandle, bl->filename))
1249 while (bl != info->blockstack.stack);
1254 if (! ieee_read_expression (info, pp, &offset))
1256 /* We just ignore the module size. FIXME. */
1260 /* Other block types do not have any trailing information. */
1267 /* Parse an NN record. */
1270 parse_ieee_nn (info, pp)
1271 struct ieee_info *info;
1272 const bfd_byte **pp;
1274 const bfd_byte *nn_start;
1277 unsigned long namlen;
1281 if (! ieee_read_number (info, pp, &varindx)
1282 || ! ieee_read_id (info, pp, &name, &namlen))
1287 ieee_error (info, nn_start, "illegal variable index");
1292 if (varindx >= info->vars.alloc)
1296 alloc = info->vars.alloc;
1299 while (varindx >= alloc)
1301 info->vars.vars = ((struct ieee_var *)
1302 xrealloc (info->vars.vars,
1303 alloc * sizeof *info->vars.vars));
1304 memset (info->vars.vars + info->vars.alloc, 0,
1305 (alloc - info->vars.alloc) * sizeof *info->vars.vars);
1306 info->vars.alloc = alloc;
1309 info->vars.vars[varindx].name = name;
1310 info->vars.vars[varindx].namlen = namlen;
1315 /* Parse a TY record. */
1318 parse_ieee_ty (info, pp)
1319 struct ieee_info *info;
1320 const bfd_byte **pp;
1322 const bfd_byte *ty_start, *ty_var_start, *ty_code_start;
1323 bfd_vma typeindx, varindx, tc;
1325 boolean tag, typdef;
1326 debug_type *arg_slots;
1327 unsigned long type_bitsize;
1332 if (! ieee_read_number (info, pp, &typeindx))
1337 ieee_error (info, ty_start, "illegal type index");
1342 if (! ieee_alloc_type (info, typeindx, false))
1347 ieee_error (info, *pp, "unknown TY code");
1354 if (! ieee_read_number (info, pp, &varindx))
1359 ieee_error (info, ty_var_start, "illegal variable index");
1364 if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL)
1366 ieee_error (info, ty_var_start, "undefined variable in TY");
1370 ty_code_start = *pp;
1372 if (! ieee_read_number (info, pp, &tc))
1375 dhandle = info->dhandle;
1384 ieee_error (info, ty_code_start, "unknown TY code");
1388 /* Unknown type, with size. We treat it as int. FIXME. */
1392 if (! ieee_read_number (info, pp, &size))
1394 type = debug_make_int_type (dhandle, size, false);
1398 case 'A': /* Array. */
1399 case 'a': /* FORTRAN array in column/row order. FIXME: Not
1400 distinguished from normal array. */
1402 debug_type ele_type;
1403 bfd_vma lower, upper;
1405 if (! ieee_read_type_index (info, pp, &ele_type)
1406 || ! ieee_read_number (info, pp, &lower)
1407 || ! ieee_read_number (info, pp, &upper))
1409 type = debug_make_array_type (dhandle, ele_type,
1410 ieee_builtin_type (info, ty_code_start,
1413 (bfd_signed_vma) lower,
1414 (bfd_signed_vma) upper,
1420 /* Simple enumeration. */
1426 bfd_signed_vma *vals;
1429 if (! ieee_read_number (info, pp, &size))
1431 /* FIXME: we ignore the enumeration size. */
1434 names = (const char **) xmalloc (alloc * sizeof *names);
1435 memset (names, 0, alloc * sizeof *names);
1440 unsigned long namlen;
1443 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1451 names = ((const char **)
1452 xrealloc (names, alloc * sizeof *names));
1455 names[c] = savestring (name, namlen);
1456 if (names[c] == NULL)
1463 vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals);
1464 for (i = 0; i < c; i++)
1467 type = debug_make_enum_type (dhandle, names, vals);
1473 /* Struct with bit fields. */
1477 debug_field *fields;
1480 if (! ieee_read_number (info, pp, &size))
1484 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1489 unsigned long namlen;
1492 bfd_vma bitpos, bitsize;
1494 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1498 if (! ieee_read_type_index (info, pp, &ftype)
1499 || ! ieee_read_number (info, pp, &bitpos)
1500 || ! ieee_read_number (info, pp, &bitsize))
1506 fields = ((debug_field *)
1507 xrealloc (fields, alloc * sizeof *fields));
1510 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1511 ftype, bitpos, bitsize,
1512 DEBUG_VISIBILITY_PUBLIC);
1513 if (fields[c] == NULL)
1520 type = debug_make_struct_type (dhandle, true, size, fields);
1530 bfd_signed_vma *vals;
1534 names = (const char **) xmalloc (alloc * sizeof *names);
1535 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names);
1540 unsigned long namlen;
1544 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1548 if (! ieee_read_number (info, pp, &val))
1551 /* If the length of the name is zero, then the value is
1552 actually the size of the enum. We ignore this
1553 information. FIXME. */
1560 names = ((const char **)
1561 xrealloc (names, alloc * sizeof *names));
1562 vals = ((bfd_signed_vma *)
1563 xrealloc (vals, alloc * sizeof *vals));
1566 names[c] = savestring (name, namlen);
1567 if (names[c] == NULL)
1569 vals[c] = (bfd_signed_vma) val;
1575 type = debug_make_enum_type (dhandle, names, vals);
1580 case 'O': /* Small pointer. We don't distinguish small and large
1582 case 'P': /* Large pointer. */
1586 if (! ieee_read_type_index (info, pp, &t))
1588 type = debug_make_pointer_type (dhandle, t);
1595 bfd_vma low, high, signedp, size;
1597 if (! ieee_read_number (info, pp, &low)
1598 || ! ieee_read_number (info, pp, &high)
1599 || ! ieee_read_number (info, pp, &signedp)
1600 || ! ieee_read_number (info, pp, &size))
1603 type = debug_make_range_type (dhandle,
1604 debug_make_int_type (dhandle, size,
1606 (bfd_signed_vma) low,
1607 (bfd_signed_vma) high);
1611 case 'S': /* Struct. */
1612 case 'U': /* Union. */
1616 debug_field *fields;
1619 if (! ieee_read_number (info, pp, &size))
1623 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
1628 unsigned long namlen;
1635 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1639 if (! ieee_read_number (info, pp, &tindx)
1640 || ! ieee_read_number (info, pp, &offset))
1645 ftype = ieee_builtin_type (info, ty_code_start, tindx);
1651 struct ieee_type *t;
1654 if (! ieee_alloc_type (info, tindx, true))
1656 t = info->types.types + tindx;
1658 bitsize = t->bitsize;
1666 fields = ((debug_field *)
1667 xrealloc (fields, alloc * sizeof *fields));
1670 fields[c] = debug_make_field (dhandle, savestring (name, namlen),
1671 ftype, offset, bitsize,
1672 DEBUG_VISIBILITY_PUBLIC);
1673 if (fields[c] == NULL)
1680 type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
1687 if (! ieee_read_type_index (info, pp, &type))
1693 /* Procedure. FIXME: This is an extern declaration, which we
1694 have no way of representing. */
1700 struct ieee_var *pv;
1702 /* FIXME: We ignore the attribute and the argument names. */
1704 if (! ieee_read_number (info, pp, &attr)
1705 || ! ieee_read_type_index (info, pp, &rtype)
1706 || ! ieee_read_number (info, pp, &nargs))
1711 unsigned long namlen;
1713 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
1718 pv = info->vars.vars + varindx;
1719 pv->kind = IEEE_EXTERNAL;
1721 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1723 /* Set up the return type as an indirect type pointing to
1724 the variable slot, so that we can change it to a
1725 reference later if appropriate. */
1726 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1728 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1729 (const char *) NULL);
1732 type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
1738 /* Array with 0 lower bound. */
1743 if (! ieee_read_type_index (info, pp, &etype)
1744 || ! ieee_read_number (info, pp, &high))
1747 type = debug_make_array_type (dhandle, etype,
1748 ieee_builtin_type (info, ty_code_start,
1751 0, (bfd_signed_vma) high, false);
1755 case 'c': /* Complex. */
1756 case 'd': /* Double complex. */
1759 unsigned long namlen;
1761 /* FIXME: I don't know what the name means. */
1763 if (! ieee_read_id (info, pp, &name, &namlen))
1766 type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
1771 /* Pascal file name. FIXME. */
1772 ieee_error (info, ty_code_start, "Pascal file name not supported");
1776 /* Bitfield type. */
1778 bfd_vma signedp, bitsize;
1780 if (! ieee_read_number (info, pp, &signedp)
1781 || ! ieee_read_number (info, pp, &bitsize)
1782 || ! ieee_read_type_index (info, pp, &type))
1785 /* FIXME: This is just a guess. */
1787 type = debug_make_int_type (dhandle, 4, true);
1788 type_bitsize = bitsize;
1798 if (! ieee_read_number (info, pp, &kind)
1799 || ! ieee_read_type_index (info, pp, &t))
1805 ieee_error (info, ty_start, "unsupported qualifer");
1809 type = debug_make_const_type (dhandle, t);
1813 type = debug_make_volatile_type (dhandle, t);
1825 if (! ieee_read_number (info, pp, &size)
1826 || ! ieee_read_type_index (info, pp, &etype))
1829 /* FIXME: We ignore the size. */
1831 type = debug_make_set_type (dhandle, etype, false);
1836 /* Procedure with compiler dependencies. */
1838 struct ieee_var *pv;
1839 bfd_vma attr, frame_type, push_mask, nargs, level, father;
1841 debug_type *arg_types;
1845 /* FIXME: We ignore some of this information. */
1847 pv = info->vars.vars + varindx;
1849 if (! ieee_read_number (info, pp, &attr)
1850 || ! ieee_read_number (info, pp, &frame_type)
1851 || ! ieee_read_number (info, pp, &push_mask)
1852 || ! ieee_read_type_index (info, pp, &rtype)
1853 || ! ieee_read_number (info, pp, &nargs))
1855 if (nargs == (bfd_vma) -1)
1864 arg_types = ((debug_type *)
1865 xmalloc ((nargs + 1) * sizeof *arg_types));
1866 for (i = 0; i < nargs; i++)
1867 if (! ieee_read_type_index (info, pp, arg_types + i))
1870 /* If the last type is pointer to void, this is really a
1871 varargs function. */
1877 last = arg_types[nargs - 1];
1878 if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
1879 && (debug_get_type_kind (dhandle,
1880 debug_get_target_type (dhandle,
1882 == DEBUG_KIND_VOID))
1889 /* If there are any pointer arguments, turn them into
1890 indirect types in case we later need to convert them to
1892 for (i = 0; i < nargs; i++)
1894 if (debug_get_type_kind (dhandle, arg_types[i])
1895 == DEBUG_KIND_POINTER)
1897 if (arg_slots == NULL)
1899 arg_slots = ((debug_type *)
1900 xmalloc (nargs * sizeof *arg_slots));
1901 memset (arg_slots, 0, nargs * sizeof *arg_slots);
1903 arg_slots[i] = arg_types[i];
1905 debug_make_indirect_type (dhandle,
1907 (const char *) NULL);
1911 arg_types[nargs] = DEBUG_TYPE_NULL;
1913 if (! ieee_read_number (info, pp, &level)
1914 || ! ieee_read_optional_number (info, pp, &father, &present))
1917 /* We can't distinguish between a global function and a static
1919 pv->kind = IEEE_FUNCTION;
1922 && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
1924 /* Set up the return type as an indirect type pointing to
1925 the variable slot, so that we can change it to a
1926 reference later if appropriate. */
1927 pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot);
1929 rtype = debug_make_indirect_type (dhandle, pv->pslot,
1930 (const char *) NULL);
1933 type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
1938 /* Record the type in the table. If the corresponding NN record has
1939 a name, name it. FIXME: Is this always correct? */
1941 if (type == DEBUG_TYPE_NULL)
1944 info->vars.vars[varindx].type = type;
1947 && info->vars.vars[varindx].namlen > 0)
1951 name = savestring (info->vars.vars[varindx].name,
1952 info->vars.vars[varindx].namlen);
1954 type = debug_name_type (dhandle, name, type);
1955 else if (tc == 'E' || tc == 'N')
1956 type = debug_tag_type (dhandle, name, type);
1959 struct ieee_tag *it;
1961 /* We must allocate all struct tags as indirect types, so
1962 that if we later see a definition of the tag as a C++
1963 record we can update the indirect slot and automatically
1964 change all the existing references. */
1965 it = (struct ieee_tag *) xmalloc (sizeof *it);
1966 memset (it, 0, sizeof *it);
1967 it->next = info->tags;
1972 type = debug_make_indirect_type (dhandle, &it->slot, name);
1973 type = debug_tag_type (dhandle, name, type);
1981 info->types.types[typeindx].type = type;
1982 info->types.types[typeindx].arg_slots = arg_slots;
1983 info->types.types[typeindx].bitsize = type_bitsize;
1985 /* We may have already allocated type as an indirect type pointing
1986 to slot. It does no harm to replace the indirect type with the
1987 real type. Filling in slot as well handles the indirect types
1988 which are already hanging around. */
1989 if (info->types.types[typeindx].pslot != NULL)
1990 *info->types.types[typeindx].pslot = type;
1995 /* Parse an ATN record. */
1998 parse_ieee_atn (info, pp)
1999 struct ieee_info *info;
2000 const bfd_byte **pp;
2002 const bfd_byte *atn_start, *atn_code_start;
2004 struct ieee_var *pvar;
2008 bfd_vma v, v2, v3, v4, v5;
2010 unsigned long namlen;
2017 if (! ieee_read_number (info, pp, &varindx)
2018 || ! ieee_read_type_index (info, pp, &type))
2021 atn_code_start = *pp;
2023 if (! ieee_read_number (info, pp, &atn_code))
2032 else if (varindx < 32)
2034 ieee_error (info, atn_start, "illegal variable index");
2040 if (varindx >= info->vars.alloc
2041 || info->vars.vars[varindx].name == NULL)
2043 ieee_error (info, atn_start, "undefined variable in ATN");
2047 pvar = info->vars.vars + varindx;
2052 namlen = pvar->namlen;
2055 dhandle = info->dhandle;
2057 /* If we are going to call debug_record_variable with a pointer
2058 type, change the type to an indirect type so that we can later
2059 change it to a reference type if we encounter a C++ pmisc 'R'
2062 && type != DEBUG_TYPE_NULL
2063 && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
2073 pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot);
2074 *pvar->pslot = type;
2075 type = debug_make_indirect_type (dhandle, pvar->pslot,
2076 (const char *) NULL);
2085 ieee_error (info, atn_code_start, "unknown ATN type");
2089 /* Automatic variable. */
2090 if (! ieee_read_number (info, pp, &v))
2092 namcopy = savestring (name, namlen);
2094 type = debug_make_void_type (dhandle);
2096 pvar->kind = IEEE_LOCAL;
2097 return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
2100 /* Register variable. */
2101 if (! ieee_read_number (info, pp, &v))
2103 namcopy = savestring (name, namlen);
2105 type = debug_make_void_type (dhandle);
2107 pvar->kind = IEEE_LOCAL;
2108 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
2109 ieee_regno_to_genreg (info->abfd, v));
2112 /* Static variable. */
2113 if (! ieee_require_asn (info, pp, &v))
2115 namcopy = savestring (name, namlen);
2117 type = debug_make_void_type (dhandle);
2118 if (info->blockstack.bsp <= info->blockstack.stack)
2121 blocktype = info->blockstack.bsp[-1].kind;
2124 if (blocktype == 4 || blocktype == 6)
2125 pvar->kind = IEEE_LOCAL;
2127 pvar->kind = IEEE_STATIC;
2129 return debug_record_variable (dhandle, namcopy, type,
2130 (blocktype == 4 || blocktype == 6
2131 ? DEBUG_LOCAL_STATIC
2136 /* External function. We don't currently record these. FIXME. */
2138 pvar->kind = IEEE_EXTERNAL;
2142 /* External variable. We don't currently record these. FIXME. */
2144 pvar->kind = IEEE_EXTERNAL;
2148 if (! ieee_read_number (info, pp, &v)
2149 || ! ieee_read_number (info, pp, &v2)
2150 || ! ieee_read_optional_number (info, pp, &v3, &present))
2154 if (! ieee_read_optional_number (info, pp, &v4, &present))
2158 /* We just ignore the two optional fields in v3 and v4, since
2159 they are not defined. */
2161 if (! ieee_require_asn (info, pp, &v3))
2164 /* We have no way to record the column number. FIXME. */
2166 return debug_record_line (dhandle, v, v3);
2169 /* Global variable. */
2170 if (! ieee_require_asn (info, pp, &v))
2172 namcopy = savestring (name, namlen);
2174 type = debug_make_void_type (dhandle);
2176 pvar->kind = IEEE_GLOBAL;
2177 return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
2180 /* Variable lifetime information. */
2181 if (! ieee_read_number (info, pp, &v))
2184 /* We have no way to record this information. FIXME. */
2188 /* Locked register. */
2189 if (! ieee_read_number (info, pp, &v)
2190 || ! ieee_read_number (info, pp, &v2))
2193 /* I think this means a variable that is both in a register and
2194 a frame slot. We ignore the frame slot. FIXME. */
2196 namcopy = savestring (name, namlen);
2198 type = debug_make_void_type (dhandle);
2200 pvar->kind = IEEE_LOCAL;
2201 return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
2204 /* Reserved for FORTRAN common. */
2205 ieee_error (info, atn_code_start, "unsupported ATN11");
2207 /* Return true to keep going. */
2211 /* Based variable. */
2215 if (! ieee_read_number (info, pp, &v)
2216 || ! ieee_read_number (info, pp, &v2)
2217 || ! ieee_read_optional_number (info, pp, &v3, &present))
2221 if (! ieee_read_optional_number (info, pp, &v4, &present))
2225 if (! ieee_read_optional_number (info, pp, &v5, &present))
2230 /* We have no way to record this information. FIXME. */
2232 ieee_error (info, atn_code_start, "unsupported ATN12");
2234 /* Return true to keep going. */
2238 /* Constant. The description of this that I have is ambiguous,
2239 so I'm not going to try to implement it. */
2240 if (! ieee_read_number (info, pp, &v)
2241 || ! ieee_read_optional_number (info, pp, &v2, &present))
2245 if (! ieee_read_optional_number (info, pp, &v2, &present))
2249 if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2254 if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
2256 if (! ieee_require_asn (info, pp, &v3))
2263 /* Static variable from assembler. */
2265 if (! ieee_read_number (info, pp, &v)
2266 || ! ieee_read_optional_number (info, pp, &v2, &present)
2267 || ! ieee_require_asn (info, pp, &v3))
2269 namcopy = savestring (name, namlen);
2270 /* We don't really handle this correctly. FIXME. */
2271 return debug_record_variable (dhandle, namcopy,
2272 debug_make_void_type (dhandle),
2273 v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
2277 /* Procedure miscellaneous information. */
2279 /* Variable miscellaneous information. */
2281 /* Module miscellaneous information. */
2282 if (! ieee_read_number (info, pp, &v)
2283 || ! ieee_read_number (info, pp, &v2)
2284 || ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
2287 if (atn_code == 62 && v == 80)
2291 ieee_error (info, atn_code_start,
2292 "unexpected string in C++ misc");
2295 return ieee_read_cxx_misc (info, pp, v2);
2298 /* We just ignore all of this stuff. FIXME. */
2300 for (; v2 > 0; --v2)
2302 switch ((ieee_record_enum_type) **pp)
2305 ieee_error (info, *pp, "bad misc record");
2308 case ieee_at_record_enum:
2309 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2313 case ieee_e2_first_byte_enum:
2314 if (! ieee_require_asn (info, pp, &v3))
2326 /* Handle C++ debugging miscellaneous records. This is called for
2327 procedure miscellaneous records of type 80. */
2330 ieee_read_cxx_misc (info, pp, count)
2331 struct ieee_info *info;
2332 const bfd_byte **pp;
2333 unsigned long count;
2335 const bfd_byte *start;
2340 /* Get the category of C++ misc record. */
2341 if (! ieee_require_asn (info, pp, &category))
2348 ieee_error (info, start, "unrecognized C++ misc record");
2352 if (! ieee_read_cxx_class (info, pp, count))
2360 unsigned long namlen;
2362 /* The IEEE spec indicates that the 'M' record only has a
2363 flags field. The MRI compiler also emits the name of the
2366 if (! ieee_require_asn (info, pp, &flags))
2368 if (*pp < info->pend
2369 && (ieee_record_enum_type) **pp == ieee_at_record_enum)
2371 if (! ieee_require_atn65 (info, pp, &name, &namlen))
2375 /* This is emitted for method functions, but I don't think we
2376 care very much. It might help if it told us useful
2377 information like the class with which this function is
2378 associated, but it doesn't, so it isn't helpful. */
2383 if (! ieee_read_cxx_defaults (info, pp, count))
2389 const char *name, *mangled, *class;
2390 unsigned long namlen, mangledlen, classlen;
2393 /* Pointer to member. */
2395 if (! ieee_require_atn65 (info, pp, &name, &namlen)
2396 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
2397 || ! ieee_require_atn65 (info, pp, &class, &classlen)
2398 || ! ieee_require_asn (info, pp, &control))
2401 /* FIXME: We should now track down name and change its type. */
2406 if (! ieee_read_reference (info, pp))
2414 /* Read a C++ class definition. This is a pmisc type 80 record of
2418 ieee_read_cxx_class (info, pp, count)
2419 struct ieee_info *info;
2420 const bfd_byte **pp;
2421 unsigned long count;
2423 const bfd_byte *start;
2426 unsigned long taglen;
2427 struct ieee_tag *it;
2429 debug_field *fields;
2430 unsigned int field_count, field_alloc;
2431 debug_baseclass *baseclasses;
2432 unsigned int baseclasses_count, baseclasses_alloc;
2433 const debug_field *structfields;
2437 unsigned long namlen;
2438 debug_method_variant *variants;
2442 unsigned int methods_count, methods_alloc;
2443 debug_type vptrbase;
2445 debug_method *dmethods;
2449 if (! ieee_require_asn (info, pp, &class))
2453 if (! ieee_require_atn65 (info, pp, &tag, &taglen))
2457 /* Find the C struct with this name. */
2458 for (it = info->tags; it != NULL; it = it->next)
2459 if (it->name[0] == tag[0]
2460 && strncmp (it->name, tag, taglen) == 0
2461 && strlen (it->name) == taglen)
2465 ieee_error (info, start, "undefined C++ object");
2469 dhandle = info->dhandle;
2475 baseclasses_count = 0;
2476 baseclasses_alloc = 0;
2480 vptrbase = DEBUG_TYPE_NULL;
2483 structfields = debug_get_fields (dhandle, it->type);
2488 const bfd_byte *spec_start;
2492 if (! ieee_require_asn (info, pp, &id))
2499 ieee_error (info, spec_start, "unrecognized C++ object spec");
2504 bfd_vma flags, cinline;
2505 const char *basename, *fieldname;
2506 unsigned long baselen, fieldlen;
2508 debug_type basetype;
2511 enum debug_visibility visibility;
2512 debug_baseclass baseclass;
2514 /* This represents a base or friend class. */
2516 if (! ieee_require_asn (info, pp, &flags)
2517 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
2518 || ! ieee_require_asn (info, pp, &cinline)
2519 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
2523 /* We have no way of recording friend information, so we
2525 if ((flags & BASEFLAGS_FRIEND) != 0)
2528 /* I assume that either all of the members of the
2529 baseclass are included in the object, starting at the
2530 beginning of the object, or that none of them are
2533 if ((fieldlen == 0) == (cinline == 0))
2535 ieee_error (info, start, "unsupported C++ object type");
2539 basecopy = savestring (basename, baselen);
2540 basetype = debug_find_tagged_type (dhandle, basecopy,
2541 DEBUG_KIND_ILLEGAL);
2543 if (basetype == DEBUG_TYPE_NULL)
2545 ieee_error (info, start, "C++ base class not defined");
2553 const debug_field *pf;
2555 if (structfields == NULL)
2557 ieee_error (info, start, "C++ object has no fields");
2561 for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
2565 fname = debug_get_field_name (dhandle, *pf);
2568 if (fname[0] == fieldname[0]
2569 && strncmp (fname, fieldname, fieldlen) == 0
2570 && strlen (fname) == fieldlen)
2573 if (*pf == DEBUG_FIELD_NULL)
2575 ieee_error (info, start,
2576 "C++ base class not found in container");
2580 bitpos = debug_get_field_bitpos (dhandle, *pf);
2583 if ((flags & BASEFLAGS_VIRTUAL) != 0)
2587 if ((flags & BASEFLAGS_PRIVATE) != 0)
2588 visibility = DEBUG_VISIBILITY_PRIVATE;
2590 visibility = DEBUG_VISIBILITY_PUBLIC;
2592 baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
2593 virtualp, visibility);
2594 if (baseclass == DEBUG_BASECLASS_NULL)
2597 if (baseclasses_count + 1 >= baseclasses_alloc)
2599 baseclasses_alloc += 10;
2600 baseclasses = ((debug_baseclass *)
2601 xrealloc (baseclasses,
2603 * sizeof *baseclasses)));
2606 baseclasses[baseclasses_count] = baseclass;
2607 ++baseclasses_count;
2608 baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
2615 const char *fieldname, *mangledname;
2616 unsigned long fieldlen, mangledlen;
2620 const debug_field *pf;
2621 enum debug_visibility visibility;
2624 /* This represents a data member. */
2626 if (! ieee_require_asn (info, pp, &flags)
2627 || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
2628 || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
2632 fieldcopy = savestring (fieldname, fieldlen);
2634 staticp = (flags & CXXFLAGS_STATIC) != 0 ? true : false;
2638 struct ieee_var *pv, *pvend;
2640 /* See if we can find a definition for this variable. */
2641 pv = info->vars.vars;
2642 pvend = pv + info->vars.alloc;
2643 for (; pv < pvend; pv++)
2644 if (pv->namlen == mangledlen
2645 && strncmp (pv->name, mangledname, mangledlen) == 0)
2651 /* This can happen if the variable is never used. */
2652 ftype = ieee_builtin_type (info, start,
2653 (unsigned int) builtin_void);
2660 if (structfields == NULL)
2662 ieee_error (info, start, "C++ object has no fields");
2666 for (pf = structfields, findx = 0;
2667 *pf != DEBUG_FIELD_NULL;
2672 fname = debug_get_field_name (dhandle, *pf);
2675 if (fname[0] == mangledname[0]
2676 && strncmp (fname, mangledname, mangledlen) == 0
2677 && strlen (fname) == mangledlen)
2680 if (*pf == DEBUG_FIELD_NULL)
2682 ieee_error (info, start,
2683 "C++ data member not found in container");
2687 ftype = debug_get_field_type (dhandle, *pf);
2689 if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
2691 /* We might need to convert this field into a
2692 reference type later on, so make it an indirect
2694 if (it->fslots == NULL)
2697 const debug_field *pfcnt;
2700 for (pfcnt = structfields;
2701 *pfcnt != DEBUG_FIELD_NULL;
2704 it->fslots = ((debug_type *)
2705 xmalloc (fcnt * sizeof *it->fslots));
2706 memset (it->fslots, 0,
2707 fcnt * sizeof *it->fslots);
2710 if (ftype == DEBUG_TYPE_NULL)
2712 it->fslots[findx] = ftype;
2713 ftype = debug_make_indirect_type (dhandle,
2715 (const char *) NULL);
2718 if (ftype == DEBUG_TYPE_NULL)
2721 switch (flags & CXXFLAGS_VISIBILITY)
2724 ieee_error (info, start, "unknown C++ visibility");
2727 case CXXFLAGS_VISIBILITY_PUBLIC:
2728 visibility = DEBUG_VISIBILITY_PUBLIC;
2731 case CXXFLAGS_VISIBILITY_PRIVATE:
2732 visibility = DEBUG_VISIBILITY_PRIVATE;
2735 case CXXFLAGS_VISIBILITY_PROTECTED:
2736 visibility = DEBUG_VISIBILITY_PROTECTED;
2744 mangledcopy = savestring (mangledname, mangledlen);
2746 field = debug_make_static_member (dhandle, fieldcopy,
2752 bfd_vma bitpos, bitsize;
2754 bitpos = debug_get_field_bitpos (dhandle, *pf);
2755 bitsize = debug_get_field_bitsize (dhandle, *pf);
2756 if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1)
2758 ieee_error (info, start, "bad C++ field bit pos or size");
2761 field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
2762 bitsize, visibility);
2765 if (field == DEBUG_FIELD_NULL)
2768 if (field_count + 1 >= field_alloc)
2771 fields = ((debug_field *)
2772 xrealloc (fields, field_alloc * sizeof *fields));
2775 fields[field_count] = field;
2777 fields[field_count] = DEBUG_FIELD_NULL;
2784 bfd_vma flags, virtindex, control;
2785 const char *name, *mangled;
2786 unsigned long namlen, mangledlen;
2787 struct ieee_var *pv, *pvend;
2789 enum debug_visibility visibility;
2790 boolean constp, volatilep;
2792 debug_method_variant mv;
2793 struct ieee_method *meth;
2796 if (! ieee_require_asn (info, pp, &flags)
2797 || ! ieee_require_atn65 (info, pp, &name, &namlen)
2798 || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2803 if (! ieee_require_asn (info, pp, &virtindex))
2807 if (! ieee_require_asn (info, pp, &control))
2811 /* We just ignore the control information. */
2813 /* We have no way to represent friend information, so we
2815 if ((flags & CXXFLAGS_FRIEND) != 0)
2818 /* We should already have seen a type for the function. */
2819 pv = info->vars.vars;
2820 pvend = pv + info->vars.alloc;
2821 for (; pv < pvend; pv++)
2822 if (pv->namlen == mangledlen
2823 && strncmp (pv->name, mangled, mangledlen) == 0)
2828 /* We won't have type information for this function if
2829 it is not included in this file. We don't try to
2830 handle this case. FIXME. */
2831 type = (debug_make_function_type
2833 ieee_builtin_type (info, start,
2834 (unsigned int) builtin_void),
2835 (debug_type *) NULL,
2840 debug_type return_type;
2841 const debug_type *arg_types;
2844 if (debug_get_type_kind (dhandle, pv->type)
2845 != DEBUG_KIND_FUNCTION)
2847 ieee_error (info, start,
2848 "bad type for C++ method function");
2852 return_type = debug_get_return_type (dhandle, pv->type);
2853 arg_types = debug_get_parameter_types (dhandle, pv->type,
2855 if (return_type == DEBUG_TYPE_NULL || arg_types == NULL)
2857 ieee_error (info, start,
2858 "no type information for C++ method function");
2862 type = debug_make_method_type (dhandle, return_type, it->type,
2863 (debug_type *) arg_types,
2866 if (type == DEBUG_TYPE_NULL)
2869 switch (flags & CXXFLAGS_VISIBILITY)
2872 ieee_error (info, start, "unknown C++ visibility");
2875 case CXXFLAGS_VISIBILITY_PUBLIC:
2876 visibility = DEBUG_VISIBILITY_PUBLIC;
2879 case CXXFLAGS_VISIBILITY_PRIVATE:
2880 visibility = DEBUG_VISIBILITY_PRIVATE;
2883 case CXXFLAGS_VISIBILITY_PROTECTED:
2884 visibility = DEBUG_VISIBILITY_PROTECTED;
2888 constp = (flags & CXXFLAGS_CONST) != 0 ? true : false;
2889 volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? true : false;
2891 mangledcopy = savestring (mangled, mangledlen);
2893 if ((flags & CXXFLAGS_STATIC) != 0)
2897 ieee_error (info, start, "C++ static virtual method");
2900 mv = debug_make_static_method_variant (dhandle, mangledcopy,
2907 debug_type vcontext;
2912 vcontext = DEBUG_TYPE_NULL;
2916 /* FIXME: This should depend upon the pointer
2918 voffset = virtindex * 4;
2919 /* FIXME: How can we calculate this correctly? */
2920 vcontext = it->type;
2922 mv = debug_make_method_variant (dhandle, mangledcopy, type,
2927 if (mv == DEBUG_METHOD_VARIANT_NULL)
2930 for (meth = methods, im = 0; im < methods_count; meth++, im++)
2931 if (meth->namlen == namlen
2932 && strncmp (meth->name, name, namlen) == 0)
2934 if (im >= methods_count)
2936 if (methods_count >= methods_alloc)
2938 methods_alloc += 10;
2939 methods = ((struct ieee_method *)
2941 methods_alloc * sizeof *methods));
2943 methods[methods_count].name = name;
2944 methods[methods_count].namlen = namlen;
2945 methods[methods_count].variants = NULL;
2946 methods[methods_count].count = 0;
2947 methods[methods_count].alloc = 0;
2948 meth = methods + methods_count;
2952 if (meth->count + 1 >= meth->alloc)
2955 meth->variants = ((debug_method_variant *)
2956 xrealloc (meth->variants,
2958 * sizeof *meth->variants)));
2961 meth->variants[meth->count] = mv;
2963 meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
2971 /* We have no way to store this information, so we just
2973 if (! ieee_require_asn (info, pp, &spec))
2976 if ((spec & 4) != 0)
2978 const char *filename;
2979 unsigned long filenamlen;
2982 if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
2983 || ! ieee_require_asn (info, pp, &lineno))
2987 else if ((spec & 8) != 0)
2989 const char *mangled;
2990 unsigned long mangledlen;
2992 if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
2998 ieee_error (info, start,
2999 "unrecognized C++ object overhead spec");
3007 const char *vname, *basename;
3008 unsigned long vnamelen, baselen;
3009 bfd_vma vsize, control;
3011 /* A virtual table pointer. */
3013 if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
3014 || ! ieee_require_asn (info, pp, &vsize)
3015 || ! ieee_require_atn65 (info, pp, &basename, &baselen)
3016 || ! ieee_require_asn (info, pp, &control))
3020 /* We just ignore the control number. We don't care what
3021 the virtual table name is. We have no way to store the
3022 virtual table size, and I don't think we care anyhow. */
3024 /* FIXME: We can't handle multiple virtual table pointers. */
3032 basecopy = savestring (basename, baselen);
3033 vptrbase = debug_find_tagged_type (dhandle, basecopy,
3034 DEBUG_KIND_ILLEGAL);
3036 if (vptrbase == DEBUG_TYPE_NULL)
3038 ieee_error (info, start, "undefined C++ vtable");
3047 /* Now that we have seen all the method variants, we can call
3048 debug_make_method for each one. */
3050 if (methods_count == 0)
3056 dmethods = ((debug_method *)
3057 xmalloc ((methods_count + 1) * sizeof *dmethods));
3058 for (i = 0; i < methods_count; i++)
3062 namcopy = savestring (methods[i].name, methods[i].namlen);
3063 dmethods[i] = debug_make_method (dhandle, namcopy,
3064 methods[i].variants);
3065 if (dmethods[i] == DEBUG_METHOD_NULL)
3068 dmethods[i] = DEBUG_METHOD_NULL;
3072 /* The struct type was created as an indirect type pointing at
3073 it->slot. We update it->slot to automatically update all
3074 references to this struct. */
3075 it->slot = debug_make_object_type (dhandle,
3077 debug_get_type_size (dhandle,
3079 fields, baseclasses, dmethods,
3081 if (it->slot == DEBUG_TYPE_NULL)
3087 /* Read C++ default argument value and reference type information. */
3090 ieee_read_cxx_defaults (info, pp, count)
3091 struct ieee_info *info;
3092 const bfd_byte **pp;
3093 unsigned long count;
3095 const bfd_byte *start;
3097 unsigned long fnlen;
3102 /* Giving the function name before the argument count is an addendum
3103 to the spec. The function name is demangled, though, so this
3104 record must always refer to the current function. */
3106 if (info->blockstack.bsp <= info->blockstack.stack
3107 || info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
3109 ieee_error (info, start, "C++ default values not in a function");
3113 if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
3114 || ! ieee_require_asn (info, pp, &defcount))
3118 while (defcount-- > 0)
3122 unsigned long strvallen;
3124 if (! ieee_require_asn (info, pp, &type))
3136 if (! ieee_require_asn (info, pp, &val))
3143 if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
3149 ieee_error (info, start, "unrecognized C++ default type");
3153 /* We have no way to record the default argument values, so we
3154 just ignore them. FIXME. */
3157 /* Any remaining arguments are indices of parameters that are really
3162 debug_type *arg_slots;
3164 dhandle = info->dhandle;
3165 arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
3171 if (! ieee_require_asn (info, pp, &indx))
3173 /* The index is 1 based. */
3175 if (arg_slots == NULL
3176 || arg_slots[indx] == DEBUG_TYPE_NULL
3177 || (debug_get_type_kind (dhandle, arg_slots[indx])
3178 != DEBUG_KIND_POINTER))
3180 ieee_error (info, start, "reference parameter is not a pointer");
3184 target = debug_get_target_type (dhandle, arg_slots[indx]);
3185 arg_slots[indx] = debug_make_reference_type (dhandle, target);
3186 if (arg_slots[indx] == DEBUG_TYPE_NULL)
3194 /* Read a C++ reference definition. */
3197 ieee_read_reference (info, pp)
3198 struct ieee_info *info;
3199 const bfd_byte **pp;
3201 const bfd_byte *start;
3203 const char *class, *name;
3204 unsigned long classlen, namlen;
3210 if (! ieee_require_asn (info, pp, &flags))
3213 /* Giving the class name before the member name is in an addendum to
3217 if (! ieee_require_atn65 (info, pp, &class, &classlen))
3221 if (! ieee_require_atn65 (info, pp, &name, &namlen))
3228 struct ieee_var *pv = NULL;
3230 /* We search from the last variable indices to the first in
3231 hopes of finding local variables correctly. FIXME: This
3232 probably won't work in all cases. On the other hand, I don't
3234 for (i = (int) info->vars.alloc - 1; i >= 0; i--)
3238 pv = info->vars.vars + i;
3240 if (pv->pslot == NULL
3241 || pv->namlen != namlen
3242 || strncmp (pv->name, name, namlen) != 0)
3249 ieee_error (info, start,
3250 "unrecognized C++ reference type");
3254 /* Global variable or function. */
3255 if (pv->kind == IEEE_GLOBAL
3256 || pv->kind == IEEE_EXTERNAL
3257 || pv->kind == IEEE_FUNCTION)
3262 /* Global static variable or function. */
3263 if (pv->kind == IEEE_STATIC
3264 || pv->kind == IEEE_FUNCTION)
3269 /* Local variable. */
3270 if (pv->kind == IEEE_LOCAL)
3284 struct ieee_tag *it;
3286 for (it = info->tags; it != NULL; it = it->next)
3288 if (it->name[0] == class[0]
3289 && strncmp (it->name, class, classlen) == 0
3290 && strlen (it->name) == classlen)
3292 if (it->fslots != NULL)
3294 const debug_field *pf;
3297 pf = debug_get_fields (info->dhandle, it->type);
3300 ieee_error (info, start,
3301 "C++ reference in class with no fields");
3305 for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
3309 fname = debug_get_field_name (info->dhandle, *pf);
3312 if (strncmp (fname, name, namlen) == 0
3313 && strlen (fname) == namlen)
3315 pslot = it->fslots + findx;
3328 ieee_error (info, start, "C++ reference not found");
3332 /* We allocated the type of the object as an indirect type pointing
3333 to *pslot, which we can now update to be a reference type. */
3334 if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
3336 ieee_error (info, start, "C++ reference is not pointer");
3340 target = debug_get_target_type (info->dhandle, *pslot);
3341 *pslot = debug_make_reference_type (info->dhandle, target);
3342 if (*pslot == DEBUG_TYPE_NULL)
3348 /* Require an ASN record. */
3351 ieee_require_asn (info, pp, pv)
3352 struct ieee_info *info;
3353 const bfd_byte **pp;
3356 const bfd_byte *start;
3357 ieee_record_enum_type c;
3362 c = (ieee_record_enum_type) **pp;
3363 if (c != ieee_e2_first_byte_enum)
3365 ieee_error (info, start, "missing required ASN");
3370 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3371 if (c != ieee_asn_record_enum)
3373 ieee_error (info, start, "missing required ASN");
3378 /* Just ignore the variable index. */
3379 if (! ieee_read_number (info, pp, &varindx))
3382 return ieee_read_expression (info, pp, pv);
3385 /* Require an ATN65 record. */
3388 ieee_require_atn65 (info, pp, pname, pnamlen)
3389 struct ieee_info *info;
3390 const bfd_byte **pp;
3392 unsigned long *pnamlen;
3394 const bfd_byte *start;
3395 ieee_record_enum_type c;
3396 bfd_vma name_indx, type_indx, atn_code;
3400 c = (ieee_record_enum_type) **pp;
3401 if (c != ieee_at_record_enum)
3403 ieee_error (info, start, "missing required ATN65");
3408 c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp);
3409 if (c != ieee_atn_record_enum)
3411 ieee_error (info, start, "missing required ATN65");
3416 if (! ieee_read_number (info, pp, &name_indx)
3417 || ! ieee_read_number (info, pp, &type_indx)
3418 || ! ieee_read_number (info, pp, &atn_code))
3421 /* Just ignore name_indx. */
3423 if (type_indx != 0 || atn_code != 65)
3425 ieee_error (info, start, "bad ATN65 record");
3429 return ieee_read_id (info, pp, pname, pnamlen);
3432 /* Convert a register number in IEEE debugging information into a
3433 generic register number. */
3436 ieee_regno_to_genreg (abfd, r)
3443 /* Convert a generic register number to an IEEE specific one. */
3446 ieee_genreg_to_regno (abfd, r)
3453 /* These routines build IEEE debugging information out of the generic
3454 debugging information. */
3456 /* We build the IEEE debugging information byte by byte. Rather than
3457 waste time copying data around, we use a linked list of buffers to
3460 #define IEEE_BUFSIZE (490)
3465 struct ieee_buf *next;
3466 /* Number of data bytes in this buffer. */
3469 bfd_byte buf[IEEE_BUFSIZE];
3472 /* In order to generate the BB11 blocks required by the HP emulator,
3473 we keep track of ranges of addresses which correspond to a given
3474 compilation unit. */
3479 struct ieee_range *next;
3486 /* This structure holds information for a class on the type stack. */
3488 struct ieee_type_class
3490 /* The name of the class. */
3492 /* The name index in the debugging information. */
3494 /* The pmisc records for the class. */
3495 struct ieee_buf *pmiscbuf;
3496 /* The number of pmisc records. */
3497 unsigned int pmisccount;
3498 /* The name of the class holding the virtual table, if not this
3501 /* Whether this class holds its own virtual table. */
3503 /* The largest virtual table offset seen so far. */
3505 /* The current method. */
3507 /* Additional pmisc records used to record fields of reference type. */
3508 struct ieee_buf *refs;
3511 /* This is how we store types for the writing routines. Most types
3512 are simply represented by a type index. */
3514 struct ieee_write_type
3518 /* The size of the type, if known. */
3520 /* If this is a function or method type, we build the type here, and
3521 only add it to the output buffers if we need it. */
3522 struct ieee_buf *fndef;
3523 /* If this is a struct, this is where the struct definition is
3525 struct ieee_buf *strdef;
3526 /* If this is a class, this is where the class information is built. */
3527 struct ieee_type_class *classdef;
3528 /* Whether the type is unsigned. */
3529 unsigned int unsignedp : 1;
3530 /* Whether this is a reference type. */
3531 unsigned int referencep : 1;
3534 /* This is the type stack used by the debug writing routines. FIXME:
3535 We could generate more efficient output if we remembered when we
3536 have output a particular type before. */
3538 struct ieee_type_stack
3540 /* Next entry on stack. */
3541 struct ieee_type_stack *next;
3542 /* Type information. */
3543 struct ieee_write_type type;
3546 /* This is a list of associations between names and types. This could
3547 be more efficiently implemented as a hash table. */
3549 struct ieee_name_type
3551 /* Next name/type assocation. */
3552 struct ieee_name_type *next;
3556 struct ieee_write_type type;
3557 /* If this is a tag which has not yet been defined, this is the
3558 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3559 enum debug_type_kind kind;
3562 /* We keep a list of modified versions of types, so that we don't
3563 output them more than once. */
3565 struct ieee_modified_type
3567 /* Pointer to this type. */
3568 unsigned int pointer;
3569 /* Const version of this type. */
3570 unsigned int const_qualified;
3571 /* Volatile version of this type. */
3572 unsigned int volatile_qualified;
3575 /* This is a list of pending function parameter information. We don't
3576 output them until we see the first block. */
3578 struct ieee_pending_parm
3580 /* Next pending parameter. */
3581 struct ieee_pending_parm *next;
3586 /* Whether the type is a reference. */
3589 enum debug_parm_kind kind;
3594 /* This is the handle passed down by debug_write. */
3598 /* BFD we are writing to. */
3600 /* Current data buffer. */
3601 struct ieee_buf *current;
3602 /* Filename of current compilation unit. */
3603 const char *filename;
3604 /* Module name of current compilation unit. */
3605 const char *modname;
3606 /* List of finished data buffers. */
3607 struct ieee_buf *data;
3608 /* List of buffers for typedefs in the current compilation unit. */
3609 struct ieee_buf *types;
3610 /* List of buffers for variables and functions in the current
3611 compilation unit. */
3612 struct ieee_buf *vars;
3613 /* List of buffers for C++ class definitions in the current
3614 compilation unit. */
3615 struct ieee_buf *cxx;
3616 /* List of buffers for line numbers in the current compilation unit. */
3617 struct ieee_buf *linenos;
3618 /* Ranges for the current compilation unit. */
3619 struct ieee_range *ranges;
3620 /* Nested pending ranges. */
3621 struct ieee_range *pending_ranges;
3623 struct ieee_type_stack *type_stack;
3624 /* Next unallocated type index. */
3625 unsigned int type_indx;
3626 /* Next unallocated name index. */
3627 unsigned int name_indx;
3629 struct ieee_name_type *typedefs;
3631 struct ieee_name_type *tags;
3632 /* Modified versions of types. */
3633 struct ieee_modified_type *modified;
3634 /* Number of entries allocated in modified. */
3635 unsigned int modified_alloc;
3636 /* The depth of block nesting. This is 0 outside a function, and 1
3637 just after start_function is called. */
3638 unsigned int block_depth;
3639 /* The name of the current function. */
3641 /* List of buffers for the type of the function we are currently
3643 struct ieee_buf *fntype;
3644 /* List of buffers for the parameters of the function we are
3645 currently writing out. */
3646 struct ieee_buf *fnargs;
3647 /* Number of arguments written to fnargs. */
3648 unsigned int fnargcount;
3649 /* Pending function parameters. */
3650 struct ieee_pending_parm *pending_parms;
3651 /* Current line number filename. */
3652 const char *lineno_filename;
3653 /* Line number name index. */
3654 unsigned int lineno_name_indx;
3655 /* Highest address seen at end of procedure. */
3659 static boolean ieee_change_buffer
3660 PARAMS ((struct ieee_handle *, struct ieee_buf **));
3661 static boolean ieee_real_write_byte PARAMS ((struct ieee_handle *, int));
3662 static boolean ieee_write_2bytes PARAMS ((struct ieee_handle *, int));
3663 static boolean ieee_write_number PARAMS ((struct ieee_handle *, bfd_vma));
3664 static boolean ieee_write_id PARAMS ((struct ieee_handle *, const char *));
3665 static boolean ieee_write_asn
3666 PARAMS ((struct ieee_handle *, unsigned int, bfd_vma));
3667 static boolean ieee_write_atn65
3668 PARAMS ((struct ieee_handle *, unsigned int, const char *));
3669 static boolean ieee_push_type
3670 PARAMS ((struct ieee_handle *, unsigned int, unsigned int, boolean));
3671 static unsigned int ieee_pop_type PARAMS ((struct ieee_handle *));
3672 static void ieee_pop_unused_type PARAMS ((struct ieee_handle *));
3673 static unsigned int ieee_pop_type_used
3674 PARAMS ((struct ieee_handle *, boolean));
3675 static boolean ieee_add_range
3676 PARAMS ((struct ieee_handle *, bfd_vma, bfd_vma));
3677 static boolean ieee_start_range PARAMS ((struct ieee_handle *, bfd_vma));
3678 static boolean ieee_end_range PARAMS ((struct ieee_handle *, bfd_vma));
3679 static boolean ieee_define_type
3680 PARAMS ((struct ieee_handle *, unsigned int, boolean));
3681 static boolean ieee_define_named_type
3682 PARAMS ((struct ieee_handle *, const char *, boolean, unsigned int,
3683 unsigned int, boolean, struct ieee_buf **));
3684 static struct ieee_modified_type *ieee_get_modified_info
3685 PARAMS ((struct ieee_handle *, unsigned int));
3686 static boolean ieee_finish_compilation_unit PARAMS ((struct ieee_handle *));
3687 static boolean ieee_output_pending_parms PARAMS ((struct ieee_handle *));
3688 static unsigned int ieee_vis_to_flags PARAMS ((enum debug_visibility));
3689 static boolean ieee_class_method_var
3690 PARAMS ((struct ieee_handle *, const char *, enum debug_visibility, boolean,
3691 boolean, boolean, bfd_vma, boolean));
3693 static boolean ieee_start_compilation_unit PARAMS ((PTR, const char *));
3694 static boolean ieee_start_source PARAMS ((PTR, const char *));
3695 static boolean ieee_empty_type PARAMS ((PTR));
3696 static boolean ieee_void_type PARAMS ((PTR));
3697 static boolean ieee_int_type PARAMS ((PTR, unsigned int, boolean));
3698 static boolean ieee_float_type PARAMS ((PTR, unsigned int));
3699 static boolean ieee_complex_type PARAMS ((PTR, unsigned int));
3700 static boolean ieee_bool_type PARAMS ((PTR, unsigned int));
3701 static boolean ieee_enum_type
3702 PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
3703 static boolean ieee_pointer_type PARAMS ((PTR));
3704 static boolean ieee_function_type PARAMS ((PTR, int, boolean));
3705 static boolean ieee_reference_type PARAMS ((PTR));
3706 static boolean ieee_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
3707 static boolean ieee_array_type
3708 PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
3709 static boolean ieee_set_type PARAMS ((PTR, boolean));
3710 static boolean ieee_offset_type PARAMS ((PTR));
3711 static boolean ieee_method_type PARAMS ((PTR, boolean, int, boolean));
3712 static boolean ieee_const_type PARAMS ((PTR));
3713 static boolean ieee_volatile_type PARAMS ((PTR));
3714 static boolean ieee_start_struct_type
3715 PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
3716 static boolean ieee_struct_field
3717 PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
3718 static boolean ieee_end_struct_type PARAMS ((PTR));
3719 static boolean ieee_start_class_type
3720 PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
3722 static boolean ieee_class_static_member
3723 PARAMS ((PTR, const char *, const char *, enum debug_visibility));
3724 static boolean ieee_class_baseclass
3725 PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
3726 static boolean ieee_class_start_method PARAMS ((PTR, const char *));
3727 static boolean ieee_class_method_variant
3728 PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
3730 static boolean ieee_class_static_method_variant
3731 PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
3732 static boolean ieee_class_end_method PARAMS ((PTR));
3733 static boolean ieee_end_class_type PARAMS ((PTR));
3734 static boolean ieee_typedef_type PARAMS ((PTR, const char *));
3735 static boolean ieee_tag_type
3736 PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
3737 static boolean ieee_typdef PARAMS ((PTR, const char *));
3738 static boolean ieee_tag PARAMS ((PTR, const char *));
3739 static boolean ieee_int_constant PARAMS ((PTR, const char *, bfd_vma));
3740 static boolean ieee_float_constant PARAMS ((PTR, const char *, double));
3741 static boolean ieee_typed_constant PARAMS ((PTR, const char *, bfd_vma));
3742 static boolean ieee_variable
3743 PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
3744 static boolean ieee_start_function PARAMS ((PTR, const char *, boolean));
3745 static boolean ieee_function_parameter
3746 PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
3747 static boolean ieee_start_block PARAMS ((PTR, bfd_vma));
3748 static boolean ieee_end_block PARAMS ((PTR, bfd_vma));
3749 static boolean ieee_end_function PARAMS ((PTR));
3750 static boolean ieee_lineno
3751 PARAMS ((PTR, const char *, unsigned long, bfd_vma));
3753 static const struct debug_write_fns ieee_fns =
3755 ieee_start_compilation_unit,
3766 ieee_reference_type,
3774 ieee_start_struct_type,
3776 ieee_end_struct_type,
3777 ieee_start_class_type,
3778 ieee_class_static_member,
3779 ieee_class_baseclass,
3780 ieee_class_start_method,
3781 ieee_class_method_variant,
3782 ieee_class_static_method_variant,
3783 ieee_class_end_method,
3784 ieee_end_class_type,
3790 ieee_float_constant,
3791 ieee_typed_constant,
3793 ieee_start_function,
3794 ieee_function_parameter,
3801 /* Change the current buffer to a specified buffer chain. */
3804 ieee_change_buffer (info, ppbuf)
3805 struct ieee_handle *info;
3806 struct ieee_buf **ppbuf;
3808 struct ieee_buf *buf;
3812 for (buf = *ppbuf; buf->next != NULL; buf = buf->next)
3817 buf = (struct ieee_buf *) xmalloc (sizeof *buf);
3823 info->current = buf;
3827 /* Write a byte into the buffer. We use a macro for speed and a
3828 function for the complex cases. */
3830 #define ieee_write_byte(info, b) \
3831 ((info)->current->c < IEEE_BUFSIZE \
3832 ? ((info)->current->buf[(info)->current->c++] = (b), true) \
3833 : ieee_real_write_byte ((info), (b)))
3836 ieee_real_write_byte (info, b)
3837 struct ieee_handle *info;
3840 if (info->current->c >= IEEE_BUFSIZE)
3844 n = (struct ieee_buf *) xmalloc (sizeof *n);
3847 info->current->next = n;
3851 info->current->buf[info->current->c] = b;
3857 /* Write out two bytes. */
3860 ieee_write_2bytes (info, i)
3861 struct ieee_handle *info;
3864 return (ieee_write_byte (info, i >> 8)
3865 && ieee_write_byte (info, i & 0xff));
3868 /* Write out an integer. */
3871 ieee_write_number (info, v)
3872 struct ieee_handle *info;
3880 if (v <= (bfd_vma) ieee_number_end_enum)
3881 return ieee_write_byte (info, (int) v);
3892 if (c > (unsigned int) (ieee_number_repeat_end_enum
3893 - ieee_number_repeat_start_enum))
3895 fprintf (stderr, "IEEE numeric overflow: 0x");
3896 fprintf_vma (stderr, v);
3897 fprintf (stderr, "\n");
3901 if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
3903 for (; c > 0; --c, ++p)
3905 if (! ieee_write_byte (info, *p))
3912 /* Write out a string. */
3915 ieee_write_id (info, s)
3916 struct ieee_handle *info;
3924 if (! ieee_write_byte (info, len))
3927 else if (len <= 0xff)
3929 if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
3930 || ! ieee_write_byte (info, len))
3933 else if (len <= 0xffff)
3935 if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
3936 || ! ieee_write_2bytes (info, len))
3941 fprintf (stderr, "IEEE string length overflow: %u\n", len);
3945 for (; *s != '\0'; s++)
3946 if (! ieee_write_byte (info, *s))
3952 /* Write out an ASN record. */
3955 ieee_write_asn (info, indx, val)
3956 struct ieee_handle *info;
3960 return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
3961 && ieee_write_number (info, indx)
3962 && ieee_write_number (info, val));
3965 /* Write out an ATN65 record. */
3968 ieee_write_atn65 (info, indx, s)
3969 struct ieee_handle *info;
3973 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
3974 && ieee_write_number (info, indx)
3975 && ieee_write_number (info, 0)
3976 && ieee_write_number (info, 65)
3977 && ieee_write_id (info, s));
3980 /* Push a type index onto the type stack. */
3983 ieee_push_type (info, indx, size, unsignedp)
3984 struct ieee_handle *info;
3989 struct ieee_type_stack *ts;
3991 ts = (struct ieee_type_stack *) xmalloc (sizeof *ts);
3992 memset (ts, 0, sizeof *ts);
3994 ts->type.indx = indx;
3995 ts->type.size = size;
3996 ts->type.unsignedp = unsignedp;
3998 ts->next = info->type_stack;
3999 info->type_stack = ts;
4004 /* Pop a type index off the type stack. */
4007 ieee_pop_type (info)
4008 struct ieee_handle *info;
4010 return ieee_pop_type_used (info, true);
4013 /* Pop an unused type index off the type stack. */
4016 ieee_pop_unused_type (info)
4017 struct ieee_handle *info;
4019 (void) ieee_pop_type_used (info, false);
4022 /* Pop a used or unused type index off the type stack. */
4025 ieee_pop_type_used (info, used)
4026 struct ieee_handle *info;
4029 struct ieee_type_stack *ts;
4032 ts = info->type_stack;
4033 assert (ts != NULL);
4035 /* If this is a function type, and we need it, we need to append the
4036 actual definition to the typedef block now. */
4037 if (ts->type.fndef != NULL && used)
4039 struct ieee_buf **pb;
4041 /* Make sure we have started the types block. */
4042 if (info->types == NULL)
4044 if (! ieee_change_buffer (info, &info->types)
4045 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4046 || ! ieee_write_byte (info, 1)
4047 || ! ieee_write_number (info, 0)
4048 || ! ieee_write_id (info, info->modname))
4052 for (pb = &info->types; *pb != NULL; pb = &(*pb)->next)
4054 *pb = ts->type.fndef;
4057 ret = ts->type.indx;
4058 info->type_stack = ts->next;
4063 /* Add a range of bytes included in the current compilation unit. */
4066 ieee_add_range (info, low, high)
4067 struct ieee_handle *info;
4071 struct ieee_range *r, **pr;
4073 if (low == (bfd_vma) -1 || high == (bfd_vma) -1)
4076 for (r = info->ranges; r != NULL; r = r->next)
4078 if (high >= r->low && low <= r->high)
4080 /* The new range overlaps r. */
4086 while (*pr != NULL && (*pr)->low <= r->high)
4088 struct ieee_range *n;
4090 if ((*pr)->high > r->high)
4091 r->high = (*pr)->high;
4100 r = (struct ieee_range *) xmalloc (sizeof *r);
4101 memset (r, 0, sizeof *r);
4106 /* Store the ranges sorted by address. */
4107 for (pr = &info->ranges; *pr != NULL; pr = &(*pr)->next)
4108 if ((*pr)->next != NULL && (*pr)->next->low > high)
4116 /* Start a new range for which we only have the low address. */
4119 ieee_start_range (info, low)
4120 struct ieee_handle *info;
4123 struct ieee_range *r;
4125 r = (struct ieee_range *) xmalloc (sizeof *r);
4126 memset (r, 0, sizeof *r);
4128 r->next = info->pending_ranges;
4129 info->pending_ranges = r;
4133 /* Finish a range started by ieee_start_range. */
4136 ieee_end_range (info, high)
4137 struct ieee_handle *info;
4140 struct ieee_range *r;
4143 assert (info->pending_ranges != NULL);
4144 r = info->pending_ranges;
4146 info->pending_ranges = r->next;
4148 return ieee_add_range (info, low, high);
4151 /* Start defining a type. */
4154 ieee_define_type (info, size, unsignedp)
4155 struct ieee_handle *info;
4159 return ieee_define_named_type (info, (const char *) NULL, false, 0, size,
4160 unsignedp, (struct ieee_buf **) NULL);
4163 /* Start defining a named type. */
4166 ieee_define_named_type (info, name, tagp, id, size, unsignedp, ppbuf)
4167 struct ieee_handle *info;
4173 struct ieee_buf **ppbuf;
4175 unsigned int type_indx;
4176 unsigned int name_indx;
4178 if (! tagp || id == (unsigned int) -1)
4180 type_indx = info->type_indx;
4185 struct ieee_name_type *nt;
4189 /* We need to create a tag for internal use even if we don't
4190 want one for external use. This will let us refer to an
4191 anonymous struct. */
4196 sprintf (ab, "__anon%u", id);
4200 /* The name is a tag. If we have already defined the tag, we
4201 must use the existing type index. */
4202 for (nt = info->tags; nt != NULL; nt = nt->next)
4203 if (nt->name[0] == tag[0]
4204 && strcmp (nt->name, tag) == 0)
4209 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
4210 memset (nt, 0, sizeof *nt);
4214 nt->next = info->tags;
4216 nt->type.indx = info->type_indx;
4220 nt->type.size = size;
4221 nt->type.unsignedp = unsignedp;
4222 nt->kind = DEBUG_KIND_ILLEGAL;
4224 type_indx = nt->type.indx;
4227 name_indx = info->name_indx;
4233 /* If we were given a buffer, use it; otherwise, use the general
4234 type information, and make sure that the type block is started. */
4237 if (! ieee_change_buffer (info, ppbuf))
4240 else if (info->types != NULL)
4242 if (! ieee_change_buffer (info, &info->types))
4247 if (! ieee_change_buffer (info, &info->types)
4248 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4249 || ! ieee_write_byte (info, 1)
4250 || ! ieee_write_number (info, 0)
4251 || ! ieee_write_id (info, info->modname))
4255 /* Push the new type on the type stack, write out an NN record, and
4256 write out the start of a TY record. The caller will then finish
4258 return (ieee_push_type (info, type_indx, size, unsignedp)
4259 && ieee_write_byte (info, (int) ieee_nn_record)
4260 && ieee_write_number (info, name_indx)
4261 && ieee_write_id (info, name)
4262 && ieee_write_byte (info, (int) ieee_ty_record_enum)
4263 && ieee_write_number (info, type_indx)
4264 && ieee_write_byte (info, 0xce)
4265 && ieee_write_number (info, name_indx));
4268 /* Get an entry to the list of modified versions of a type. */
4270 static struct ieee_modified_type *
4271 ieee_get_modified_info (info, indx)
4272 struct ieee_handle *info;
4275 if (indx >= info->modified_alloc)
4277 unsigned int nalloc;
4279 nalloc = info->modified_alloc;
4282 while (indx >= nalloc)
4284 info->modified = ((struct ieee_modified_type *)
4285 xrealloc (info->modified,
4286 nalloc * sizeof *info->modified));
4287 memset (info->modified + info->modified_alloc, 0,
4288 (nalloc - info->modified_alloc) * sizeof *info->modified);
4289 info->modified_alloc = nalloc;
4292 return info->modified + indx;
4295 /* The general routine to write out IEEE debugging information. */
4298 write_ieee_debugging_info (abfd, dhandle)
4302 struct ieee_handle info;
4303 struct ieee_buf *tags;
4304 struct ieee_name_type *nt;
4309 memset (&info, 0, sizeof info);
4311 info.type_indx = 256;
4312 info.name_indx = 32;
4314 if (! debug_write (dhandle, &ieee_fns, (PTR) &info))
4317 if (info.filename != NULL)
4319 if (! ieee_finish_compilation_unit (&info))
4323 /* Put any undefined tags in the global typedef information. */
4325 for (nt = info.tags; nt != NULL; nt = nt->next)
4327 unsigned int name_indx;
4330 if (nt->kind == DEBUG_KIND_ILLEGAL)
4334 if (! ieee_change_buffer (&info, &tags)
4335 || ! ieee_write_byte (&info, (int) ieee_bb_record_enum)
4336 || ! ieee_write_byte (&info, 2)
4337 || ! ieee_write_number (&info, 0)
4338 || ! ieee_write_id (&info, ""))
4341 name_indx = info.name_indx;
4343 if (! ieee_write_byte (&info, (int) ieee_nn_record)
4344 || ! ieee_write_number (&info, name_indx)
4345 || ! ieee_write_id (&info, nt->name)
4346 || ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
4347 || ! ieee_write_number (&info, nt->type.indx)
4348 || ! ieee_write_byte (&info, 0xce)
4349 || ! ieee_write_number (&info, name_indx))
4356 case DEBUG_KIND_STRUCT:
4357 case DEBUG_KIND_CLASS:
4360 case DEBUG_KIND_UNION:
4361 case DEBUG_KIND_UNION_CLASS:
4364 case DEBUG_KIND_ENUM:
4368 if (! ieee_write_number (&info, code)
4369 || ! ieee_write_number (&info, 0))
4374 struct ieee_buf **pb;
4376 if (! ieee_write_byte (&info, (int) ieee_be_record_enum))
4379 for (pb = &tags; *pb != NULL; pb = &(*pb)->next)
4385 /* Now all the data is in info.data. Write it out to the BFD. We
4386 normally would need to worry about whether all the other sections
4387 are set up yet, but the IEEE backend will handle this particular
4388 case correctly regardless. */
4389 if (info.data == NULL)
4391 /* There is no debugging information. */
4395 s = bfd_make_section (abfd, ".debug");
4397 err = "bfd_make_section";
4400 if (! bfd_set_section_flags (abfd, s, SEC_DEBUGGING | SEC_HAS_CONTENTS))
4401 err = "bfd_set_section_flags";
4408 for (b = info.data; b != NULL; b = b->next)
4410 if (! bfd_set_section_size (abfd, s, size))
4411 err = "bfd_set_section_size";
4418 for (b = info.data; b != NULL; b = b->next)
4420 if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
4422 err = "bfd_set_section_contents";
4431 fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
4432 bfd_errmsg (bfd_get_error ()));
4439 /* Start writing out information for a compilation unit. */
4442 ieee_start_compilation_unit (p, filename)
4444 const char *filename;
4446 struct ieee_handle *info = (struct ieee_handle *) p;
4447 const char *modname;
4450 if (info->filename != NULL)
4452 if (! ieee_finish_compilation_unit (info))
4456 info->filename = filename;
4457 modname = strrchr (filename, '/');
4458 if (modname != NULL)
4462 modname = strrchr (filename, '\\');
4463 if (modname != NULL)
4468 c = xstrdup (modname);
4469 s = strrchr (c, '.');
4477 info->linenos = NULL;
4478 info->ranges = NULL;
4483 /* Finish up a compilation unit. */
4486 ieee_finish_compilation_unit (info)
4487 struct ieee_handle *info;
4489 struct ieee_buf **pp;
4490 struct ieee_range *r;
4492 if (info->types != NULL)
4494 if (! ieee_change_buffer (info, &info->types)
4495 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4499 if (info->cxx != NULL)
4501 /* Append any C++ information to the global function and
4502 variable information. */
4503 if (info->vars != NULL)
4505 if (! ieee_change_buffer (info, &info->vars))
4510 if (! ieee_change_buffer (info, &info->vars)
4511 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
4512 || ! ieee_write_byte (info, 3)
4513 || ! ieee_write_number (info, 0)
4514 || ! ieee_write_id (info, info->modname))
4518 /* We put the pmisc records in a dummy procedure, just as the
4519 MRI compiler does. */
4520 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4521 || ! ieee_write_byte (info, 6)
4522 || ! ieee_write_number (info, 0)
4523 || ! ieee_write_id (info, "__XRYCPP")
4524 || ! ieee_write_number (info, 0)
4525 || ! ieee_write_number (info, 0)
4526 || ! ieee_write_number (info, info->highaddr))
4529 for (pp = &info->vars; *pp != NULL; pp = &(*pp)->next)
4533 if (! ieee_change_buffer (info, &info->vars)
4534 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4535 || ! ieee_write_number (info, info->highaddr))
4539 if (info->vars != NULL)
4541 if (! ieee_change_buffer (info, &info->vars)
4542 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4546 if (info->linenos != NULL)
4548 if (! ieee_change_buffer (info, &info->linenos)
4549 || ! ieee_write_byte (info, (int) ieee_be_record_enum))
4553 for (pp = &info->data; *pp != NULL; pp = &(*pp)->next)
4556 for (; *pp != NULL; pp = &(*pp)->next)
4559 for (; *pp != NULL; pp = &(*pp)->next)
4561 *pp = info->linenos;
4563 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4564 if (! ieee_change_buffer (info, &info->data))
4567 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4568 || ! ieee_write_byte (info, 10)
4569 || ! ieee_write_number (info, 0)
4570 || ! ieee_write_id (info, info->modname)
4571 || ! ieee_write_id (info, "")
4572 || ! ieee_write_number (info, 0)
4573 || ! ieee_write_id (info, "GNU objcopy"))
4576 for (r = info->ranges; r != NULL; r = r->next)
4585 /* Find the section corresponding to this range. */
4586 for (s = info->abfd->sections; s != NULL; s = s->next)
4588 if (bfd_get_section_vma (info->abfd, s) <= low
4589 && high <= (bfd_get_section_vma (info->abfd, s)
4590 + bfd_section_size (info->abfd, s)))
4596 /* Just ignore this range. */
4600 /* Coalesce ranges if it seems reasonable. */
4601 while (r->next != NULL
4602 && high + 64 >= r->next->low
4604 <= (bfd_get_section_vma (info->abfd, s)
4605 + bfd_section_size (info->abfd, s))))
4608 high = r->next->high;
4611 if ((s->flags & SEC_CODE) != 0)
4613 else if ((s->flags & SEC_READONLY) != 0)
4618 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
4619 || ! ieee_write_byte (info, 11)
4620 || ! ieee_write_number (info, 0)
4621 || ! ieee_write_id (info, "")
4622 || ! ieee_write_number (info, kind)
4623 || ! ieee_write_number (info, s->index)
4624 || ! ieee_write_number (info, low)
4625 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
4626 || ! ieee_write_number (info, high - low))
4630 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
4636 /* Start recording information from a particular source file. This is
4637 used to record which file defined which types, variables, etc. It
4638 is not used for line numbers, since the lineno entry point passes
4639 down the file name anyhow. IEEE debugging information doesn't seem
4640 to store this information anywhere. */
4644 ieee_start_source (p, filename)
4646 const char *filename;
4651 /* Make an empty type. */
4657 struct ieee_handle *info = (struct ieee_handle *) p;
4659 return ieee_push_type (info, 0, 0, false);
4662 /* Make a void type. */
4668 struct ieee_handle *info = (struct ieee_handle *) p;
4670 return ieee_push_type (info, 1, 0, false);
4673 /* Make an integer type. */
4676 ieee_int_type (p, size, unsignedp)
4681 struct ieee_handle *info = (struct ieee_handle *) p;
4687 indx = (int) builtin_signed_char;
4690 indx = (int) builtin_signed_short_int;
4693 indx = (int) builtin_signed_long;
4696 indx = (int) builtin_signed_long_long;
4699 fprintf (stderr, "IEEE unsupported integer type size %u\n", size);
4706 return ieee_push_type (info, indx, size, unsignedp);
4709 /* Make a floating point type. */
4712 ieee_float_type (p, size)
4716 struct ieee_handle *info = (struct ieee_handle *) p;
4722 indx = (int) builtin_float;
4725 indx = (int) builtin_double;
4728 /* FIXME: This size really depends upon the processor. */
4729 indx = (int) builtin_long_double;
4732 indx = (int) builtin_long_long_double;
4735 fprintf (stderr, "IEEE unsupported float type size %u\n", size);
4739 return ieee_push_type (info, indx, size, false);
4742 /* Make a complex type. */
4745 ieee_complex_type (p, size)
4749 struct ieee_handle *info = (struct ieee_handle *) p;
4761 fprintf (stderr, "IEEE unsupported complex type size %u\n", size);
4765 /* FIXME: I don't know what the string is for. */
4766 return (ieee_define_type (info, size, false)
4767 && ieee_write_number (info, code)
4768 && ieee_write_id (info, ""));
4771 /* Make a boolean type. IEEE doesn't support these, so we just make
4772 an integer type instead. */
4775 ieee_bool_type (p, size)
4779 return ieee_int_type (p, size, true);
4782 /* Make an enumeration. */
4785 ieee_enum_type (p, tag, names, vals)
4789 bfd_signed_vma *vals;
4791 struct ieee_handle *info = (struct ieee_handle *) p;
4795 /* If this is a simple enumeration, in which the values start at 0
4796 and always increment by 1, we can use type E. Otherwise we must
4802 for (i = 0; names[i] != NULL; i++)
4812 if (! ieee_define_named_type (info, tag, true, (unsigned int) -1, 0,
4813 true, (struct ieee_buf **) NULL)
4814 || ! ieee_write_number (info, simple ? 'E' : 'N'))
4818 /* FIXME: This is supposed to be the enumeration size, but we
4819 don't store that. */
4820 if (! ieee_write_number (info, 4))
4825 for (i = 0; names[i] != NULL; i++)
4827 if (! ieee_write_id (info, names[i]))
4831 if (! ieee_write_number (info, vals[i]))
4840 /* Make a pointer type. */
4843 ieee_pointer_type (p)
4846 struct ieee_handle *info = (struct ieee_handle *) p;
4848 struct ieee_modified_type *m;
4850 indx = ieee_pop_type (info);
4852 /* A pointer to a simple builtin type can be obtained by adding 32. */
4854 return ieee_push_type (info, indx + 32, 0, true);
4856 m = ieee_get_modified_info (p, indx);
4861 return ieee_push_type (info, m->pointer, 0, true);
4863 if (! ieee_define_type (info, 0, true)
4864 || ! ieee_write_number (info, 'P')
4865 || ! ieee_write_number (info, indx))
4868 m->pointer = info->type_stack->type.indx;
4873 /* Make a function type. This will be called for a method, but we
4874 don't want to actually add it to the type table in that case. We
4875 handle this by defining the type in a private buffer, and only
4876 adding that buffer to the typedef block if we are going to use it. */
4879 ieee_function_type (p, argcount, varargs)
4884 struct ieee_handle *info = (struct ieee_handle *) p;
4885 unsigned int *args = NULL;
4887 unsigned int retindx;
4888 struct ieee_buf *fndef;
4892 args = (unsigned int *) xmalloc (argcount * sizeof *args);
4893 for (i = argcount - 1; i >= 0; i--)
4894 args[i] = ieee_pop_type (info);
4896 else if (argcount < 0)
4899 retindx = ieee_pop_type (info);
4901 /* An attribute of 0x41 means that the frame and push mask are
4904 if (! ieee_define_named_type (info, (const char *) NULL, false, 0, 0,
4906 || ! ieee_write_number (info, 'x')
4907 || ! ieee_write_number (info, 0x41)
4908 || ! ieee_write_number (info, 0)
4909 || ! ieee_write_number (info, 0)
4910 || ! ieee_write_number (info, retindx)
4911 || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
4915 for (i = 0; i < argcount; i++)
4916 if (! ieee_write_number (info, args[i]))
4922 /* A varargs function is represented by writing out the last
4923 argument as type void *, although this makes little sense. */
4924 if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
4928 if (! ieee_write_number (info, 0))
4931 /* We wrote the information into fndef, in case we don't need it.
4932 It will be appended to info->types by ieee_pop_type. */
4933 info->type_stack->type.fndef = fndef;
4938 /* Make a reference type. */
4941 ieee_reference_type (p)
4944 struct ieee_handle *info = (struct ieee_handle *) p;
4946 /* IEEE appears to record a normal pointer type, and then use a
4947 pmisc record to indicate that it is really a reference. */
4949 if (! ieee_pointer_type (p))
4951 info->type_stack->type.referencep = true;
4955 /* Make a range type. */
4958 ieee_range_type (p, low, high)
4961 bfd_signed_vma high;
4963 struct ieee_handle *info = (struct ieee_handle *) p;
4967 size = info->type_stack->type.size;
4968 unsignedp = info->type_stack->type.unsignedp;
4969 ieee_pop_unused_type (info);
4970 return (ieee_define_type (info, size, unsignedp)
4971 && ieee_write_number (info, 'R')
4972 && ieee_write_number (info, (bfd_vma) low)
4973 && ieee_write_number (info, (bfd_vma) high)
4974 && ieee_write_number (info, unsignedp ? 0 : 1)
4975 && ieee_write_number (info, size));
4978 /* Make an array type. */
4982 ieee_array_type (p, low, high, stringp)
4985 bfd_signed_vma high;
4988 struct ieee_handle *info = (struct ieee_handle *) p;
4989 unsigned int eleindx;
4991 /* IEEE does not store the range, so we just ignore it. */
4992 ieee_pop_unused_type (info);
4993 eleindx = ieee_pop_type (info);
4995 if (! ieee_define_type (info, 0, false)
4996 || ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
4997 || ! ieee_write_number (info, eleindx))
5001 if (! ieee_write_number (info, low))
5005 return ieee_write_number (info, high);
5008 /* Make a set type. */
5011 ieee_set_type (p, bitstringp)
5015 struct ieee_handle *info = (struct ieee_handle *) p;
5016 unsigned int eleindx;
5018 eleindx = ieee_pop_type (info);
5020 /* FIXME: We don't know the size, so we just use 4. */
5022 return (ieee_define_type (info, 0, true)
5023 && ieee_write_number (info, 's')
5024 && ieee_write_number (info, 4)
5025 && ieee_write_number (info, eleindx));
5028 /* Make an offset type. */
5031 ieee_offset_type (p)
5034 struct ieee_handle *info = (struct ieee_handle *) p;
5035 unsigned int targetindx, baseindx;
5037 targetindx = ieee_pop_type (info);
5038 baseindx = ieee_pop_type (info);
5040 /* FIXME: The MRI C++ compiler does not appear to generate any
5041 useful type information about an offset type. It just records a
5042 pointer to member as an integer. The MRI/HP IEEE spec does
5043 describe a pmisc record which can be used for a pointer to
5044 member. Unfortunately, it does not describe the target type,
5045 which seems pretty important. I'm going to punt this for now. */
5047 return ieee_int_type (p, 4, true);
5050 /* Make a method type. */
5053 ieee_method_type (p, domain, argcount, varargs)
5059 struct ieee_handle *info = (struct ieee_handle *) p;
5061 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5062 method, but the definition is incomplete. We just output an 'x'
5066 ieee_pop_unused_type (info);
5068 return ieee_function_type (p, argcount, varargs);
5071 /* Make a const qualified type. */
5077 struct ieee_handle *info = (struct ieee_handle *) p;
5081 struct ieee_modified_type *m;
5083 size = info->type_stack->type.size;
5084 unsignedp = info->type_stack->type.unsignedp;
5085 indx = ieee_pop_type (info);
5087 m = ieee_get_modified_info (info, indx);
5091 if (m->const_qualified > 0)
5092 return ieee_push_type (info, m->const_qualified, size, unsignedp);
5094 if (! ieee_define_type (info, size, unsignedp)
5095 || ! ieee_write_number (info, 'n')
5096 || ! ieee_write_number (info, 1)
5097 || ! ieee_write_number (info, indx))
5100 m->const_qualified = info->type_stack->type.indx;
5105 /* Make a volatile qualified type. */
5108 ieee_volatile_type (p)
5111 struct ieee_handle *info = (struct ieee_handle *) p;
5115 struct ieee_modified_type *m;
5117 size = info->type_stack->type.size;
5118 unsignedp = info->type_stack->type.unsignedp;
5119 indx = ieee_pop_type (info);
5121 m = ieee_get_modified_info (info, indx);
5125 if (m->volatile_qualified > 0)
5126 return ieee_push_type (info, m->volatile_qualified, size, unsignedp);
5128 if (! ieee_define_type (info, size, unsignedp)
5129 || ! ieee_write_number (info, 'n')
5130 || ! ieee_write_number (info, 2)
5131 || ! ieee_write_number (info, indx))
5134 m->volatile_qualified = info->type_stack->type.indx;
5139 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5142 ieee_vis_to_flags (visibility)
5143 enum debug_visibility visibility;
5149 case DEBUG_VISIBILITY_PUBLIC:
5150 return CXXFLAGS_VISIBILITY_PUBLIC;
5151 case DEBUG_VISIBILITY_PRIVATE:
5152 return CXXFLAGS_VISIBILITY_PRIVATE;
5153 case DEBUG_VISIBILITY_PROTECTED:
5154 return CXXFLAGS_VISIBILITY_PROTECTED;
5159 /* Start defining a struct type. We build it in the strdef field on
5160 the stack, to avoid confusing type definitions required by the
5161 fields with the struct type itself. */
5164 ieee_start_struct_type (p, tag, id, structp, size)
5171 struct ieee_handle *info = (struct ieee_handle *) p;
5172 struct ieee_buf *strdef;
5175 if (! ieee_define_named_type (info, tag, true, id, size, true, &strdef)
5176 || ! ieee_write_number (info, structp ? 'S' : 'U')
5177 || ! ieee_write_number (info, size))
5180 info->type_stack->type.strdef = strdef;
5185 /* Add a field to a struct. */
5188 ieee_struct_field (p, name, bitpos, bitsize, visibility)
5193 enum debug_visibility visibility;
5195 struct ieee_handle *info = (struct ieee_handle *) p;
5202 size = info->type_stack->type.size;
5203 unsignedp = info->type_stack->type.unsignedp;
5204 referencep = info->type_stack->type.referencep;
5205 indx = ieee_pop_type (info);
5207 assert (info->type_stack != NULL && info->type_stack->type.strdef != NULL);
5209 if (info->type_stack->type.classdef != NULL)
5214 /* This is a class. We must add a description of this field to
5215 the class records we are building. */
5217 flags = ieee_vis_to_flags (visibility);
5218 nindx = info->type_stack->type.classdef->indx;
5219 if (! ieee_change_buffer (info,
5220 &info->type_stack->type.classdef->pmiscbuf)
5221 || ! ieee_write_asn (info, nindx, 'd')
5222 || ! ieee_write_asn (info, nindx, flags)
5223 || ! ieee_write_atn65 (info, nindx, name)
5224 || ! ieee_write_atn65 (info, nindx, name))
5226 info->type_stack->type.classdef->pmisccount += 4;
5232 /* We need to output a record recording that this field is
5233 really of reference type. We put this on the refs field
5234 of classdef, so that it can be appended to the C++
5235 records after the class is defined. */
5237 nindx = info->name_indx;
5240 if (! ieee_change_buffer (info,
5241 &info->type_stack->type.classdef->refs)
5242 || ! ieee_write_byte (info, (int) ieee_nn_record)
5243 || ! ieee_write_number (info, nindx)
5244 || ! ieee_write_id (info, "")
5245 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5246 || ! ieee_write_number (info, nindx)
5247 || ! ieee_write_number (info, 0)
5248 || ! ieee_write_number (info, 62)
5249 || ! ieee_write_number (info, 80)
5250 || ! ieee_write_number (info, 4)
5251 || ! ieee_write_asn (info, nindx, 'R')
5252 || ! ieee_write_asn (info, nindx, 3)
5253 || ! ieee_write_atn65 (info, nindx,
5254 info->type_stack->type.classdef->name)
5255 || ! ieee_write_atn65 (info, nindx, name))
5260 /* If the bitsize doesn't match the expected size, we need to output
5262 if (size == 0 || bitsize == size * 8)
5263 offset = bitpos / 8;
5266 if (! ieee_define_type (info, 0, unsignedp)
5267 || ! ieee_write_number (info, 'g')
5268 || ! ieee_write_number (info, unsignedp ? 0 : 1)
5269 || ! ieee_write_number (info, indx))
5271 indx = ieee_pop_type (info);
5275 /* Switch to the struct we are building in order to output this
5276 field definition. */
5277 return (ieee_change_buffer (info, &info->type_stack->type.strdef)
5278 && ieee_write_id (info, name)
5279 && ieee_write_number (info, indx)
5280 && ieee_write_number (info, offset));
5283 /* Finish up a struct type. */
5286 ieee_end_struct_type (p)
5289 struct ieee_handle *info = (struct ieee_handle *) p;
5290 struct ieee_buf **pb;
5292 assert (info->type_stack != NULL && info->type_stack->type.strdef != NULL);
5294 /* Make sure we have started the types block. */
5295 if (info->types == NULL)
5297 if (! ieee_change_buffer (info, &info->types)
5298 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
5299 || ! ieee_write_byte (info, 1)
5300 || ! ieee_write_number (info, 0)
5301 || ! ieee_write_id (info, info->modname))
5305 /* Append the struct definition to the types. */
5306 for (pb = &info->types; *pb != NULL; pb = &(*pb)->next)
5308 *pb = info->type_stack->type.strdef;
5309 info->type_stack->type.strdef = NULL;
5311 /* Leave the struct on the type stack. */
5316 /* Start a class type. */
5319 ieee_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
5328 struct ieee_handle *info = (struct ieee_handle *) p;
5330 struct ieee_buf *pmiscbuf;
5332 struct ieee_type_class *classdef;
5333 struct ieee_name_type *nt;
5335 /* A C++ class is output as a C++ struct along with a set of pmisc
5336 records describing the class. */
5338 /* We need to have a name so that we can associate the struct and
5344 t = (char *) xmalloc (20);
5345 sprintf (t, "__anon%u", id);
5349 /* We can't write out the virtual table information until we have
5350 finished the class, because we don't know the virtual table size.
5351 We get the size from the largest voffset we see. */
5353 if (vptr && ! ownvptr)
5355 assert (info->type_stack->type.classdef != NULL);
5356 vclass = info->type_stack->type.classdef->name;
5357 /* We don't call ieee_pop_unused_type, since the class should
5359 (void) ieee_pop_type (info);
5362 if (! ieee_start_struct_type (p, tag, id, structp, size))
5365 indx = info->name_indx;
5368 /* We write out pmisc records into the classdef field. We will
5369 write out the pmisc start after we know the number of records we
5372 if (! ieee_change_buffer (info, &pmiscbuf)
5373 || ! ieee_write_asn (info, indx, 'T')
5374 || ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
5375 || ! ieee_write_atn65 (info, indx, tag))
5378 classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef);
5379 memset (classdef, 0, sizeof *classdef);
5381 classdef->name = tag;
5382 classdef->indx = indx;
5383 classdef->pmiscbuf = pmiscbuf;
5384 classdef->pmisccount = 3;
5385 classdef->vclass = vclass;
5386 classdef->ownvptr = ownvptr;
5388 info->type_stack->type.classdef = classdef;
5390 /* We need to fill in the classdef in the tag as well, so that it
5391 will be set when ieee_tag_type is called. */
5392 for (nt = info->tags; nt != NULL; nt = nt->next)
5393 if (nt->name[0] == tag[0]
5394 && strcmp (nt->name, tag) == 0)
5396 assert (nt != NULL);
5397 nt->type.classdef = classdef;
5402 /* Add a static member to a class. */
5405 ieee_class_static_member (p, name, physname, visibility)
5408 const char *physname;
5409 enum debug_visibility visibility;
5411 struct ieee_handle *info = (struct ieee_handle *) p;
5415 /* We don't care about the type. Hopefully there will be a call to
5416 ieee_variable declaring the physical name and the type, since
5417 that is where an IEEE consumer must get the type. */
5418 ieee_pop_unused_type (info);
5420 assert (info->type_stack != NULL
5421 && info->type_stack->type.classdef != NULL);
5423 flags = ieee_vis_to_flags (visibility);
5424 flags |= CXXFLAGS_STATIC;
5426 nindx = info->type_stack->type.classdef->indx;
5428 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
5429 || ! ieee_write_asn (info, nindx, 'd')
5430 || ! ieee_write_asn (info, nindx, flags)
5431 || ! ieee_write_atn65 (info, nindx, name)
5432 || ! ieee_write_atn65 (info, nindx, physname))
5434 info->type_stack->type.classdef->pmisccount += 4;
5439 /* Add a base class to a class. */
5442 ieee_class_baseclass (p, bitpos, virtual, visibility)
5446 enum debug_visibility visibility;
5448 struct ieee_handle *info = (struct ieee_handle *) p;
5455 assert (info->type_stack != NULL
5456 && info->type_stack->type.classdef != NULL
5457 && info->type_stack->next != NULL
5458 && info->type_stack->next->type.classdef != NULL
5459 && info->type_stack->next->type.strdef != NULL);
5461 bname = info->type_stack->type.classdef->name;
5462 bindx = ieee_pop_type (info);
5464 /* We are currently defining both a struct and a class. We must
5465 write out a field definition in the struct which holds the base
5466 class. The stabs debugging reader will create a field named
5467 _vb$CLASS for a virtual base class, so we just use that. FIXME:
5468 we should not depend upon a detail of stabs debugging. */
5471 fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
5472 sprintf (fname, "_vb$%s", bname);
5473 flags = BASEFLAGS_VIRTUAL;
5477 fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
5478 sprintf (fname, "_b$%s", bname);
5480 if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
5481 || ! ieee_write_id (info, fname)
5482 || ! ieee_write_number (info, bindx)
5483 || ! ieee_write_number (info, bitpos / 8))
5488 if (visibility == DEBUG_VISIBILITY_PRIVATE)
5489 flags |= BASEFLAGS_PRIVATE;
5491 nindx = info->type_stack->type.classdef->indx;
5493 if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
5494 || ! ieee_write_asn (info, nindx, 'b')
5495 || ! ieee_write_asn (info, nindx, flags)
5496 || ! ieee_write_atn65 (info, nindx, bname)
5497 || ! ieee_write_asn (info, nindx, 0)
5498 || ! ieee_write_atn65 (info, nindx, fname))
5500 info->type_stack->type.classdef->pmisccount += 5;
5507 /* Start building a method for a class. */
5510 ieee_class_start_method (p, name)
5514 struct ieee_handle *info = (struct ieee_handle *) p;
5516 assert (info->type_stack != NULL
5517 && info->type_stack->type.classdef != NULL
5518 && info->type_stack->type.classdef->method == NULL);
5520 info->type_stack->type.classdef->method = name;
5525 /* Define a new method variant, either static or not. */
5528 ieee_class_method_var (info, physname, visibility, staticp, constp,
5529 volatilep, voffset, context)
5530 struct ieee_handle *info;
5531 const char *physname;
5532 enum debug_visibility visibility;
5543 /* We don't need the type of the method. An IEEE consumer which
5544 wants the type must track down the function by the physical name
5545 and get the type from that. */
5546 ieee_pop_unused_type (info);
5548 /* We don't use the context. FIXME: We probably ought to use it to
5549 adjust the voffset somehow, but I don't really know how. */
5551 ieee_pop_unused_type (info);
5553 assert (info->type_stack != NULL
5554 && info->type_stack->type.classdef != NULL
5555 && info->type_stack->type.classdef->method != NULL);
5557 flags = ieee_vis_to_flags (visibility);
5559 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
5560 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
5563 flags |= CXXFLAGS_STATIC;
5565 flags |= CXXFLAGS_CONST;
5567 flags |= CXXFLAGS_VOLATILE;
5569 nindx = info->type_stack->type.classdef->indx;
5571 virtual = context || voffset > 0;
5573 if (! ieee_change_buffer (info,
5574 &info->type_stack->type.classdef->pmiscbuf)
5575 || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm')
5576 || ! ieee_write_asn (info, nindx, flags)
5577 || ! ieee_write_atn65 (info, nindx,
5578 info->type_stack->type.classdef->method)
5579 || ! ieee_write_atn65 (info, nindx, physname))
5584 if (voffset > info->type_stack->type.classdef->voffset)
5585 info->type_stack->type.classdef->voffset = voffset;
5586 /* FIXME: The size of a vtable entry depends upon the
5588 if (! ieee_write_asn (info, nindx, (voffset / 4) + 1))
5590 ++info->type_stack->type.classdef->pmisccount;
5593 if (! ieee_write_asn (info, nindx, 0))
5596 info->type_stack->type.classdef->pmisccount += 5;
5601 /* Define a new method variant. */
5604 ieee_class_method_variant (p, physname, visibility, constp, volatilep,
5607 const char *physname;
5608 enum debug_visibility visibility;
5614 struct ieee_handle *info = (struct ieee_handle *) p;
5616 return ieee_class_method_var (info, physname, visibility, false, constp,
5617 volatilep, voffset, context);
5620 /* Define a new static method variant. */
5623 ieee_class_static_method_variant (p, physname, visibility, constp, volatilep)
5625 const char *physname;
5626 enum debug_visibility visibility;
5630 struct ieee_handle *info = (struct ieee_handle *) p;
5632 return ieee_class_method_var (info, physname, visibility, true, constp,
5633 volatilep, 0, false);
5636 /* Finish up a method. */
5639 ieee_class_end_method (p)
5642 struct ieee_handle *info = (struct ieee_handle *) p;
5644 assert (info->type_stack != NULL
5645 && info->type_stack->type.classdef != NULL
5646 && info->type_stack->type.classdef->method != NULL);
5648 info->type_stack->type.classdef->method = NULL;
5653 /* Finish up a class. */
5656 ieee_end_class_type (p)
5659 struct ieee_handle *info = (struct ieee_handle *) p;
5661 struct ieee_buf **pb;
5663 assert (info->type_stack != NULL
5664 && info->type_stack->type.classdef != NULL);
5666 nindx = info->type_stack->type.classdef->indx;
5668 /* If we have a virtual table, we can write out the information now. */
5669 if (info->type_stack->type.classdef->vclass != NULL
5670 || info->type_stack->type.classdef->ownvptr)
5674 /* FIXME: This calculation is architecture dependent. */
5675 vsize = (info->type_stack->type.classdef->voffset + 4) / 4;
5677 if (! ieee_change_buffer (info,
5678 &info->type_stack->type.classdef->pmiscbuf)
5679 || ! ieee_write_asn (info, nindx, 'z')
5680 || ! ieee_write_atn65 (info, nindx, "")
5681 || ! ieee_write_asn (info, nindx, vsize))
5683 if (info->type_stack->type.classdef->ownvptr)
5685 if (! ieee_write_atn65 (info, nindx, ""))
5690 if (! ieee_write_atn65 (info, nindx,
5691 info->type_stack->type.classdef->vclass))
5694 if (! ieee_write_asn (info, nindx, 0))
5696 info->type_stack->type.classdef->pmisccount += 5;
5699 /* Now that we know the number of pmisc records, we can write out
5700 the atn62 which starts the pmisc records, and append them to the
5703 if (! ieee_change_buffer (info, &info->cxx)
5704 || ! ieee_write_byte (info, (int) ieee_nn_record)
5705 || ! ieee_write_number (info, nindx)
5706 || ! ieee_write_id (info, "")
5707 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
5708 || ! ieee_write_number (info, nindx)
5709 || ! ieee_write_number (info, 0)
5710 || ! ieee_write_number (info, 62)
5711 || ! ieee_write_number (info, 80)
5712 || ! ieee_write_number (info,
5713 info->type_stack->type.classdef->pmisccount))
5716 for (pb = &info->cxx; *pb != NULL; pb = &(*pb)->next)
5718 *pb = info->type_stack->type.classdef->pmiscbuf;
5719 if (info->type_stack->type.classdef->refs != NULL)
5721 for (; *pb != NULL; pb = &(*pb)->next)
5723 *pb = info->type_stack->type.classdef->refs;
5726 return ieee_end_struct_type (p);
5729 /* Push a previously seen typedef onto the type stack. */
5732 ieee_typedef_type (p, name)
5736 struct ieee_handle *info = (struct ieee_handle *) p;
5737 register struct ieee_name_type *nt;
5739 for (nt = info->typedefs; nt != NULL; nt = nt->next)
5741 if (nt->name[0] == name[0]
5742 && strcmp (nt->name, name) == 0)
5744 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
5745 nt->type.unsignedp))
5747 /* Copy over any other type information we may have. */
5748 info->type_stack->type = nt->type;
5756 /* Push a tagged type onto the type stack. */
5759 ieee_tag_type (p, name, id, kind)
5763 enum debug_type_kind kind;
5765 struct ieee_handle *info = (struct ieee_handle *) p;
5766 register struct ieee_name_type *nt;
5771 sprintf (ab, "__anon%u", id);
5775 for (nt = info->tags; nt != NULL; nt = nt->next)
5777 if (nt->name[0] == name[0]
5778 && strcmp (nt->name, name) == 0)
5780 if (! ieee_push_type (info, nt->type.indx, nt->type.size,
5781 nt->type.unsignedp))
5783 /* Copy over any other type information we may have. */
5784 info->type_stack->type = nt->type;
5789 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5790 memset (nt, 0, sizeof *nt);
5793 name = xstrdup (ab);
5795 nt->type.indx = info->type_indx;
5799 nt->next = info->tags;
5802 return ieee_push_type (info, nt->type.indx, 0, false);
5805 /* Output a typedef. */
5808 ieee_typdef (p, name)
5812 struct ieee_handle *info = (struct ieee_handle *) p;
5813 struct ieee_name_type *nt;
5818 nt = (struct ieee_name_type *) xmalloc (sizeof *nt);
5819 memset (nt, 0, sizeof *nt);
5821 nt->type = info->type_stack->type;
5822 nt->kind = DEBUG_KIND_ILLEGAL;
5824 nt->next = info->typedefs;
5825 info->typedefs = nt;
5827 size = info->type_stack->type.size;
5828 unsignedp = info->type_stack->type.unsignedp;
5829 indx = ieee_pop_type (info);
5831 /* If this is a simple builtin type using a builtin name, we don't
5832 want to output the typedef itself. We also want to change the
5833 type index to correspond to the name being used. We recognize
5834 names used in stabs debugging output even if they don't exactly
5835 correspond to the names used for the IEEE builtin types. */
5836 if (indx <= (unsigned int) builtin_bcd_float)
5841 switch ((enum builtin_types) indx)
5847 if (strcmp (name, "void") == 0)
5851 case builtin_signed_char:
5853 if (strcmp (name, "signed char") == 0)
5855 indx = (unsigned int) builtin_signed_char;
5858 else if (strcmp (name, "char") == 0)
5860 indx = (unsigned int) builtin_char;
5865 case builtin_unsigned_char:
5866 if (strcmp (name, "unsigned char") == 0)
5870 case builtin_signed_short_int:
5872 case builtin_short_int:
5873 case builtin_signed_short:
5874 if (strcmp (name, "signed short int") == 0)
5876 indx = (unsigned int) builtin_signed_short_int;
5879 else if (strcmp (name, "short") == 0)
5881 indx = (unsigned int) builtin_short;
5884 else if (strcmp (name, "short int") == 0)
5886 indx = (unsigned int) builtin_short_int;
5889 else if (strcmp (name, "signed short") == 0)
5891 indx = (unsigned int) builtin_signed_short;
5896 case builtin_unsigned_short_int:
5897 case builtin_unsigned_short:
5898 if (strcmp (name, "unsigned short int") == 0
5899 || strcmp (name, "short unsigned int") == 0)
5901 indx = builtin_unsigned_short_int;
5904 else if (strcmp (name, "unsigned short") == 0)
5906 indx = builtin_unsigned_short;
5911 case builtin_signed_long:
5912 case builtin_int: /* FIXME: Size depends upon architecture. */
5914 if (strcmp (name, "signed long") == 0)
5916 indx = builtin_signed_long;
5919 else if (strcmp (name, "int") == 0)
5924 else if (strcmp (name, "long") == 0
5925 || strcmp (name, "long int") == 0)
5927 indx = builtin_long;
5932 case builtin_unsigned_long:
5933 case builtin_unsigned: /* FIXME: Size depends upon architecture. */
5934 case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
5935 if (strcmp (name, "unsigned long") == 0
5936 || strcmp (name, "long unsigned int") == 0)
5938 indx = builtin_unsigned_long;
5941 else if (strcmp (name, "unsigned") == 0)
5943 indx = builtin_unsigned;
5946 else if (strcmp (name, "unsigned int") == 0)
5948 indx = builtin_unsigned_int;
5953 case builtin_signed_long_long:
5954 if (strcmp (name, "signed long long") == 0
5955 || strcmp (name, "long long int") == 0)
5959 case builtin_unsigned_long_long:
5960 if (strcmp (name, "unsigned long long") == 0
5961 || strcmp (name, "long long unsigned int") == 0)
5966 if (strcmp (name, "float") == 0)
5970 case builtin_double:
5971 if (strcmp (name, "double") == 0)
5975 case builtin_long_double:
5976 if (strcmp (name, "long double") == 0)
5980 case builtin_long_long_double:
5981 if (strcmp (name, "long long double") == 0)
5988 nt->type.indx = indx;
5993 if (! ieee_define_named_type (info, name, false, 0, size, unsignedp,
5994 (struct ieee_buf **) NULL)
5995 || ! ieee_write_number (info, 'T')
5996 || ! ieee_write_number (info, indx))
5999 /* Remove the type we just added to the type stack. This should not
6000 be ieee_pop_unused_type, since the type is used, we just don't
6002 (void) ieee_pop_type (info);
6007 /* Output a tag for a type. We don't have to do anything here. */
6014 struct ieee_handle *info = (struct ieee_handle *) p;
6016 /* This should not be ieee_pop_unused_type, since we want the type
6018 (void) ieee_pop_type (info);
6022 /* Output an integer constant. */
6025 ieee_int_constant (p, name, val)
6034 /* Output a floating point constant. */
6037 ieee_float_constant (p, name, val)
6046 /* Output a typed constant. */
6049 ieee_typed_constant (p, name, val)
6054 struct ieee_handle *info = (struct ieee_handle *) p;
6057 ieee_pop_unused_type (info);
6061 /* Output a variable. */
6064 ieee_variable (p, name, kind, val)
6067 enum debug_var_kind kind;
6070 struct ieee_handle *info = (struct ieee_handle *) p;
6071 unsigned int name_indx;
6074 unsigned int type_indx;
6078 size = info->type_stack->type.size;
6079 referencep = info->type_stack->type.referencep;
6080 type_indx = ieee_pop_type (info);
6082 /* Make sure the variable section is started. */
6083 if (info->vars != NULL)
6085 if (! ieee_change_buffer (info, &info->vars))
6090 if (! ieee_change_buffer (info, &info->vars)
6091 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6092 || ! ieee_write_byte (info, 3)
6093 || ! ieee_write_number (info, 0)
6094 || ! ieee_write_id (info, info->modname))
6098 name_indx = info->name_indx;
6101 /* Write out an NN and an ATN record for this variable. */
6102 if (! ieee_write_byte (info, (int) ieee_nn_record)
6103 || ! ieee_write_number (info, name_indx)
6104 || ! ieee_write_id (info, name)
6105 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6106 || ! ieee_write_number (info, name_indx)
6107 || ! ieee_write_number (info, type_indx))
6115 if (! ieee_write_number (info, 8)
6116 || ! ieee_add_range (info, val, val + size))
6122 if (! ieee_write_number (info, 3)
6123 || ! ieee_add_range (info, val, val + size))
6128 case DEBUG_LOCAL_STATIC:
6129 if (! ieee_write_number (info, 3)
6130 || ! ieee_add_range (info, val, val + size))
6136 if (! ieee_write_number (info, 1)
6137 || ! ieee_write_number (info, val))
6142 case DEBUG_REGISTER:
6143 if (! ieee_write_number (info, 2)
6144 || ! ieee_write_number (info,
6145 ieee_genreg_to_regno (info->abfd, val)))
6154 if (! ieee_write_asn (info, name_indx, val))
6158 /* If this is really a reference type, then we just output it with
6159 pointer type, and must now output a C++ record indicating that it
6160 is really reference type. */
6165 nindx = info->name_indx;
6168 /* If this is a global variable, we want to output the misc
6169 record in the C++ misc record block. Otherwise, we want to
6170 output it just after the variable definition, which is where
6171 the current buffer is. */
6174 if (! ieee_change_buffer (info, &info->cxx))
6178 if (! ieee_write_byte (info, (int) ieee_nn_record)
6179 || ! ieee_write_number (info, nindx)
6180 || ! ieee_write_id (info, "")
6181 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6182 || ! ieee_write_number (info, nindx)
6183 || ! ieee_write_number (info, 0)
6184 || ! ieee_write_number (info, 62)
6185 || ! ieee_write_number (info, 80)
6186 || ! ieee_write_number (info, 3)
6187 || ! ieee_write_asn (info, nindx, 'R')
6188 || ! ieee_write_asn (info, nindx, refflag)
6189 || ! ieee_write_atn65 (info, nindx, name))
6196 /* Start outputting information for a function. */
6199 ieee_start_function (p, name, global)
6204 struct ieee_handle *info = (struct ieee_handle *) p;
6206 unsigned int retindx, typeindx;
6208 referencep = info->type_stack->type.referencep;
6209 retindx = ieee_pop_type (info);
6211 /* Besides recording a BB4 or BB6 block, we record the type of the
6212 function in the BB1 typedef block. We can't write out the full
6213 type until we have seen all the parameters, so we accumulate it
6214 in info->fntype and info->fnargs. */
6215 if (info->fntype != NULL)
6217 /* FIXME: This might happen someday if we support nested
6222 info->fnname = name;
6224 /* An attribute of 0x41 means that the frame and push mask are
6226 if (! ieee_define_named_type (info, name, false, 0, 0, false, &info->fntype)
6227 || ! ieee_write_number (info, 'x')
6228 || ! ieee_write_number (info, 0x41)
6229 || ! ieee_write_number (info, 0)
6230 || ! ieee_write_number (info, 0)
6231 || ! ieee_write_number (info, retindx))
6234 typeindx = ieee_pop_type (info);
6236 info->fnargs = NULL;
6237 info->fnargcount = 0;
6239 /* If the function return value is actually a reference type, we
6240 must add a record indicating that. */
6245 nindx = info->name_indx;
6247 if (! ieee_change_buffer (info, &info->cxx)
6248 || ! ieee_write_byte (info, (int) ieee_nn_record)
6249 || ! ieee_write_number (info, nindx)
6250 || ! ieee_write_id (info, "")
6251 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6252 || ! ieee_write_number (info, nindx)
6253 || ! ieee_write_number (info, 0)
6254 || ! ieee_write_number (info, 62)
6255 || ! ieee_write_number (info, 80)
6256 || ! ieee_write_number (info, 3)
6257 || ! ieee_write_asn (info, nindx, 'R')
6258 || ! ieee_write_asn (info, nindx, global ? 0 : 1)
6259 || ! ieee_write_atn65 (info, nindx, name))
6263 /* Make sure the variable section is started. */
6264 if (info->vars != NULL)
6266 if (! ieee_change_buffer (info, &info->vars))
6271 if (! ieee_change_buffer (info, &info->vars)
6272 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6273 || ! ieee_write_byte (info, 3)
6274 || ! ieee_write_number (info, 0)
6275 || ! ieee_write_id (info, info->modname))
6279 /* The address is written out as the first block. */
6281 ++info->block_depth;
6283 return (ieee_write_byte (info, (int) ieee_bb_record_enum)
6284 && ieee_write_byte (info, global ? 4 : 6)
6285 && ieee_write_number (info, 0)
6286 && ieee_write_id (info, name)
6287 && ieee_write_number (info, 0)
6288 && ieee_write_number (info, typeindx));
6291 /* Add a function parameter. This will normally be called before the
6292 first block, so we postpone them until we see the block. */
6295 ieee_function_parameter (p, name, kind, val)
6298 enum debug_parm_kind kind;
6301 struct ieee_handle *info = (struct ieee_handle *) p;
6302 struct ieee_pending_parm *m, **pm;
6304 assert (info->block_depth == 1);
6306 m = (struct ieee_pending_parm *) xmalloc (sizeof *m);
6307 memset (m, 0, sizeof *m);
6311 m->referencep = info->type_stack->type.referencep;
6312 m->type = ieee_pop_type (info);
6316 for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next)
6320 /* Add the type to the fnargs list. */
6321 if (! ieee_change_buffer (info, &info->fnargs)
6322 || ! ieee_write_number (info, m->type))
6329 /* Output pending function parameters. */
6332 ieee_output_pending_parms (info)
6333 struct ieee_handle *info;
6335 struct ieee_pending_parm *m;
6336 unsigned int refcount;
6339 for (m = info->pending_parms; m != NULL; m = m->next)
6341 enum debug_var_kind vkind;
6348 case DEBUG_PARM_STACK:
6349 case DEBUG_PARM_REFERENCE:
6350 vkind = DEBUG_LOCAL;
6352 case DEBUG_PARM_REG:
6353 case DEBUG_PARM_REF_REG:
6354 vkind = DEBUG_REGISTER;
6358 if (! ieee_push_type (info, m->type, 0, false))
6360 info->type_stack->type.referencep = m->referencep;
6363 if (! ieee_variable ((PTR) info, m->name, vkind, m->val))
6367 /* If there are any reference parameters, we need to output a
6368 miscellaneous record indicating them. */
6371 unsigned int nindx, varindx;
6373 /* FIXME: The MRI compiler outputs the demangled function name
6374 here, but we are outputting the mangled name. */
6375 nindx = info->name_indx;
6377 if (! ieee_change_buffer (info, &info->vars)
6378 || ! ieee_write_byte (info, (int) ieee_nn_record)
6379 || ! ieee_write_number (info, nindx)
6380 || ! ieee_write_id (info, "")
6381 || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6382 || ! ieee_write_number (info, nindx)
6383 || ! ieee_write_number (info, 0)
6384 || ! ieee_write_number (info, 62)
6385 || ! ieee_write_number (info, 80)
6386 || ! ieee_write_number (info, refcount + 3)
6387 || ! ieee_write_asn (info, nindx, 'B')
6388 || ! ieee_write_atn65 (info, nindx, info->fnname)
6389 || ! ieee_write_asn (info, nindx, 0))
6391 for (m = info->pending_parms, varindx = 1;
6393 m = m->next, varindx++)
6397 if (! ieee_write_asn (info, nindx, varindx))
6403 m = info->pending_parms;
6406 struct ieee_pending_parm *next;
6413 info->pending_parms = NULL;
6418 /* Start a block. If this is the first block, we output the address
6419 to finish the BB4 or BB6, and then output the function parameters. */
6422 ieee_start_block (p, addr)
6426 struct ieee_handle *info = (struct ieee_handle *) p;
6428 if (! ieee_change_buffer (info, &info->vars))
6431 if (info->block_depth == 1)
6433 if (! ieee_write_number (info, addr)
6434 || ! ieee_output_pending_parms (info))
6439 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
6440 || ! ieee_write_byte (info, 6)
6441 || ! ieee_write_number (info, 0)
6442 || ! ieee_write_id (info, "")
6443 || ! ieee_write_number (info, 0)
6444 || ! ieee_write_number (info, 0)
6445 || ! ieee_write_number (info, addr))
6449 if (! ieee_start_range (info, addr))
6452 ++info->block_depth;
6460 ieee_end_block (p, addr)
6464 struct ieee_handle *info = (struct ieee_handle *) p;
6466 if (! ieee_change_buffer (info, &info->vars)
6467 || ! ieee_write_byte (info, (int) ieee_be_record_enum)
6468 || ! ieee_write_number (info, addr))
6471 if (! ieee_end_range (info, addr))
6474 --info->block_depth;
6476 if (addr > info->highaddr)
6477 info->highaddr = addr;
6482 /* End a function. */
6485 ieee_end_function (p)
6488 struct ieee_handle *info = (struct ieee_handle *) p;
6489 struct ieee_buf **pb;
6491 assert (info->block_depth == 1);
6493 --info->block_depth;
6495 /* Now we can finish up fntype, and add it to the typdef section.
6496 At this point, fntype is the 'x' type up to the argument count,
6497 and fnargs is the argument types. We must add the argument
6498 count, and we must add the level. FIXME: We don't record varargs
6499 functions correctly. In fact, stabs debugging does not give us
6500 enough information to do so. */
6501 if (! ieee_change_buffer (info, &info->fntype)
6502 || ! ieee_write_number (info, info->fnargcount)
6503 || ! ieee_change_buffer (info, &info->fnargs)
6504 || ! ieee_write_number (info, 0))
6507 /* Make sure the typdef block has been started. */
6508 if (info->types == NULL)
6510 if (! ieee_change_buffer (info, &info->types)
6511 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6512 || ! ieee_write_byte (info, 1)
6513 || ! ieee_write_number (info, 0)
6514 || ! ieee_write_id (info, info->modname))
6518 for (pb = &info->types; *pb != NULL; pb = &(*pb)->next)
6521 for (; *pb != NULL; pb = &(*pb)->next)
6525 info->fnname = NULL;
6526 info->fntype = NULL;
6527 info->fnargs = NULL;
6528 info->fnargcount = 0;
6533 /* Record line number information. */
6536 ieee_lineno (p, filename, lineno, addr)
6538 const char *filename;
6539 unsigned long lineno;
6542 struct ieee_handle *info = (struct ieee_handle *) p;
6544 assert (info->filename != NULL);
6546 /* Make sure we have a line number block. */
6547 if (info->linenos != NULL)
6549 if (! ieee_change_buffer (info, &info->linenos))
6554 info->lineno_name_indx = info->name_indx;
6556 if (! ieee_change_buffer (info, &info->linenos)
6557 || ! ieee_write_byte (info, (int) ieee_bb_record_enum)
6558 || ! ieee_write_byte (info, 5)
6559 || ! ieee_write_number (info, 0)
6560 || ! ieee_write_id (info, info->filename)
6561 || ! ieee_write_byte (info, (int) ieee_nn_record)
6562 || ! ieee_write_number (info, info->lineno_name_indx)
6563 || ! ieee_write_id (info, ""))
6565 info->lineno_filename = info->filename;
6568 if (strcmp (filename, info->lineno_filename) != 0)
6570 if (strcmp (info->filename, info->lineno_filename) != 0)
6572 /* We were not in the main file. Close the block for the
6574 if (! ieee_write_byte (info, (int) ieee_be_record_enum))
6577 if (strcmp (info->filename, filename) != 0)
6579 /* We are not changing to the main file. Open a block for
6580 the new included file. */
6581 if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
6582 || ! ieee_write_byte (info, 5)
6583 || ! ieee_write_number (info, 0)
6584 || ! ieee_write_id (info, filename))
6587 info->lineno_filename = filename;
6590 return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
6591 && ieee_write_number (info, info->lineno_name_indx)
6592 && ieee_write_number (info, 0)
6593 && ieee_write_number (info, 7)
6594 && ieee_write_number (info, lineno)
6595 && ieee_write_number (info, 0)
6596 && ieee_write_asn (info, info->lineno_name_indx, addr));