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
, voffset
, 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
))
2805 if (! ieee_require_asn (info
, pp
, &voffset
))
2809 if (! ieee_require_asn (info
, pp
, &control
))
2813 /* We just ignore the control information. */
2815 /* We have no way to represent friend information, so we
2817 if ((flags
& CXXFLAGS_FRIEND
) != 0)
2820 /* We should already have seen a type for the function. */
2821 pv
= info
->vars
.vars
;
2822 pvend
= pv
+ info
->vars
.alloc
;
2823 for (; pv
< pvend
; pv
++)
2824 if (pv
->namlen
== mangledlen
2825 && strncmp (pv
->name
, mangled
, mangledlen
) == 0)
2830 /* We won't have type information for this function if
2831 it is not included in this file. We don't try to
2832 handle this case. FIXME. */
2833 type
= (debug_make_function_type
2835 ieee_builtin_type (info
, start
,
2836 (unsigned int) builtin_void
),
2837 (debug_type
*) NULL
,
2842 debug_type return_type
;
2843 const debug_type
*arg_types
;
2846 if (debug_get_type_kind (dhandle
, pv
->type
)
2847 != DEBUG_KIND_FUNCTION
)
2849 ieee_error (info
, start
,
2850 "bad type for C++ method function");
2854 return_type
= debug_get_return_type (dhandle
, pv
->type
);
2855 arg_types
= debug_get_parameter_types (dhandle
, pv
->type
,
2857 if (return_type
== DEBUG_TYPE_NULL
|| arg_types
== NULL
)
2859 ieee_error (info
, start
,
2860 "no type information for C++ method function");
2864 type
= debug_make_method_type (dhandle
, return_type
, it
->type
,
2865 (debug_type
*) arg_types
,
2868 if (type
== DEBUG_TYPE_NULL
)
2871 switch (flags
& CXXFLAGS_VISIBILITY
)
2874 ieee_error (info
, start
, "unknown C++ visibility");
2877 case CXXFLAGS_VISIBILITY_PUBLIC
:
2878 visibility
= DEBUG_VISIBILITY_PUBLIC
;
2881 case CXXFLAGS_VISIBILITY_PRIVATE
:
2882 visibility
= DEBUG_VISIBILITY_PRIVATE
;
2885 case CXXFLAGS_VISIBILITY_PROTECTED
:
2886 visibility
= DEBUG_VISIBILITY_PROTECTED
;
2890 constp
= (flags
& CXXFLAGS_CONST
) != 0 ? true : false;
2891 volatilep
= (flags
& CXXFLAGS_VOLATILE
) != 0 ? true : false;
2893 mangledcopy
= savestring (mangled
, mangledlen
);
2895 if ((flags
& CXXFLAGS_STATIC
) != 0)
2899 ieee_error (info
, start
, "C++ static virtual method");
2902 mv
= debug_make_static_method_variant (dhandle
, mangledcopy
,
2908 debug_type vcontext
;
2911 vcontext
= DEBUG_TYPE_NULL
;
2914 /* FIXME: How can we calculate this correctly? */
2915 vcontext
= it
->type
;
2917 mv
= debug_make_method_variant (dhandle
, mangledcopy
, type
,
2922 if (mv
== DEBUG_METHOD_VARIANT_NULL
)
2925 for (meth
= methods
, im
= 0; im
< methods_count
; meth
++, im
++)
2926 if (meth
->namlen
== namlen
2927 && strncmp (meth
->name
, name
, namlen
) == 0)
2929 if (im
>= methods_count
)
2931 if (methods_count
>= methods_alloc
)
2933 methods_alloc
+= 10;
2934 methods
= ((struct ieee_method
*)
2936 methods_alloc
* sizeof *methods
));
2938 methods
[methods_count
].name
= name
;
2939 methods
[methods_count
].namlen
= namlen
;
2940 methods
[methods_count
].variants
= NULL
;
2941 methods
[methods_count
].count
= 0;
2942 methods
[methods_count
].alloc
= 0;
2943 meth
= methods
+ methods_count
;
2947 if (meth
->count
+ 1 >= meth
->alloc
)
2950 meth
->variants
= ((debug_method_variant
*)
2951 xrealloc (meth
->variants
,
2953 * sizeof *meth
->variants
)));
2956 meth
->variants
[meth
->count
] = mv
;
2958 meth
->variants
[meth
->count
] = DEBUG_METHOD_VARIANT_NULL
;
2966 /* We have no way to store this information, so we just
2968 if (! ieee_require_asn (info
, pp
, &spec
))
2971 if ((spec
& 4) != 0)
2973 const char *filename
;
2974 unsigned long filenamlen
;
2977 if (! ieee_require_atn65 (info
, pp
, &filename
, &filenamlen
)
2978 || ! ieee_require_asn (info
, pp
, &lineno
))
2982 else if ((spec
& 8) != 0)
2984 const char *mangled
;
2985 unsigned long mangledlen
;
2987 if (! ieee_require_atn65 (info
, pp
, &mangled
, &mangledlen
))
2993 ieee_error (info
, start
,
2994 "unrecognized C++ object overhead spec");
3002 const char *vname
, *basename
;
3003 unsigned long vnamelen
, baselen
;
3004 bfd_vma vsize
, control
;
3006 /* A virtual table pointer. */
3008 if (! ieee_require_atn65 (info
, pp
, &vname
, &vnamelen
)
3009 || ! ieee_require_asn (info
, pp
, &vsize
)
3010 || ! ieee_require_atn65 (info
, pp
, &basename
, &baselen
)
3011 || ! ieee_require_asn (info
, pp
, &control
))
3015 /* We just ignore the control number. We don't care what
3016 the virtual table name is. We have no way to store the
3017 virtual table size, and I don't think we care anyhow. */
3019 /* FIXME: We can't handle multiple virtual table pointers. */
3027 basecopy
= savestring (basename
, baselen
);
3028 vptrbase
= debug_find_tagged_type (dhandle
, basecopy
,
3029 DEBUG_KIND_ILLEGAL
);
3031 if (vptrbase
== DEBUG_TYPE_NULL
)
3033 ieee_error (info
, start
, "undefined C++ vtable");
3042 /* Now that we have seen all the method variants, we can call
3043 debug_make_method for each one. */
3045 if (methods_count
== 0)
3051 dmethods
= ((debug_method
*)
3052 xmalloc ((methods_count
+ 1) * sizeof *dmethods
));
3053 for (i
= 0; i
< methods_count
; i
++)
3057 namcopy
= savestring (methods
[i
].name
, methods
[i
].namlen
);
3058 dmethods
[i
] = debug_make_method (dhandle
, namcopy
,
3059 methods
[i
].variants
);
3060 if (dmethods
[i
] == DEBUG_METHOD_NULL
)
3063 dmethods
[i
] = DEBUG_METHOD_NULL
;
3067 /* The struct type was created as an indirect type pointing at
3068 it->slot. We update it->slot to automatically update all
3069 references to this struct. */
3070 it
->slot
= debug_make_object_type (dhandle
,
3072 debug_get_type_size (dhandle
,
3074 fields
, baseclasses
, dmethods
,
3076 if (it
->slot
== DEBUG_TYPE_NULL
)
3082 /* Read C++ default argument value and reference type information. */
3085 ieee_read_cxx_defaults (info
, pp
, count
)
3086 struct ieee_info
*info
;
3087 const bfd_byte
**pp
;
3088 unsigned long count
;
3090 const bfd_byte
*start
;
3092 unsigned long fnlen
;
3097 /* Giving the function name before the argument count is an addendum
3098 to the spec. The function name is demangled, though, so this
3099 record must always refer to the current function. */
3101 if (info
->blockstack
.bsp
<= info
->blockstack
.stack
3102 || info
->blockstack
.bsp
[-1].fnindx
== (unsigned int) -1)
3104 ieee_error (info
, start
, "C++ default values not in a function");
3108 if (! ieee_require_atn65 (info
, pp
, &fnname
, &fnlen
)
3109 || ! ieee_require_asn (info
, pp
, &defcount
))
3113 while (defcount
-- > 0)
3117 unsigned long strvallen
;
3119 if (! ieee_require_asn (info
, pp
, &type
))
3131 if (! ieee_require_asn (info
, pp
, &val
))
3138 if (! ieee_require_atn65 (info
, pp
, &strval
, &strvallen
))
3144 ieee_error (info
, start
, "unrecognized C++ default type");
3148 /* We have no way to record the default argument values, so we
3149 just ignore them. FIXME. */
3152 /* Any remaining arguments are indices of parameters that are really
3157 debug_type
*arg_slots
;
3159 dhandle
= info
->dhandle
;
3160 arg_slots
= info
->types
.types
[info
->blockstack
.bsp
[-1].fnindx
].arg_slots
;
3166 if (! ieee_require_asn (info
, pp
, &indx
))
3168 /* The index is 1 based. */
3170 if (arg_slots
== NULL
3171 || arg_slots
[indx
] == DEBUG_TYPE_NULL
3172 || (debug_get_type_kind (dhandle
, arg_slots
[indx
])
3173 != DEBUG_KIND_POINTER
))
3175 ieee_error (info
, start
, "reference parameter is not a pointer");
3179 target
= debug_get_target_type (dhandle
, arg_slots
[indx
]);
3180 arg_slots
[indx
] = debug_make_reference_type (dhandle
, target
);
3181 if (arg_slots
[indx
] == DEBUG_TYPE_NULL
)
3189 /* Read a C++ reference definition. */
3192 ieee_read_reference (info
, pp
)
3193 struct ieee_info
*info
;
3194 const bfd_byte
**pp
;
3196 const bfd_byte
*start
;
3198 const char *class, *name
;
3199 unsigned long classlen
, namlen
;
3205 if (! ieee_require_asn (info
, pp
, &flags
))
3208 /* Giving the class name before the member name is in an addendum to
3212 if (! ieee_require_atn65 (info
, pp
, &class, &classlen
))
3216 if (! ieee_require_atn65 (info
, pp
, &name
, &namlen
))
3223 struct ieee_var
*pv
= NULL
;
3225 /* We search from the last variable indices to the first in
3226 hopes of finding local variables correctly. FIXME: This
3227 probably won't work in all cases. On the other hand, I don't
3229 for (i
= (int) info
->vars
.alloc
- 1; i
>= 0; i
--)
3233 pv
= info
->vars
.vars
+ i
;
3235 if (pv
->pslot
== NULL
3236 || pv
->namlen
!= namlen
3237 || strncmp (pv
->name
, name
, namlen
) != 0)
3244 ieee_error (info
, start
,
3245 "unrecognized C++ reference type");
3249 /* Global variable or function. */
3250 if (pv
->kind
== IEEE_GLOBAL
3251 || pv
->kind
== IEEE_EXTERNAL
3252 || pv
->kind
== IEEE_FUNCTION
)
3257 /* Global static variable or function. */
3258 if (pv
->kind
== IEEE_STATIC
3259 || pv
->kind
== IEEE_FUNCTION
)
3264 /* Local variable. */
3265 if (pv
->kind
== IEEE_LOCAL
)
3279 struct ieee_tag
*it
;
3281 for (it
= info
->tags
; it
!= NULL
; it
= it
->next
)
3283 if (it
->name
[0] == class[0]
3284 && strncmp (it
->name
, class, classlen
) == 0
3285 && strlen (it
->name
) == classlen
)
3287 if (it
->fslots
!= NULL
)
3289 const debug_field
*pf
;
3292 pf
= debug_get_fields (info
->dhandle
, it
->type
);
3295 ieee_error (info
, start
,
3296 "C++ reference in class with no fields");
3300 for (findx
= 0; *pf
!= DEBUG_FIELD_NULL
; pf
++, findx
++)
3304 fname
= debug_get_field_name (info
->dhandle
, *pf
);
3307 if (strncmp (fname
, name
, namlen
) == 0
3308 && strlen (fname
) == namlen
)
3310 pslot
= it
->fslots
+ findx
;
3323 ieee_error (info
, start
, "C++ reference not found");
3327 /* We allocated the type of the object as an indirect type pointing
3328 to *pslot, which we can now update to be a reference type. */
3329 if (debug_get_type_kind (info
->dhandle
, *pslot
) != DEBUG_KIND_POINTER
)
3331 ieee_error (info
, start
, "C++ reference is not pointer");
3335 target
= debug_get_target_type (info
->dhandle
, *pslot
);
3336 *pslot
= debug_make_reference_type (info
->dhandle
, target
);
3337 if (*pslot
== DEBUG_TYPE_NULL
)
3343 /* Require an ASN record. */
3346 ieee_require_asn (info
, pp
, pv
)
3347 struct ieee_info
*info
;
3348 const bfd_byte
**pp
;
3351 const bfd_byte
*start
;
3352 ieee_record_enum_type c
;
3357 c
= (ieee_record_enum_type
) **pp
;
3358 if (c
!= ieee_e2_first_byte_enum
)
3360 ieee_error (info
, start
, "missing required ASN");
3365 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
3366 if (c
!= ieee_asn_record_enum
)
3368 ieee_error (info
, start
, "missing required ASN");
3373 /* Just ignore the variable index. */
3374 if (! ieee_read_number (info
, pp
, &varindx
))
3377 return ieee_read_expression (info
, pp
, pv
);
3380 /* Require an ATN65 record. */
3383 ieee_require_atn65 (info
, pp
, pname
, pnamlen
)
3384 struct ieee_info
*info
;
3385 const bfd_byte
**pp
;
3387 unsigned long *pnamlen
;
3389 const bfd_byte
*start
;
3390 ieee_record_enum_type c
;
3391 bfd_vma name_indx
, type_indx
, atn_code
;
3395 c
= (ieee_record_enum_type
) **pp
;
3396 if (c
!= ieee_at_record_enum
)
3398 ieee_error (info
, start
, "missing required ATN65");
3403 c
= (ieee_record_enum_type
) (((unsigned int) c
<< 8) | **pp
);
3404 if (c
!= ieee_atn_record_enum
)
3406 ieee_error (info
, start
, "missing required ATN65");
3411 if (! ieee_read_number (info
, pp
, &name_indx
)
3412 || ! ieee_read_number (info
, pp
, &type_indx
)
3413 || ! ieee_read_number (info
, pp
, &atn_code
))
3416 /* Just ignore name_indx. */
3418 if (type_indx
!= 0 || atn_code
!= 65)
3420 ieee_error (info
, start
, "bad ATN65 record");
3424 return ieee_read_id (info
, pp
, pname
, pnamlen
);
3427 /* Convert a register number in IEEE debugging information into a
3428 generic register number. */
3431 ieee_regno_to_genreg (abfd
, r
)
3438 /* Convert a generic register number to an IEEE specific one. */
3441 ieee_genreg_to_regno (abfd
, r
)
3448 /* These routines build IEEE debugging information out of the generic
3449 debugging information. */
3451 /* We build the IEEE debugging information byte by byte. Rather than
3452 waste time copying data around, we use a linked list of buffers to
3455 #define IEEE_BUFSIZE (490)
3460 struct ieee_buf
*next
;
3461 /* Number of data bytes in this buffer. */
3464 bfd_byte buf
[IEEE_BUFSIZE
];
3467 /* In order to generate the BB11 blocks required by the HP emulator,
3468 we keep track of ranges of addresses which correspond to a given
3469 compilation unit. */
3474 struct ieee_range
*next
;
3481 /* This structure holds information for a class on the type stack. */
3483 struct ieee_type_class
3485 /* The name index in the debugging information. */
3487 /* The pmisc records for the class. */
3488 struct ieee_buf
*pmiscbuf
;
3489 /* The number of pmisc records. */
3490 unsigned int pmisccount
;
3491 /* The name of the class holding the virtual table, if not this
3494 /* Whether this class holds its own virtual table. */
3496 /* The largest virtual table offset seen so far. */
3498 /* The current method. */
3500 /* Additional pmisc records used to record fields of reference type. */
3501 struct ieee_buf
*refs
;
3504 /* This is how we store types for the writing routines. Most types
3505 are simply represented by a type index. */
3507 struct ieee_write_type
3511 /* The size of the type, if known. */
3513 /* The name of the type, if any. */
3515 /* If this is a function or method type, we build the type here, and
3516 only add it to the output buffers if we need it. */
3517 struct ieee_buf
*fndef
;
3518 /* If this is a struct, this is where the struct definition is
3520 struct ieee_buf
*strdef
;
3521 /* If this is a class, this is where the class information is built. */
3522 struct ieee_type_class
*classdef
;
3523 /* Whether the type is unsigned. */
3524 unsigned int unsignedp
: 1;
3525 /* Whether this is a reference type. */
3526 unsigned int referencep
: 1;
3529 /* This is the type stack used by the debug writing routines. FIXME:
3530 We could generate more efficient output if we remembered when we
3531 have output a particular type before. */
3533 struct ieee_type_stack
3535 /* Next entry on stack. */
3536 struct ieee_type_stack
*next
;
3537 /* Type information. */
3538 struct ieee_write_type type
;
3541 /* This is a list of associations between names and types. This could
3542 be more efficiently implemented as a hash table. */
3544 struct ieee_name_type
3546 /* Next name/type assocation. */
3547 struct ieee_name_type
*next
;
3549 struct ieee_write_type type
;
3550 /* If this is a tag which has not yet been defined, this is the
3551 kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
3552 enum debug_type_kind kind
;
3555 /* We keep a list of modified versions of types, so that we don't
3556 output them more than once. */
3558 struct ieee_modified_type
3560 /* Pointer to this type. */
3561 unsigned int pointer
;
3562 /* Const version of this type. */
3563 unsigned int const_qualified
;
3564 /* Volatile version of this type. */
3565 unsigned int volatile_qualified
;
3568 /* This is a list of pending function parameter information. We don't
3569 output them until we see the first block. */
3571 struct ieee_pending_parm
3573 /* Next pending parameter. */
3574 struct ieee_pending_parm
*next
;
3579 /* Whether the type is a reference. */
3582 enum debug_parm_kind kind
;
3587 /* This is the handle passed down by debug_write. */
3591 /* BFD we are writing to. */
3593 /* Current data buffer. */
3594 struct ieee_buf
*current
;
3595 /* Filename of current compilation unit. */
3596 const char *filename
;
3597 /* Module name of current compilation unit. */
3598 const char *modname
;
3599 /* List of finished data buffers. */
3600 struct ieee_buf
*data
;
3601 /* List of buffers for typedefs in the current compilation unit. */
3602 struct ieee_buf
*types
;
3603 /* List of buffers for variables and functions in the current
3604 compilation unit. */
3605 struct ieee_buf
*vars
;
3606 /* List of buffers for C++ class definitions in the current
3607 compilation unit. */
3608 struct ieee_buf
*cxx
;
3609 /* List of buffers for line numbers in the current compilation unit. */
3610 struct ieee_buf
*linenos
;
3611 /* Ranges for the current compilation unit. */
3612 struct ieee_range
*ranges
;
3613 /* Nested pending ranges. */
3614 struct ieee_range
*pending_ranges
;
3616 struct ieee_type_stack
*type_stack
;
3617 /* Next unallocated type index. */
3618 unsigned int type_indx
;
3619 /* Next unallocated name index. */
3620 unsigned int name_indx
;
3622 struct ieee_name_type
*typedefs
;
3624 struct ieee_name_type
*tags
;
3625 /* Modified versions of types. */
3626 struct ieee_modified_type
*modified
;
3627 /* Number of entries allocated in modified. */
3628 unsigned int modified_alloc
;
3629 /* The depth of block nesting. This is 0 outside a function, and 1
3630 just after start_function is called. */
3631 unsigned int block_depth
;
3632 /* The name of the current function. */
3634 /* List of buffers for the type of the function we are currently
3636 struct ieee_buf
*fntype
;
3637 /* List of buffers for the parameters of the function we are
3638 currently writing out. */
3639 struct ieee_buf
*fnargs
;
3640 /* Number of arguments written to fnargs. */
3641 unsigned int fnargcount
;
3642 /* Pending function parameters. */
3643 struct ieee_pending_parm
*pending_parms
;
3644 /* Current line number filename. */
3645 const char *lineno_filename
;
3646 /* Line number name index. */
3647 unsigned int lineno_name_indx
;
3648 /* Highest address seen at end of procedure. */
3652 static boolean ieee_change_buffer
3653 PARAMS ((struct ieee_handle
*, struct ieee_buf
**));
3654 static boolean ieee_real_write_byte
PARAMS ((struct ieee_handle
*, int));
3655 static boolean ieee_write_2bytes
PARAMS ((struct ieee_handle
*, int));
3656 static boolean ieee_write_number
PARAMS ((struct ieee_handle
*, bfd_vma
));
3657 static boolean ieee_write_id
PARAMS ((struct ieee_handle
*, const char *));
3658 static boolean ieee_write_asn
3659 PARAMS ((struct ieee_handle
*, unsigned int, bfd_vma
));
3660 static boolean ieee_write_atn65
3661 PARAMS ((struct ieee_handle
*, unsigned int, const char *));
3662 static boolean ieee_push_type
3663 PARAMS ((struct ieee_handle
*, unsigned int, unsigned int, boolean
));
3664 static unsigned int ieee_pop_type
PARAMS ((struct ieee_handle
*));
3665 static void ieee_pop_unused_type
PARAMS ((struct ieee_handle
*));
3666 static unsigned int ieee_pop_type_used
3667 PARAMS ((struct ieee_handle
*, boolean
));
3668 static boolean ieee_add_range
3669 PARAMS ((struct ieee_handle
*, bfd_vma
, bfd_vma
));
3670 static boolean ieee_start_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
3671 static boolean ieee_end_range
PARAMS ((struct ieee_handle
*, bfd_vma
));
3672 static boolean ieee_define_type
3673 PARAMS ((struct ieee_handle
*, unsigned int, boolean
));
3674 static boolean ieee_define_named_type
3675 PARAMS ((struct ieee_handle
*, const char *, boolean
, unsigned int,
3676 unsigned int, boolean
, struct ieee_buf
**));
3677 static struct ieee_modified_type
*ieee_get_modified_info
3678 PARAMS ((struct ieee_handle
*, unsigned int));
3679 static boolean ieee_finish_compilation_unit
PARAMS ((struct ieee_handle
*));
3680 static boolean ieee_output_pending_parms
PARAMS ((struct ieee_handle
*));
3681 static unsigned int ieee_vis_to_flags
PARAMS ((enum debug_visibility
));
3682 static boolean ieee_class_method_var
3683 PARAMS ((struct ieee_handle
*, const char *, enum debug_visibility
, boolean
,
3684 boolean
, boolean
, bfd_vma
, boolean
));
3686 static boolean ieee_start_compilation_unit
PARAMS ((PTR
, const char *));
3687 static boolean ieee_start_source
PARAMS ((PTR
, const char *));
3688 static boolean ieee_empty_type
PARAMS ((PTR
));
3689 static boolean ieee_void_type
PARAMS ((PTR
));
3690 static boolean ieee_int_type
PARAMS ((PTR
, unsigned int, boolean
));
3691 static boolean ieee_float_type
PARAMS ((PTR
, unsigned int));
3692 static boolean ieee_complex_type
PARAMS ((PTR
, unsigned int));
3693 static boolean ieee_bool_type
PARAMS ((PTR
, unsigned int));
3694 static boolean ieee_enum_type
3695 PARAMS ((PTR
, const char *, const char **, bfd_signed_vma
*));
3696 static boolean ieee_pointer_type
PARAMS ((PTR
));
3697 static boolean ieee_function_type
PARAMS ((PTR
, int, boolean
));
3698 static boolean ieee_reference_type
PARAMS ((PTR
));
3699 static boolean ieee_range_type
PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
));
3700 static boolean ieee_array_type
3701 PARAMS ((PTR
, bfd_signed_vma
, bfd_signed_vma
, boolean
));
3702 static boolean ieee_set_type
PARAMS ((PTR
, boolean
));
3703 static boolean ieee_offset_type
PARAMS ((PTR
));
3704 static boolean ieee_method_type
PARAMS ((PTR
, boolean
, int, boolean
));
3705 static boolean ieee_const_type
PARAMS ((PTR
));
3706 static boolean ieee_volatile_type
PARAMS ((PTR
));
3707 static boolean ieee_start_struct_type
3708 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int));
3709 static boolean ieee_struct_field
3710 PARAMS ((PTR
, const char *, bfd_vma
, bfd_vma
, enum debug_visibility
));
3711 static boolean ieee_end_struct_type
PARAMS ((PTR
));
3712 static boolean ieee_start_class_type
3713 PARAMS ((PTR
, const char *, unsigned int, boolean
, unsigned int, boolean
,
3715 static boolean ieee_class_static_member
3716 PARAMS ((PTR
, const char *, const char *, enum debug_visibility
));
3717 static boolean ieee_class_baseclass
3718 PARAMS ((PTR
, bfd_vma
, boolean
, enum debug_visibility
));
3719 static boolean ieee_class_start_method
PARAMS ((PTR
, const char *));
3720 static boolean ieee_class_method_variant
3721 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
,
3723 static boolean ieee_class_static_method_variant
3724 PARAMS ((PTR
, const char *, enum debug_visibility
, boolean
, boolean
));
3725 static boolean ieee_class_end_method
PARAMS ((PTR
));
3726 static boolean ieee_end_class_type
PARAMS ((PTR
));
3727 static boolean ieee_typedef_type
PARAMS ((PTR
, const char *));
3728 static boolean ieee_tag_type
3729 PARAMS ((PTR
, const char *, unsigned int, enum debug_type_kind
));
3730 static boolean ieee_typdef
PARAMS ((PTR
, const char *));
3731 static boolean ieee_tag
PARAMS ((PTR
, const char *));
3732 static boolean ieee_int_constant
PARAMS ((PTR
, const char *, bfd_vma
));
3733 static boolean ieee_float_constant
PARAMS ((PTR
, const char *, double));
3734 static boolean ieee_typed_constant
PARAMS ((PTR
, const char *, bfd_vma
));
3735 static boolean ieee_variable
3736 PARAMS ((PTR
, const char *, enum debug_var_kind
, bfd_vma
));
3737 static boolean ieee_start_function
PARAMS ((PTR
, const char *, boolean
));
3738 static boolean ieee_function_parameter
3739 PARAMS ((PTR
, const char *, enum debug_parm_kind
, bfd_vma
));
3740 static boolean ieee_start_block
PARAMS ((PTR
, bfd_vma
));
3741 static boolean ieee_end_block
PARAMS ((PTR
, bfd_vma
));
3742 static boolean ieee_end_function
PARAMS ((PTR
));
3743 static boolean ieee_lineno
3744 PARAMS ((PTR
, const char *, unsigned long, bfd_vma
));
3746 static const struct debug_write_fns ieee_fns
=
3748 ieee_start_compilation_unit
,
3759 ieee_reference_type
,
3767 ieee_start_struct_type
,
3769 ieee_end_struct_type
,
3770 ieee_start_class_type
,
3771 ieee_class_static_member
,
3772 ieee_class_baseclass
,
3773 ieee_class_start_method
,
3774 ieee_class_method_variant
,
3775 ieee_class_static_method_variant
,
3776 ieee_class_end_method
,
3777 ieee_end_class_type
,
3783 ieee_float_constant
,
3784 ieee_typed_constant
,
3786 ieee_start_function
,
3787 ieee_function_parameter
,
3794 /* Change the current buffer to a specified buffer chain. */
3797 ieee_change_buffer (info
, ppbuf
)
3798 struct ieee_handle
*info
;
3799 struct ieee_buf
**ppbuf
;
3801 struct ieee_buf
*buf
;
3805 for (buf
= *ppbuf
; buf
->next
!= NULL
; buf
= buf
->next
)
3810 buf
= (struct ieee_buf
*) xmalloc (sizeof *buf
);
3816 info
->current
= buf
;
3820 /* Write a byte into the buffer. We use a macro for speed and a
3821 function for the complex cases. */
3823 #define ieee_write_byte(info, b) \
3824 ((info)->current->c < IEEE_BUFSIZE \
3825 ? ((info)->current->buf[(info)->current->c++] = (b), true) \
3826 : ieee_real_write_byte ((info), (b)))
3829 ieee_real_write_byte (info
, b
)
3830 struct ieee_handle
*info
;
3833 if (info
->current
->c
>= IEEE_BUFSIZE
)
3837 n
= (struct ieee_buf
*) xmalloc (sizeof *n
);
3840 info
->current
->next
= n
;
3844 info
->current
->buf
[info
->current
->c
] = b
;
3850 /* Write out two bytes. */
3853 ieee_write_2bytes (info
, i
)
3854 struct ieee_handle
*info
;
3857 return (ieee_write_byte (info
, i
>> 8)
3858 && ieee_write_byte (info
, i
& 0xff));
3861 /* Write out an integer. */
3864 ieee_write_number (info
, v
)
3865 struct ieee_handle
*info
;
3873 if (v
<= (bfd_vma
) ieee_number_end_enum
)
3874 return ieee_write_byte (info
, (int) v
);
3885 if (c
> (unsigned int) (ieee_number_repeat_end_enum
3886 - ieee_number_repeat_start_enum
))
3888 fprintf (stderr
, "IEEE numeric overflow: 0x");
3889 fprintf_vma (stderr
, v
);
3890 fprintf (stderr
, "\n");
3894 if (! ieee_write_byte (info
, (int) ieee_number_repeat_start_enum
+ c
))
3896 for (; c
> 0; --c
, ++p
)
3898 if (! ieee_write_byte (info
, *p
))
3905 /* Write out a string. */
3908 ieee_write_id (info
, s
)
3909 struct ieee_handle
*info
;
3917 if (! ieee_write_byte (info
, len
))
3920 else if (len
<= 0xff)
3922 if (! ieee_write_byte (info
, (int) ieee_extension_length_1_enum
)
3923 || ! ieee_write_byte (info
, len
))
3926 else if (len
<= 0xffff)
3928 if (! ieee_write_byte (info
, (int) ieee_extension_length_2_enum
)
3929 || ! ieee_write_2bytes (info
, len
))
3934 fprintf (stderr
, "IEEE string length overflow: %u\n", len
);
3938 for (; *s
!= '\0'; s
++)
3939 if (! ieee_write_byte (info
, *s
))
3945 /* Write out an ASN record. */
3948 ieee_write_asn (info
, indx
, val
)
3949 struct ieee_handle
*info
;
3953 return (ieee_write_2bytes (info
, (int) ieee_asn_record_enum
)
3954 && ieee_write_number (info
, indx
)
3955 && ieee_write_number (info
, val
));
3958 /* Write out an ATN65 record. */
3961 ieee_write_atn65 (info
, indx
, s
)
3962 struct ieee_handle
*info
;
3966 return (ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
3967 && ieee_write_number (info
, indx
)
3968 && ieee_write_number (info
, 0)
3969 && ieee_write_number (info
, 65)
3970 && ieee_write_id (info
, s
));
3973 /* Push a type index onto the type stack. */
3976 ieee_push_type (info
, indx
, size
, unsignedp
)
3977 struct ieee_handle
*info
;
3982 struct ieee_type_stack
*ts
;
3984 ts
= (struct ieee_type_stack
*) xmalloc (sizeof *ts
);
3985 memset (ts
, 0, sizeof *ts
);
3987 ts
->type
.indx
= indx
;
3988 ts
->type
.size
= size
;
3989 ts
->type
.unsignedp
= unsignedp
;
3991 ts
->next
= info
->type_stack
;
3992 info
->type_stack
= ts
;
3997 /* Pop a type index off the type stack. */
4000 ieee_pop_type (info
)
4001 struct ieee_handle
*info
;
4003 return ieee_pop_type_used (info
, true);
4006 /* Pop an unused type index off the type stack. */
4009 ieee_pop_unused_type (info
)
4010 struct ieee_handle
*info
;
4012 (void) ieee_pop_type_used (info
, false);
4015 /* Pop a used or unused type index off the type stack. */
4018 ieee_pop_type_used (info
, used
)
4019 struct ieee_handle
*info
;
4022 struct ieee_type_stack
*ts
;
4025 ts
= info
->type_stack
;
4026 assert (ts
!= NULL
);
4028 /* If this is a function type, and we need it, we need to append the
4029 actual definition to the typedef block now. */
4030 if (ts
->type
.fndef
!= NULL
&& used
)
4032 struct ieee_buf
**pb
;
4034 /* Make sure we have started the types block. */
4035 if (info
->types
== NULL
)
4037 if (! ieee_change_buffer (info
, &info
->types
)
4038 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4039 || ! ieee_write_byte (info
, 1)
4040 || ! ieee_write_number (info
, 0)
4041 || ! ieee_write_id (info
, info
->modname
))
4045 for (pb
= &info
->types
; *pb
!= NULL
; pb
= &(*pb
)->next
)
4047 *pb
= ts
->type
.fndef
;
4050 ret
= ts
->type
.indx
;
4051 info
->type_stack
= ts
->next
;
4056 /* Add a range of bytes included in the current compilation unit. */
4059 ieee_add_range (info
, low
, high
)
4060 struct ieee_handle
*info
;
4064 struct ieee_range
*r
, **pr
;
4066 if (low
== (bfd_vma
) -1 || high
== (bfd_vma
) -1)
4069 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
4071 if (high
>= r
->low
&& low
<= r
->high
)
4073 /* The new range overlaps r. */
4079 while (*pr
!= NULL
&& (*pr
)->low
<= r
->high
)
4081 struct ieee_range
*n
;
4083 if ((*pr
)->high
> r
->high
)
4084 r
->high
= (*pr
)->high
;
4093 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
4094 memset (r
, 0, sizeof *r
);
4099 /* Store the ranges sorted by address. */
4100 for (pr
= &info
->ranges
; *pr
!= NULL
; pr
= &(*pr
)->next
)
4101 if ((*pr
)->next
!= NULL
&& (*pr
)->next
->low
> high
)
4109 /* Start a new range for which we only have the low address. */
4112 ieee_start_range (info
, low
)
4113 struct ieee_handle
*info
;
4116 struct ieee_range
*r
;
4118 r
= (struct ieee_range
*) xmalloc (sizeof *r
);
4119 memset (r
, 0, sizeof *r
);
4121 r
->next
= info
->pending_ranges
;
4122 info
->pending_ranges
= r
;
4126 /* Finish a range started by ieee_start_range. */
4129 ieee_end_range (info
, high
)
4130 struct ieee_handle
*info
;
4133 struct ieee_range
*r
;
4136 assert (info
->pending_ranges
!= NULL
);
4137 r
= info
->pending_ranges
;
4139 info
->pending_ranges
= r
->next
;
4141 return ieee_add_range (info
, low
, high
);
4144 /* Start defining a type. */
4147 ieee_define_type (info
, size
, unsignedp
)
4148 struct ieee_handle
*info
;
4152 return ieee_define_named_type (info
, (const char *) NULL
, false, 0, size
,
4153 unsignedp
, (struct ieee_buf
**) NULL
);
4156 /* Start defining a named type. */
4159 ieee_define_named_type (info
, name
, tagp
, id
, size
, unsignedp
, ppbuf
)
4160 struct ieee_handle
*info
;
4166 struct ieee_buf
**ppbuf
;
4168 unsigned int type_indx
;
4169 unsigned int name_indx
;
4171 if (! tagp
|| id
== (unsigned int) -1)
4173 type_indx
= info
->type_indx
;
4178 struct ieee_name_type
*nt
;
4182 /* We need to create a tag for internal use even if we don't
4183 want one for external use. This will let us refer to an
4184 anonymous struct. */
4189 sprintf (ab
, "__anon%u", id
);
4193 /* The name is a tag. If we have already defined the tag, we
4194 must use the existing type index. */
4195 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
4196 if (nt
->type
.name
[0] == tag
[0]
4197 && strcmp (nt
->type
.name
, tag
) == 0)
4202 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
4203 memset (nt
, 0, sizeof *nt
);
4206 nt
->type
.name
= tag
;
4207 nt
->next
= info
->tags
;
4209 nt
->type
.indx
= info
->type_indx
;
4213 nt
->type
.size
= size
;
4214 nt
->type
.unsignedp
= unsignedp
;
4215 nt
->kind
= DEBUG_KIND_ILLEGAL
;
4217 type_indx
= nt
->type
.indx
;
4220 name_indx
= info
->name_indx
;
4226 /* If we were given a buffer, use it; otherwise, use the general
4227 type information, and make sure that the type block is started. */
4230 if (! ieee_change_buffer (info
, ppbuf
))
4233 else if (info
->types
!= NULL
)
4235 if (! ieee_change_buffer (info
, &info
->types
))
4240 if (! ieee_change_buffer (info
, &info
->types
)
4241 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4242 || ! ieee_write_byte (info
, 1)
4243 || ! ieee_write_number (info
, 0)
4244 || ! ieee_write_id (info
, info
->modname
))
4248 /* Push the new type on the type stack, write out an NN record, and
4249 write out the start of a TY record. The caller will then finish
4251 return (ieee_push_type (info
, type_indx
, size
, unsignedp
)
4252 && ieee_write_byte (info
, (int) ieee_nn_record
)
4253 && ieee_write_number (info
, name_indx
)
4254 && ieee_write_id (info
, name
)
4255 && ieee_write_byte (info
, (int) ieee_ty_record_enum
)
4256 && ieee_write_number (info
, type_indx
)
4257 && ieee_write_byte (info
, 0xce)
4258 && ieee_write_number (info
, name_indx
));
4261 /* Get an entry to the list of modified versions of a type. */
4263 static struct ieee_modified_type
*
4264 ieee_get_modified_info (info
, indx
)
4265 struct ieee_handle
*info
;
4268 if (indx
>= info
->modified_alloc
)
4270 unsigned int nalloc
;
4272 nalloc
= info
->modified_alloc
;
4275 while (indx
>= nalloc
)
4277 info
->modified
= ((struct ieee_modified_type
*)
4278 xrealloc (info
->modified
,
4279 nalloc
* sizeof *info
->modified
));
4280 memset (info
->modified
+ info
->modified_alloc
, 0,
4281 (nalloc
- info
->modified_alloc
) * sizeof *info
->modified
);
4282 info
->modified_alloc
= nalloc
;
4285 return info
->modified
+ indx
;
4288 /* The general routine to write out IEEE debugging information. */
4291 write_ieee_debugging_info (abfd
, dhandle
)
4295 struct ieee_handle info
;
4296 struct ieee_buf
*tags
;
4297 struct ieee_name_type
*nt
;
4302 memset (&info
, 0, sizeof info
);
4304 info
.type_indx
= 256;
4305 info
.name_indx
= 32;
4307 if (! debug_write (dhandle
, &ieee_fns
, (PTR
) &info
))
4310 if (info
.filename
!= NULL
)
4312 if (! ieee_finish_compilation_unit (&info
))
4316 /* Put any undefined tags in the global typedef information. */
4318 for (nt
= info
.tags
; nt
!= NULL
; nt
= nt
->next
)
4320 unsigned int name_indx
;
4323 if (nt
->kind
== DEBUG_KIND_ILLEGAL
)
4327 if (! ieee_change_buffer (&info
, &tags
)
4328 || ! ieee_write_byte (&info
, (int) ieee_bb_record_enum
)
4329 || ! ieee_write_byte (&info
, 2)
4330 || ! ieee_write_number (&info
, 0)
4331 || ! ieee_write_id (&info
, ""))
4334 name_indx
= info
.name_indx
;
4336 if (! ieee_write_byte (&info
, (int) ieee_nn_record
)
4337 || ! ieee_write_number (&info
, name_indx
)
4338 || ! ieee_write_id (&info
, nt
->type
.name
)
4339 || ! ieee_write_byte (&info
, (int) ieee_ty_record_enum
)
4340 || ! ieee_write_number (&info
, nt
->type
.indx
)
4341 || ! ieee_write_byte (&info
, 0xce)
4342 || ! ieee_write_number (&info
, name_indx
))
4349 case DEBUG_KIND_STRUCT
:
4350 case DEBUG_KIND_CLASS
:
4353 case DEBUG_KIND_UNION
:
4354 case DEBUG_KIND_UNION_CLASS
:
4357 case DEBUG_KIND_ENUM
:
4361 if (! ieee_write_number (&info
, code
)
4362 || ! ieee_write_number (&info
, 0))
4367 struct ieee_buf
**pb
;
4369 if (! ieee_write_byte (&info
, (int) ieee_be_record_enum
))
4372 for (pb
= &tags
; *pb
!= NULL
; pb
= &(*pb
)->next
)
4378 /* Now all the data is in info.data. Write it out to the BFD. We
4379 normally would need to worry about whether all the other sections
4380 are set up yet, but the IEEE backend will handle this particular
4381 case correctly regardless. */
4382 if (info
.data
== NULL
)
4384 /* There is no debugging information. */
4388 s
= bfd_make_section (abfd
, ".debug");
4390 err
= "bfd_make_section";
4393 if (! bfd_set_section_flags (abfd
, s
, SEC_DEBUGGING
| SEC_HAS_CONTENTS
))
4394 err
= "bfd_set_section_flags";
4401 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
4403 if (! bfd_set_section_size (abfd
, s
, size
))
4404 err
= "bfd_set_section_size";
4411 for (b
= info
.data
; b
!= NULL
; b
= b
->next
)
4413 if (! bfd_set_section_contents (abfd
, s
, b
->buf
, offset
, b
->c
))
4415 err
= "bfd_set_section_contents";
4424 fprintf (stderr
, "%s: %s: %s\n", bfd_get_filename (abfd
), err
,
4425 bfd_errmsg (bfd_get_error ()));
4432 /* Start writing out information for a compilation unit. */
4435 ieee_start_compilation_unit (p
, filename
)
4437 const char *filename
;
4439 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4440 const char *modname
;
4443 if (info
->filename
!= NULL
)
4445 if (! ieee_finish_compilation_unit (info
))
4449 info
->filename
= filename
;
4450 modname
= strrchr (filename
, '/');
4451 if (modname
!= NULL
)
4455 modname
= strrchr (filename
, '\\');
4456 if (modname
!= NULL
)
4461 c
= xstrdup (modname
);
4462 s
= strrchr (c
, '.');
4470 info
->linenos
= NULL
;
4471 info
->ranges
= NULL
;
4472 info
->modified
= NULL
;
4473 info
->modified_alloc
= 0;
4478 /* Finish up a compilation unit. */
4481 ieee_finish_compilation_unit (info
)
4482 struct ieee_handle
*info
;
4484 struct ieee_buf
**pp
;
4485 struct ieee_range
*r
;
4487 if (info
->types
!= NULL
)
4489 if (! ieee_change_buffer (info
, &info
->types
)
4490 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4494 if (info
->cxx
!= NULL
)
4496 /* Append any C++ information to the global function and
4497 variable information. */
4498 if (info
->vars
!= NULL
)
4500 if (! ieee_change_buffer (info
, &info
->vars
))
4505 if (! ieee_change_buffer (info
, &info
->vars
)
4506 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4507 || ! ieee_write_byte (info
, 3)
4508 || ! ieee_write_number (info
, 0)
4509 || ! ieee_write_id (info
, info
->modname
))
4513 /* We put the pmisc records in a dummy procedure, just as the
4514 MRI compiler does. */
4515 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4516 || ! ieee_write_byte (info
, 6)
4517 || ! ieee_write_number (info
, 0)
4518 || ! ieee_write_id (info
, "__XRYCPP")
4519 || ! ieee_write_number (info
, 0)
4520 || ! ieee_write_number (info
, 0)
4521 || ! ieee_write_number (info
, info
->highaddr
))
4524 for (pp
= &info
->vars
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4528 if (! ieee_change_buffer (info
, &info
->vars
)
4529 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4530 || ! ieee_write_number (info
, info
->highaddr
))
4534 if (info
->vars
!= NULL
)
4536 if (! ieee_change_buffer (info
, &info
->vars
)
4537 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4541 if (info
->linenos
!= NULL
)
4543 if (! ieee_change_buffer (info
, &info
->linenos
)
4544 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4548 for (pp
= &info
->data
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4551 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
4554 for (; *pp
!= NULL
; pp
= &(*pp
)->next
)
4556 *pp
= info
->linenos
;
4558 /* Build BB10/BB11 blocks based on the ranges we recorded. */
4559 if (! ieee_change_buffer (info
, &info
->data
))
4562 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4563 || ! ieee_write_byte (info
, 10)
4564 || ! ieee_write_number (info
, 0)
4565 || ! ieee_write_id (info
, info
->modname
)
4566 || ! ieee_write_id (info
, "")
4567 || ! ieee_write_number (info
, 0)
4568 || ! ieee_write_id (info
, "GNU objcopy"))
4571 for (r
= info
->ranges
; r
!= NULL
; r
= r
->next
)
4580 /* Find the section corresponding to this range. */
4581 for (s
= info
->abfd
->sections
; s
!= NULL
; s
= s
->next
)
4583 if (bfd_get_section_vma (info
->abfd
, s
) <= low
4584 && high
<= (bfd_get_section_vma (info
->abfd
, s
)
4585 + bfd_section_size (info
->abfd
, s
)))
4591 /* Just ignore this range. */
4595 /* Coalesce ranges if it seems reasonable. */
4596 while (r
->next
!= NULL
4597 && high
+ 64 >= r
->next
->low
4599 <= (bfd_get_section_vma (info
->abfd
, s
)
4600 + bfd_section_size (info
->abfd
, s
))))
4603 high
= r
->next
->high
;
4606 if ((s
->flags
& SEC_CODE
) != 0)
4608 else if ((s
->flags
& SEC_READONLY
) != 0)
4613 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
4614 || ! ieee_write_byte (info
, 11)
4615 || ! ieee_write_number (info
, 0)
4616 || ! ieee_write_id (info
, "")
4617 || ! ieee_write_number (info
, kind
)
4618 || ! ieee_write_number (info
, s
->index
)
4619 || ! ieee_write_number (info
, low
)
4620 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
4621 || ! ieee_write_number (info
, high
- low
))
4625 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
4631 /* Start recording information from a particular source file. This is
4632 used to record which file defined which types, variables, etc. It
4633 is not used for line numbers, since the lineno entry point passes
4634 down the file name anyhow. IEEE debugging information doesn't seem
4635 to store this information anywhere. */
4639 ieee_start_source (p
, filename
)
4641 const char *filename
;
4646 /* Make an empty type. */
4652 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4654 return ieee_push_type (info
, 0, 0, false);
4657 /* Make a void type. */
4663 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4665 return ieee_push_type (info
, 1, 0, false);
4668 /* Make an integer type. */
4671 ieee_int_type (p
, size
, unsignedp
)
4676 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4682 indx
= (int) builtin_signed_char
;
4685 indx
= (int) builtin_signed_short_int
;
4688 indx
= (int) builtin_signed_long
;
4691 indx
= (int) builtin_signed_long_long
;
4694 fprintf (stderr
, "IEEE unsupported integer type size %u\n", size
);
4701 return ieee_push_type (info
, indx
, size
, unsignedp
);
4704 /* Make a floating point type. */
4707 ieee_float_type (p
, size
)
4711 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4717 indx
= (int) builtin_float
;
4720 indx
= (int) builtin_double
;
4723 /* FIXME: This size really depends upon the processor. */
4724 indx
= (int) builtin_long_double
;
4727 indx
= (int) builtin_long_long_double
;
4730 fprintf (stderr
, "IEEE unsupported float type size %u\n", size
);
4734 return ieee_push_type (info
, indx
, size
, false);
4737 /* Make a complex type. */
4740 ieee_complex_type (p
, size
)
4744 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4756 fprintf (stderr
, "IEEE unsupported complex type size %u\n", size
);
4760 /* FIXME: I don't know what the string is for. */
4761 return (ieee_define_type (info
, size
, false)
4762 && ieee_write_number (info
, code
)
4763 && ieee_write_id (info
, ""));
4766 /* Make a boolean type. IEEE doesn't support these, so we just make
4767 an integer type instead. */
4770 ieee_bool_type (p
, size
)
4774 return ieee_int_type (p
, size
, true);
4777 /* Make an enumeration. */
4780 ieee_enum_type (p
, tag
, names
, vals
)
4784 bfd_signed_vma
*vals
;
4786 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4790 /* If this is a simple enumeration, in which the values start at 0
4791 and always increment by 1, we can use type E. Otherwise we must
4797 for (i
= 0; names
[i
] != NULL
; i
++)
4807 if (! ieee_define_named_type (info
, tag
, true, (unsigned int) -1, 0,
4808 true, (struct ieee_buf
**) NULL
)
4809 || ! ieee_write_number (info
, simple
? 'E' : 'N'))
4813 /* FIXME: This is supposed to be the enumeration size, but we
4814 don't store that. */
4815 if (! ieee_write_number (info
, 4))
4820 for (i
= 0; names
[i
] != NULL
; i
++)
4822 if (! ieee_write_id (info
, names
[i
]))
4826 if (! ieee_write_number (info
, vals
[i
]))
4835 /* Make a pointer type. */
4838 ieee_pointer_type (p
)
4841 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4843 struct ieee_modified_type
*m
;
4845 indx
= ieee_pop_type (info
);
4847 /* A pointer to a simple builtin type can be obtained by adding 32. */
4849 return ieee_push_type (info
, indx
+ 32, 0, true);
4851 m
= ieee_get_modified_info (p
, indx
);
4856 return ieee_push_type (info
, m
->pointer
, 0, true);
4858 if (! ieee_define_type (info
, 0, true)
4859 || ! ieee_write_number (info
, 'P')
4860 || ! ieee_write_number (info
, indx
))
4863 m
->pointer
= info
->type_stack
->type
.indx
;
4868 /* Make a function type. This will be called for a method, but we
4869 don't want to actually add it to the type table in that case. We
4870 handle this by defining the type in a private buffer, and only
4871 adding that buffer to the typedef block if we are going to use it. */
4874 ieee_function_type (p
, argcount
, varargs
)
4879 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4880 unsigned int *args
= NULL
;
4882 unsigned int retindx
;
4883 struct ieee_buf
*fndef
;
4887 args
= (unsigned int *) xmalloc (argcount
* sizeof *args
);
4888 for (i
= argcount
- 1; i
>= 0; i
--)
4889 args
[i
] = ieee_pop_type (info
);
4891 else if (argcount
< 0)
4894 retindx
= ieee_pop_type (info
);
4896 /* An attribute of 0x41 means that the frame and push mask are
4899 if (! ieee_define_named_type (info
, (const char *) NULL
, false, 0, 0,
4901 || ! ieee_write_number (info
, 'x')
4902 || ! ieee_write_number (info
, 0x41)
4903 || ! ieee_write_number (info
, 0)
4904 || ! ieee_write_number (info
, 0)
4905 || ! ieee_write_number (info
, retindx
)
4906 || ! ieee_write_number (info
, (bfd_vma
) argcount
+ (varargs
? 1 : 0)))
4910 for (i
= 0; i
< argcount
; i
++)
4911 if (! ieee_write_number (info
, args
[i
]))
4917 /* A varargs function is represented by writing out the last
4918 argument as type void *, although this makes little sense. */
4919 if (! ieee_write_number (info
, (bfd_vma
) builtin_void
+ 32))
4923 if (! ieee_write_number (info
, 0))
4926 /* We wrote the information into fndef, in case we don't need it.
4927 It will be appended to info->types by ieee_pop_type. */
4928 info
->type_stack
->type
.fndef
= fndef
;
4933 /* Make a reference type. */
4936 ieee_reference_type (p
)
4939 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4941 /* IEEE appears to record a normal pointer type, and then use a
4942 pmisc record to indicate that it is really a reference. */
4944 if (! ieee_pointer_type (p
))
4946 info
->type_stack
->type
.referencep
= true;
4950 /* Make a range type. */
4953 ieee_range_type (p
, low
, high
)
4956 bfd_signed_vma high
;
4958 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4962 size
= info
->type_stack
->type
.size
;
4963 unsignedp
= info
->type_stack
->type
.unsignedp
;
4964 ieee_pop_unused_type (info
);
4965 return (ieee_define_type (info
, size
, unsignedp
)
4966 && ieee_write_number (info
, 'R')
4967 && ieee_write_number (info
, (bfd_vma
) low
)
4968 && ieee_write_number (info
, (bfd_vma
) high
)
4969 && ieee_write_number (info
, unsignedp
? 0 : 1)
4970 && ieee_write_number (info
, size
));
4973 /* Make an array type. */
4977 ieee_array_type (p
, low
, high
, stringp
)
4980 bfd_signed_vma high
;
4983 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
4984 unsigned int eleindx
;
4986 /* IEEE does not store the range, so we just ignore it. */
4987 ieee_pop_unused_type (info
);
4988 eleindx
= ieee_pop_type (info
);
4990 if (! ieee_define_type (info
, 0, false)
4991 || ! ieee_write_number (info
, low
== 0 ? 'Z' : 'C')
4992 || ! ieee_write_number (info
, eleindx
))
4996 if (! ieee_write_number (info
, low
))
5000 return ieee_write_number (info
, high
);
5003 /* Make a set type. */
5006 ieee_set_type (p
, bitstringp
)
5010 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5011 unsigned int eleindx
;
5013 eleindx
= ieee_pop_type (info
);
5015 /* FIXME: We don't know the size, so we just use 4. */
5017 return (ieee_define_type (info
, 0, true)
5018 && ieee_write_number (info
, 's')
5019 && ieee_write_number (info
, 4)
5020 && ieee_write_number (info
, eleindx
));
5023 /* Make an offset type. */
5026 ieee_offset_type (p
)
5029 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5030 unsigned int targetindx
, baseindx
;
5032 targetindx
= ieee_pop_type (info
);
5033 baseindx
= ieee_pop_type (info
);
5035 /* FIXME: The MRI C++ compiler does not appear to generate any
5036 useful type information about an offset type. It just records a
5037 pointer to member as an integer. The MRI/HP IEEE spec does
5038 describe a pmisc record which can be used for a pointer to
5039 member. Unfortunately, it does not describe the target type,
5040 which seems pretty important. I'm going to punt this for now. */
5042 return ieee_int_type (p
, 4, true);
5045 /* Make a method type. */
5048 ieee_method_type (p
, domain
, argcount
, varargs
)
5054 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5056 /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
5057 method, but the definition is incomplete. We just output an 'x'
5061 ieee_pop_unused_type (info
);
5063 return ieee_function_type (p
, argcount
, varargs
);
5066 /* Make a const qualified type. */
5072 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5076 struct ieee_modified_type
*m
;
5078 size
= info
->type_stack
->type
.size
;
5079 unsignedp
= info
->type_stack
->type
.unsignedp
;
5080 indx
= ieee_pop_type (info
);
5082 m
= ieee_get_modified_info (info
, indx
);
5086 if (m
->const_qualified
> 0)
5087 return ieee_push_type (info
, m
->const_qualified
, size
, unsignedp
);
5089 if (! ieee_define_type (info
, size
, unsignedp
)
5090 || ! ieee_write_number (info
, 'n')
5091 || ! ieee_write_number (info
, 1)
5092 || ! ieee_write_number (info
, indx
))
5095 m
->const_qualified
= info
->type_stack
->type
.indx
;
5100 /* Make a volatile qualified type. */
5103 ieee_volatile_type (p
)
5106 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5110 struct ieee_modified_type
*m
;
5112 size
= info
->type_stack
->type
.size
;
5113 unsignedp
= info
->type_stack
->type
.unsignedp
;
5114 indx
= ieee_pop_type (info
);
5116 m
= ieee_get_modified_info (info
, indx
);
5120 if (m
->volatile_qualified
> 0)
5121 return ieee_push_type (info
, m
->volatile_qualified
, size
, unsignedp
);
5123 if (! ieee_define_type (info
, size
, unsignedp
)
5124 || ! ieee_write_number (info
, 'n')
5125 || ! ieee_write_number (info
, 2)
5126 || ! ieee_write_number (info
, indx
))
5129 m
->volatile_qualified
= info
->type_stack
->type
.indx
;
5134 /* Convert an enum debug_visibility into a CXXFLAGS value. */
5137 ieee_vis_to_flags (visibility
)
5138 enum debug_visibility visibility
;
5144 case DEBUG_VISIBILITY_PUBLIC
:
5145 return CXXFLAGS_VISIBILITY_PUBLIC
;
5146 case DEBUG_VISIBILITY_PRIVATE
:
5147 return CXXFLAGS_VISIBILITY_PRIVATE
;
5148 case DEBUG_VISIBILITY_PROTECTED
:
5149 return CXXFLAGS_VISIBILITY_PROTECTED
;
5154 /* Start defining a struct type. We build it in the strdef field on
5155 the stack, to avoid confusing type definitions required by the
5156 fields with the struct type itself. */
5159 ieee_start_struct_type (p
, tag
, id
, structp
, size
)
5166 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5167 struct ieee_buf
*strdef
;
5170 if (! ieee_define_named_type (info
, tag
, true, id
, size
, true, &strdef
)
5171 || ! ieee_write_number (info
, structp
? 'S' : 'U')
5172 || ! ieee_write_number (info
, size
))
5175 info
->type_stack
->type
.name
= tag
;
5176 info
->type_stack
->type
.strdef
= strdef
;
5181 /* Add a field to a struct. */
5184 ieee_struct_field (p
, name
, bitpos
, bitsize
, visibility
)
5189 enum debug_visibility visibility
;
5191 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5198 size
= info
->type_stack
->type
.size
;
5199 unsignedp
= info
->type_stack
->type
.unsignedp
;
5200 referencep
= info
->type_stack
->type
.referencep
;
5201 indx
= ieee_pop_type (info
);
5203 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
5205 if (info
->type_stack
->type
.classdef
!= NULL
)
5210 /* This is a class. We must add a description of this field to
5211 the class records we are building. */
5213 flags
= ieee_vis_to_flags (visibility
);
5214 nindx
= info
->type_stack
->type
.classdef
->indx
;
5215 if (! ieee_change_buffer (info
,
5216 &info
->type_stack
->type
.classdef
->pmiscbuf
)
5217 || ! ieee_write_asn (info
, nindx
, 'd')
5218 || ! ieee_write_asn (info
, nindx
, flags
)
5219 || ! ieee_write_atn65 (info
, nindx
, name
)
5220 || ! ieee_write_atn65 (info
, nindx
, name
))
5222 info
->type_stack
->type
.classdef
->pmisccount
+= 4;
5228 /* We need to output a record recording that this field is
5229 really of reference type. We put this on the refs field
5230 of classdef, so that it can be appended to the C++
5231 records after the class is defined. */
5233 nindx
= info
->name_indx
;
5236 if (! ieee_change_buffer (info
,
5237 &info
->type_stack
->type
.classdef
->refs
)
5238 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
5239 || ! ieee_write_number (info
, nindx
)
5240 || ! ieee_write_id (info
, "")
5241 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
5242 || ! ieee_write_number (info
, nindx
)
5243 || ! ieee_write_number (info
, 0)
5244 || ! ieee_write_number (info
, 62)
5245 || ! ieee_write_number (info
, 80)
5246 || ! ieee_write_number (info
, 4)
5247 || ! ieee_write_asn (info
, nindx
, 'R')
5248 || ! ieee_write_asn (info
, nindx
, 3)
5249 || ! ieee_write_atn65 (info
, nindx
, info
->type_stack
->type
.name
)
5250 || ! ieee_write_atn65 (info
, nindx
, name
))
5255 /* If the bitsize doesn't match the expected size, we need to output
5257 if (size
== 0 || bitsize
== size
* 8)
5258 offset
= bitpos
/ 8;
5261 if (! ieee_define_type (info
, 0, unsignedp
)
5262 || ! ieee_write_number (info
, 'g')
5263 || ! ieee_write_number (info
, unsignedp
? 0 : 1)
5264 || ! ieee_write_number (info
, indx
))
5266 indx
= ieee_pop_type (info
);
5270 /* Switch to the struct we are building in order to output this
5271 field definition. */
5272 return (ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
5273 && ieee_write_id (info
, name
)
5274 && ieee_write_number (info
, indx
)
5275 && ieee_write_number (info
, offset
));
5278 /* Finish up a struct type. */
5281 ieee_end_struct_type (p
)
5284 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5285 struct ieee_buf
**pb
;
5287 assert (info
->type_stack
!= NULL
&& info
->type_stack
->type
.strdef
!= NULL
);
5289 /* Make sure we have started the types block. */
5290 if (info
->types
== NULL
)
5292 if (! ieee_change_buffer (info
, &info
->types
)
5293 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
5294 || ! ieee_write_byte (info
, 1)
5295 || ! ieee_write_number (info
, 0)
5296 || ! ieee_write_id (info
, info
->modname
))
5300 /* Append the struct definition to the types. */
5301 for (pb
= &info
->types
; *pb
!= NULL
; pb
= &(*pb
)->next
)
5303 *pb
= info
->type_stack
->type
.strdef
;
5304 info
->type_stack
->type
.strdef
= NULL
;
5306 /* Leave the struct on the type stack. */
5311 /* Start a class type. */
5314 ieee_start_class_type (p
, tag
, id
, structp
, size
, vptr
, ownvptr
)
5323 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5325 struct ieee_buf
*pmiscbuf
;
5327 struct ieee_type_class
*classdef
;
5329 /* A C++ class is output as a C++ struct along with a set of pmisc
5330 records describing the class. */
5332 /* We need to have a name so that we can associate the struct and
5338 t
= (char *) xmalloc (20);
5339 sprintf (t
, "__anon%u", id
);
5343 /* We can't write out the virtual table information until we have
5344 finished the class, because we don't know the virtual table size.
5345 We get the size from the largest voffset we see. */
5347 if (vptr
&& ! ownvptr
)
5349 vclass
= info
->type_stack
->type
.name
;
5350 assert (vclass
!= NULL
);
5351 /* We don't call ieee_pop_unused_type, since the class should
5353 (void) ieee_pop_type (info
);
5356 if (! ieee_start_struct_type (p
, tag
, id
, structp
, size
))
5359 indx
= info
->name_indx
;
5362 /* We write out pmisc records into the classdef field. We will
5363 write out the pmisc start after we know the number of records we
5366 if (! ieee_change_buffer (info
, &pmiscbuf
)
5367 || ! ieee_write_asn (info
, indx
, 'T')
5368 || ! ieee_write_asn (info
, indx
, structp
? 'o' : 'u')
5369 || ! ieee_write_atn65 (info
, indx
, tag
))
5372 classdef
= (struct ieee_type_class
*) xmalloc (sizeof *classdef
);
5373 memset (classdef
, 0, sizeof *classdef
);
5375 classdef
->indx
= indx
;
5376 classdef
->pmiscbuf
= pmiscbuf
;
5377 classdef
->pmisccount
= 3;
5378 classdef
->vclass
= vclass
;
5379 classdef
->ownvptr
= ownvptr
;
5381 info
->type_stack
->type
.classdef
= classdef
;
5386 /* Add a static member to a class. */
5389 ieee_class_static_member (p
, name
, physname
, visibility
)
5392 const char *physname
;
5393 enum debug_visibility visibility
;
5395 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5399 /* We don't care about the type. Hopefully there will be a call to
5400 ieee_variable declaring the physical name and the type, since
5401 that is where an IEEE consumer must get the type. */
5402 ieee_pop_unused_type (info
);
5404 assert (info
->type_stack
!= NULL
5405 && info
->type_stack
->type
.classdef
!= NULL
);
5407 flags
= ieee_vis_to_flags (visibility
);
5408 flags
|= CXXFLAGS_STATIC
;
5410 nindx
= info
->type_stack
->type
.classdef
->indx
;
5412 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.classdef
->pmiscbuf
)
5413 || ! ieee_write_asn (info
, nindx
, 'd')
5414 || ! ieee_write_asn (info
, nindx
, flags
)
5415 || ! ieee_write_atn65 (info
, nindx
, name
)
5416 || ! ieee_write_atn65 (info
, nindx
, physname
))
5418 info
->type_stack
->type
.classdef
->pmisccount
+= 4;
5423 /* Add a base class to a class. */
5426 ieee_class_baseclass (p
, bitpos
, virtual, visibility
)
5430 enum debug_visibility visibility
;
5432 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5439 assert (info
->type_stack
!= NULL
5440 && info
->type_stack
->type
.name
!= NULL
5441 && info
->type_stack
->next
!= NULL
5442 && info
->type_stack
->next
->type
.classdef
!= NULL
5443 && info
->type_stack
->next
->type
.strdef
!= NULL
);
5445 bname
= info
->type_stack
->type
.name
;
5446 bindx
= ieee_pop_type (info
);
5448 /* We are currently defining both a struct and a class. We must
5449 write out a field definition in the struct which holds the base
5450 class. The stabs debugging reader will create a field named
5451 _vb$CLASS for a virtual base class, so we just use that. FIXME:
5452 we should not depend upon a detail of stabs debugging. */
5455 fname
= (char *) xmalloc (strlen (bname
) + sizeof "_vb$");
5456 sprintf (fname
, "_vb$%s", bname
);
5457 flags
= BASEFLAGS_VIRTUAL
;
5461 fname
= (char *) xmalloc (strlen (bname
) + sizeof "_b$");
5462 sprintf (fname
, "_b$%s", bname
);
5464 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.strdef
)
5465 || ! ieee_write_id (info
, fname
)
5466 || ! ieee_write_number (info
, bindx
)
5467 || ! ieee_write_number (info
, bitpos
/ 8))
5472 if (visibility
== DEBUG_VISIBILITY_PRIVATE
)
5473 flags
|= BASEFLAGS_PRIVATE
;
5475 nindx
= info
->type_stack
->type
.classdef
->indx
;
5477 if (! ieee_change_buffer (info
, &info
->type_stack
->type
.classdef
->pmiscbuf
)
5478 || ! ieee_write_asn (info
, nindx
, 'b')
5479 || ! ieee_write_asn (info
, nindx
, flags
)
5480 || ! ieee_write_atn65 (info
, nindx
, bname
)
5481 || ! ieee_write_asn (info
, nindx
, 0)
5482 || ! ieee_write_atn65 (info
, nindx
, fname
))
5484 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
5491 /* Start building a method for a class. */
5494 ieee_class_start_method (p
, name
)
5498 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5500 assert (info
->type_stack
!= NULL
5501 && info
->type_stack
->type
.classdef
!= NULL
5502 && info
->type_stack
->type
.classdef
->method
== NULL
);
5504 info
->type_stack
->type
.classdef
->method
= name
;
5509 /* Define a new method variant, either static or not. */
5512 ieee_class_method_var (info
, physname
, visibility
, staticp
, constp
,
5513 volatilep
, voffset
, context
)
5514 struct ieee_handle
*info
;
5515 const char *physname
;
5516 enum debug_visibility visibility
;
5527 /* We don't need the type of the method. An IEEE consumer which
5528 wants the type must track down the function by the physical name
5529 and get the type from that. */
5530 ieee_pop_unused_type (info
);
5532 /* We don't use the context. FIXME: We probably ought to use it to
5533 adjust the voffset somehow, but I don't really know how. */
5535 ieee_pop_unused_type (info
);
5537 assert (info
->type_stack
!= NULL
5538 && info
->type_stack
->type
.classdef
!= NULL
5539 && info
->type_stack
->type
.classdef
->method
!= NULL
);
5541 flags
= ieee_vis_to_flags (visibility
);
5543 /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
5544 CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
5547 flags
|= CXXFLAGS_STATIC
;
5549 flags
|= CXXFLAGS_CONST
;
5551 flags
|= CXXFLAGS_VOLATILE
;
5553 nindx
= info
->type_stack
->type
.classdef
->indx
;
5555 virtual = context
|| voffset
> 0;
5557 if (! ieee_change_buffer (info
,
5558 &info
->type_stack
->type
.classdef
->pmiscbuf
)
5559 || ! ieee_write_asn (info
, nindx
, virtual ? 'v' : 'm')
5560 || ! ieee_write_asn (info
, nindx
, flags
)
5561 || ! ieee_write_atn65 (info
, nindx
,
5562 info
->type_stack
->type
.classdef
->method
)
5563 || ! ieee_write_atn65 (info
, nindx
, physname
))
5568 if (voffset
> info
->type_stack
->type
.classdef
->voffset
)
5569 info
->type_stack
->type
.classdef
->voffset
= voffset
;
5570 if (! ieee_write_asn (info
, nindx
, voffset
))
5572 ++info
->type_stack
->type
.classdef
->pmisccount
;
5575 if (! ieee_write_asn (info
, nindx
, 0))
5578 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
5583 /* Define a new method variant. */
5586 ieee_class_method_variant (p
, physname
, visibility
, constp
, volatilep
,
5589 const char *physname
;
5590 enum debug_visibility visibility
;
5596 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5598 return ieee_class_method_var (info
, physname
, visibility
, false, constp
,
5599 volatilep
, voffset
, context
);
5602 /* Define a new static method variant. */
5605 ieee_class_static_method_variant (p
, physname
, visibility
, constp
, volatilep
)
5607 const char *physname
;
5608 enum debug_visibility visibility
;
5612 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5614 return ieee_class_method_var (info
, physname
, visibility
, true, constp
,
5615 volatilep
, 0, false);
5618 /* Finish up a method. */
5621 ieee_class_end_method (p
)
5624 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5626 assert (info
->type_stack
!= NULL
5627 && info
->type_stack
->type
.classdef
!= NULL
5628 && info
->type_stack
->type
.classdef
->method
!= NULL
);
5630 info
->type_stack
->type
.classdef
->method
= NULL
;
5635 /* Finish up a class. */
5638 ieee_end_class_type (p
)
5641 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5643 struct ieee_buf
**pb
;
5645 assert (info
->type_stack
!= NULL
5646 && info
->type_stack
->type
.classdef
!= NULL
);
5648 nindx
= info
->type_stack
->type
.classdef
->indx
;
5650 /* If we have a virtual table, we can write out the information now. */
5651 if (info
->type_stack
->type
.classdef
->vclass
!= NULL
5652 || info
->type_stack
->type
.classdef
->ownvptr
)
5654 if (! ieee_change_buffer (info
,
5655 &info
->type_stack
->type
.classdef
->pmiscbuf
)
5656 || ! ieee_write_asn (info
, nindx
, 'z')
5657 || ! ieee_write_atn65 (info
, nindx
, "")
5658 || ! ieee_write_asn (info
, nindx
,
5659 info
->type_stack
->type
.classdef
->voffset
))
5661 if (info
->type_stack
->type
.classdef
->ownvptr
)
5663 if (! ieee_write_atn65 (info
, nindx
, ""))
5668 if (! ieee_write_atn65 (info
, nindx
,
5669 info
->type_stack
->type
.classdef
->vclass
))
5672 if (! ieee_write_asn (info
, nindx
, 0))
5674 info
->type_stack
->type
.classdef
->pmisccount
+= 5;
5677 /* Now that we know the number of pmisc records, we can write out
5678 the atn62 which starts the pmisc records, and append them to the
5681 if (! ieee_change_buffer (info
, &info
->cxx
)
5682 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
5683 || ! ieee_write_number (info
, nindx
)
5684 || ! ieee_write_id (info
, "")
5685 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
5686 || ! ieee_write_number (info
, nindx
)
5687 || ! ieee_write_number (info
, 0)
5688 || ! ieee_write_number (info
, 62)
5689 || ! ieee_write_number (info
, 80)
5690 || ! ieee_write_number (info
,
5691 info
->type_stack
->type
.classdef
->pmisccount
))
5694 for (pb
= &info
->cxx
; *pb
!= NULL
; pb
= &(*pb
)->next
)
5696 *pb
= info
->type_stack
->type
.classdef
->pmiscbuf
;
5697 if (info
->type_stack
->type
.classdef
->refs
!= NULL
)
5699 for (; *pb
!= NULL
; pb
= &(*pb
)->next
)
5701 *pb
= info
->type_stack
->type
.classdef
->refs
;
5704 return ieee_end_struct_type (p
);
5707 /* Push a previously seen typedef onto the type stack. */
5710 ieee_typedef_type (p
, name
)
5714 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5715 register struct ieee_name_type
*nt
;
5717 for (nt
= info
->typedefs
; nt
!= NULL
; nt
= nt
->next
)
5719 if (nt
->type
.name
[0] == name
[0]
5720 && strcmp (nt
->type
.name
, name
) == 0)
5722 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
5723 nt
->type
.unsignedp
))
5725 /* Copy over any other type information we may have. */
5726 info
->type_stack
->type
= nt
->type
;
5734 /* Push a tagged type onto the type stack. */
5737 ieee_tag_type (p
, name
, id
, kind
)
5741 enum debug_type_kind kind
;
5743 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5744 register struct ieee_name_type
*nt
;
5749 sprintf (ab
, "__anon%u", id
);
5753 for (nt
= info
->tags
; nt
!= NULL
; nt
= nt
->next
)
5755 if (nt
->type
.name
[0] == name
[0]
5756 && strcmp (nt
->type
.name
, name
) == 0)
5758 if (! ieee_push_type (info
, nt
->type
.indx
, nt
->type
.size
,
5759 nt
->type
.unsignedp
))
5761 /* Copy over any other type information we may have. */
5762 info
->type_stack
->type
= nt
->type
;
5767 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
5768 memset (nt
, 0, sizeof *nt
);
5771 name
= xstrdup (ab
);
5772 nt
->type
.name
= name
;
5773 nt
->type
.indx
= info
->type_indx
;
5777 nt
->next
= info
->tags
;
5780 if (! ieee_push_type (info
, nt
->type
.indx
, 0, false))
5783 info
->type_stack
->type
.name
= name
;
5788 /* Output a typedef. */
5791 ieee_typdef (p
, name
)
5795 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5796 struct ieee_name_type
*nt
;
5801 nt
= (struct ieee_name_type
*) xmalloc (sizeof *nt
);
5802 memset (nt
, 0, sizeof *nt
);
5803 nt
->type
= info
->type_stack
->type
;
5804 nt
->type
.name
= name
;
5805 nt
->kind
= DEBUG_KIND_ILLEGAL
;
5807 nt
->next
= info
->typedefs
;
5808 info
->typedefs
= nt
;
5810 size
= info
->type_stack
->type
.size
;
5811 unsignedp
= info
->type_stack
->type
.unsignedp
;
5812 indx
= ieee_pop_type (info
);
5814 /* If this is a simple builtin type using a builtin name, we don't
5815 want to output the typedef itself. We also want to change the
5816 type index to correspond to the name being used. We recognize
5817 names used in stabs debugging output even if they don't exactly
5818 correspond to the names used for the IEEE builtin types. */
5819 if (indx
<= (unsigned int) builtin_bcd_float
)
5824 switch ((enum builtin_types
) indx
)
5830 if (strcmp (name
, "void") == 0)
5834 case builtin_signed_char
:
5836 if (strcmp (name
, "signed char") == 0)
5838 indx
= (unsigned int) builtin_signed_char
;
5841 else if (strcmp (name
, "char") == 0)
5843 indx
= (unsigned int) builtin_char
;
5848 case builtin_unsigned_char
:
5849 if (strcmp (name
, "unsigned char") == 0)
5853 case builtin_signed_short_int
:
5855 case builtin_short_int
:
5856 case builtin_signed_short
:
5857 if (strcmp (name
, "signed short int") == 0)
5859 indx
= (unsigned int) builtin_signed_short_int
;
5862 else if (strcmp (name
, "short") == 0)
5864 indx
= (unsigned int) builtin_short
;
5867 else if (strcmp (name
, "short int") == 0)
5869 indx
= (unsigned int) builtin_short_int
;
5872 else if (strcmp (name
, "signed short") == 0)
5874 indx
= (unsigned int) builtin_signed_short
;
5879 case builtin_unsigned_short_int
:
5880 case builtin_unsigned_short
:
5881 if (strcmp (name
, "unsigned short int") == 0
5882 || strcmp (name
, "short unsigned int") == 0)
5884 indx
= builtin_unsigned_short_int
;
5887 else if (strcmp (name
, "unsigned short") == 0)
5889 indx
= builtin_unsigned_short
;
5894 case builtin_signed_long
:
5895 case builtin_int
: /* FIXME: Size depends upon architecture. */
5897 if (strcmp (name
, "signed long") == 0)
5899 indx
= builtin_signed_long
;
5902 else if (strcmp (name
, "int") == 0)
5907 else if (strcmp (name
, "long") == 0
5908 || strcmp (name
, "long int") == 0)
5910 indx
= builtin_long
;
5915 case builtin_unsigned_long
:
5916 case builtin_unsigned
: /* FIXME: Size depends upon architecture. */
5917 case builtin_unsigned_int
: /* FIXME: Like builtin_unsigned. */
5918 if (strcmp (name
, "unsigned long") == 0
5919 || strcmp (name
, "long unsigned int") == 0)
5921 indx
= builtin_unsigned_long
;
5924 else if (strcmp (name
, "unsigned") == 0)
5926 indx
= builtin_unsigned
;
5929 else if (strcmp (name
, "unsigned int") == 0)
5931 indx
= builtin_unsigned_int
;
5936 case builtin_signed_long_long
:
5937 if (strcmp (name
, "signed long long") == 0
5938 || strcmp (name
, "long long int") == 0)
5942 case builtin_unsigned_long_long
:
5943 if (strcmp (name
, "unsigned long long") == 0
5944 || strcmp (name
, "long long unsigned int") == 0)
5949 if (strcmp (name
, "float") == 0)
5953 case builtin_double
:
5954 if (strcmp (name
, "double") == 0)
5958 case builtin_long_double
:
5959 if (strcmp (name
, "long double") == 0)
5963 case builtin_long_long_double
:
5964 if (strcmp (name
, "long long double") == 0)
5971 nt
->type
.indx
= indx
;
5976 if (! ieee_define_named_type (info
, name
, false, 0, size
, unsignedp
,
5977 (struct ieee_buf
**) NULL
)
5978 || ! ieee_write_number (info
, 'T')
5979 || ! ieee_write_number (info
, indx
))
5982 /* Remove the type we just added to the type stack. This should not
5983 be ieee_pop_unused_type, since the type is used, we just don't
5985 (void) ieee_pop_type (info
);
5990 /* Output a tag for a type. We don't have to do anything here. */
5997 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
5999 /* This should not be ieee_pop_unused_type, since we want the type
6001 (void) ieee_pop_type (info
);
6005 /* Output an integer constant. */
6008 ieee_int_constant (p
, name
, val
)
6017 /* Output a floating point constant. */
6020 ieee_float_constant (p
, name
, val
)
6029 /* Output a typed constant. */
6032 ieee_typed_constant (p
, name
, val
)
6037 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6040 ieee_pop_unused_type (info
);
6044 /* Output a variable. */
6047 ieee_variable (p
, name
, kind
, val
)
6050 enum debug_var_kind kind
;
6053 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6054 unsigned int name_indx
;
6057 unsigned int type_indx
;
6061 size
= info
->type_stack
->type
.size
;
6062 referencep
= info
->type_stack
->type
.referencep
;
6063 type_indx
= ieee_pop_type (info
);
6065 /* Make sure the variable section is started. */
6066 if (info
->vars
!= NULL
)
6068 if (! ieee_change_buffer (info
, &info
->vars
))
6073 if (! ieee_change_buffer (info
, &info
->vars
)
6074 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6075 || ! ieee_write_byte (info
, 3)
6076 || ! ieee_write_number (info
, 0)
6077 || ! ieee_write_id (info
, info
->modname
))
6081 name_indx
= info
->name_indx
;
6084 /* Write out an NN and an ATN record for this variable. */
6085 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
6086 || ! ieee_write_number (info
, name_indx
)
6087 || ! ieee_write_id (info
, name
)
6088 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6089 || ! ieee_write_number (info
, name_indx
)
6090 || ! ieee_write_number (info
, type_indx
))
6098 if (! ieee_write_number (info
, 8)
6099 || ! ieee_add_range (info
, val
, val
+ size
))
6105 if (! ieee_write_number (info
, 3)
6106 || ! ieee_add_range (info
, val
, val
+ size
))
6111 case DEBUG_LOCAL_STATIC
:
6112 if (! ieee_write_number (info
, 3)
6113 || ! ieee_add_range (info
, val
, val
+ size
))
6119 if (! ieee_write_number (info
, 1)
6120 || ! ieee_write_number (info
, val
))
6125 case DEBUG_REGISTER
:
6126 if (! ieee_write_number (info
, 2)
6127 || ! ieee_write_number (info
,
6128 ieee_genreg_to_regno (info
->abfd
, val
)))
6137 if (! ieee_write_asn (info
, name_indx
, val
))
6141 /* If this is really a reference type, then we just output it with
6142 pointer type, and must now output a C++ record indicating that it
6143 is really reference type. */
6148 nindx
= info
->name_indx
;
6151 /* If this is a global variable, we want to output the misc
6152 record in the C++ misc record block. Otherwise, we want to
6153 output it just after the variable definition, which is where
6154 the current buffer is. */
6157 if (! ieee_change_buffer (info
, &info
->cxx
))
6161 if (! ieee_write_byte (info
, (int) ieee_nn_record
)
6162 || ! ieee_write_number (info
, nindx
)
6163 || ! ieee_write_id (info
, "")
6164 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6165 || ! ieee_write_number (info
, nindx
)
6166 || ! ieee_write_number (info
, 0)
6167 || ! ieee_write_number (info
, 62)
6168 || ! ieee_write_number (info
, 80)
6169 || ! ieee_write_number (info
, 3)
6170 || ! ieee_write_asn (info
, nindx
, 'R')
6171 || ! ieee_write_asn (info
, nindx
, refflag
)
6172 || ! ieee_write_atn65 (info
, nindx
, name
))
6179 /* Start outputting information for a function. */
6182 ieee_start_function (p
, name
, global
)
6187 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6189 unsigned int retindx
, typeindx
;
6191 referencep
= info
->type_stack
->type
.referencep
;
6192 retindx
= ieee_pop_type (info
);
6194 /* Besides recording a BB4 or BB6 block, we record the type of the
6195 function in the BB1 typedef block. We can't write out the full
6196 type until we have seen all the parameters, so we accumulate it
6197 in info->fntype and info->fnargs. */
6198 if (info
->fntype
!= NULL
)
6200 /* FIXME: This might happen someday if we support nested
6205 info
->fnname
= name
;
6207 /* An attribute of 0x41 means that the frame and push mask are
6209 if (! ieee_define_named_type (info
, name
, false, 0, 0, false, &info
->fntype
)
6210 || ! ieee_write_number (info
, 'x')
6211 || ! ieee_write_number (info
, 0x41)
6212 || ! ieee_write_number (info
, 0)
6213 || ! ieee_write_number (info
, 0)
6214 || ! ieee_write_number (info
, retindx
))
6217 typeindx
= ieee_pop_type (info
);
6219 info
->fnargs
= NULL
;
6220 info
->fnargcount
= 0;
6222 /* If the function return value is actually a reference type, we
6223 must add a record indicating that. */
6228 nindx
= info
->name_indx
;
6230 if (! ieee_change_buffer (info
, &info
->cxx
)
6231 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
6232 || ! ieee_write_number (info
, nindx
)
6233 || ! ieee_write_id (info
, "")
6234 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6235 || ! ieee_write_number (info
, nindx
)
6236 || ! ieee_write_number (info
, 0)
6237 || ! ieee_write_number (info
, 62)
6238 || ! ieee_write_number (info
, 80)
6239 || ! ieee_write_number (info
, 3)
6240 || ! ieee_write_asn (info
, nindx
, 'R')
6241 || ! ieee_write_asn (info
, nindx
, global
? 0 : 1)
6242 || ! ieee_write_atn65 (info
, nindx
, name
))
6246 /* Make sure the variable section is started. */
6247 if (info
->vars
!= NULL
)
6249 if (! ieee_change_buffer (info
, &info
->vars
))
6254 if (! ieee_change_buffer (info
, &info
->vars
)
6255 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6256 || ! ieee_write_byte (info
, 3)
6257 || ! ieee_write_number (info
, 0)
6258 || ! ieee_write_id (info
, info
->modname
))
6262 /* The address is written out as the first block. */
6264 ++info
->block_depth
;
6266 return (ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6267 && ieee_write_byte (info
, global
? 4 : 6)
6268 && ieee_write_number (info
, 0)
6269 && ieee_write_id (info
, name
)
6270 && ieee_write_number (info
, 0)
6271 && ieee_write_number (info
, typeindx
));
6274 /* Add a function parameter. This will normally be called before the
6275 first block, so we postpone them until we see the block. */
6278 ieee_function_parameter (p
, name
, kind
, val
)
6281 enum debug_parm_kind kind
;
6284 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6285 struct ieee_pending_parm
*m
, **pm
;
6287 assert (info
->block_depth
== 1);
6289 m
= (struct ieee_pending_parm
*) xmalloc (sizeof *m
);
6290 memset (m
, 0, sizeof *m
);
6294 m
->referencep
= info
->type_stack
->type
.referencep
;
6295 m
->type
= ieee_pop_type (info
);
6299 for (pm
= &info
->pending_parms
; *pm
!= NULL
; pm
= &(*pm
)->next
)
6303 /* Add the type to the fnargs list. */
6304 if (! ieee_change_buffer (info
, &info
->fnargs
)
6305 || ! ieee_write_number (info
, m
->type
))
6312 /* Output pending function parameters. */
6315 ieee_output_pending_parms (info
)
6316 struct ieee_handle
*info
;
6318 struct ieee_pending_parm
*m
;
6319 unsigned int refcount
;
6322 for (m
= info
->pending_parms
; m
!= NULL
; m
= m
->next
)
6324 enum debug_var_kind vkind
;
6331 case DEBUG_PARM_STACK
:
6332 case DEBUG_PARM_REFERENCE
:
6333 vkind
= DEBUG_LOCAL
;
6335 case DEBUG_PARM_REG
:
6336 case DEBUG_PARM_REF_REG
:
6337 vkind
= DEBUG_REGISTER
;
6341 if (! ieee_push_type (info
, m
->type
, 0, false))
6343 info
->type_stack
->type
.referencep
= m
->referencep
;
6346 if (! ieee_variable ((PTR
) info
, m
->name
, vkind
, m
->val
))
6350 /* If there are any reference parameters, we need to output a
6351 miscellaneous record indicating them. */
6354 unsigned int nindx
, varindx
;
6356 /* FIXME: The MRI compiler outputs the demangled function name
6357 here, but we are outputting the mangled name. */
6358 nindx
= info
->name_indx
;
6360 if (! ieee_change_buffer (info
, &info
->vars
)
6361 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
6362 || ! ieee_write_number (info
, nindx
)
6363 || ! ieee_write_id (info
, "")
6364 || ! ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6365 || ! ieee_write_number (info
, nindx
)
6366 || ! ieee_write_number (info
, 0)
6367 || ! ieee_write_number (info
, 62)
6368 || ! ieee_write_number (info
, 80)
6369 || ! ieee_write_number (info
, refcount
+ 3)
6370 || ! ieee_write_asn (info
, nindx
, 'B')
6371 || ! ieee_write_atn65 (info
, nindx
, info
->fnname
)
6372 || ! ieee_write_asn (info
, nindx
, 0))
6374 for (m
= info
->pending_parms
, varindx
= 1;
6376 m
= m
->next
, varindx
++)
6380 if (! ieee_write_asn (info
, nindx
, varindx
))
6386 m
= info
->pending_parms
;
6389 struct ieee_pending_parm
*next
;
6396 info
->pending_parms
= NULL
;
6401 /* Start a block. If this is the first block, we output the address
6402 to finish the BB4 or BB6, and then output the function parameters. */
6405 ieee_start_block (p
, addr
)
6409 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6411 if (! ieee_change_buffer (info
, &info
->vars
))
6414 if (info
->block_depth
== 1)
6416 if (! ieee_write_number (info
, addr
)
6417 || ! ieee_output_pending_parms (info
))
6422 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6423 || ! ieee_write_byte (info
, 6)
6424 || ! ieee_write_number (info
, 0)
6425 || ! ieee_write_id (info
, "")
6426 || ! ieee_write_number (info
, 0)
6427 || ! ieee_write_number (info
, 0)
6428 || ! ieee_write_number (info
, addr
))
6432 if (! ieee_start_range (info
, addr
))
6435 ++info
->block_depth
;
6443 ieee_end_block (p
, addr
)
6447 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6449 if (! ieee_change_buffer (info
, &info
->vars
)
6450 || ! ieee_write_byte (info
, (int) ieee_be_record_enum
)
6451 || ! ieee_write_number (info
, addr
))
6454 if (! ieee_end_range (info
, addr
))
6457 --info
->block_depth
;
6459 if (addr
> info
->highaddr
)
6460 info
->highaddr
= addr
;
6465 /* End a function. */
6468 ieee_end_function (p
)
6471 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6472 struct ieee_buf
**pb
;
6474 assert (info
->block_depth
== 1);
6476 --info
->block_depth
;
6478 /* Now we can finish up fntype, and add it to the typdef section.
6479 At this point, fntype is the 'x' type up to the argument count,
6480 and fnargs is the argument types. We must add the argument
6481 count, and we must add the level. FIXME: We don't record varargs
6482 functions correctly. In fact, stabs debugging does not give us
6483 enough information to do so. */
6484 if (! ieee_change_buffer (info
, &info
->fntype
)
6485 || ! ieee_write_number (info
, info
->fnargcount
)
6486 || ! ieee_change_buffer (info
, &info
->fnargs
)
6487 || ! ieee_write_number (info
, 0))
6490 /* Make sure the typdef block has been started. */
6491 if (info
->types
== NULL
)
6493 if (! ieee_change_buffer (info
, &info
->types
)
6494 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6495 || ! ieee_write_byte (info
, 1)
6496 || ! ieee_write_number (info
, 0)
6497 || ! ieee_write_id (info
, info
->modname
))
6501 for (pb
= &info
->types
; *pb
!= NULL
; pb
= &(*pb
)->next
)
6504 for (; *pb
!= NULL
; pb
= &(*pb
)->next
)
6508 info
->fnname
= NULL
;
6509 info
->fntype
= NULL
;
6510 info
->fnargs
= NULL
;
6511 info
->fnargcount
= 0;
6516 /* Record line number information. */
6519 ieee_lineno (p
, filename
, lineno
, addr
)
6521 const char *filename
;
6522 unsigned long lineno
;
6525 struct ieee_handle
*info
= (struct ieee_handle
*) p
;
6527 assert (info
->filename
!= NULL
);
6529 /* Make sure we have a line number block. */
6530 if (info
->linenos
!= NULL
)
6532 if (! ieee_change_buffer (info
, &info
->linenos
))
6537 info
->lineno_name_indx
= info
->name_indx
;
6539 if (! ieee_change_buffer (info
, &info
->linenos
)
6540 || ! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6541 || ! ieee_write_byte (info
, 5)
6542 || ! ieee_write_number (info
, 0)
6543 || ! ieee_write_id (info
, info
->filename
)
6544 || ! ieee_write_byte (info
, (int) ieee_nn_record
)
6545 || ! ieee_write_number (info
, info
->lineno_name_indx
)
6546 || ! ieee_write_id (info
, ""))
6548 info
->lineno_filename
= info
->filename
;
6551 if (strcmp (filename
, info
->lineno_filename
) != 0)
6553 if (strcmp (info
->filename
, info
->lineno_filename
) != 0)
6555 /* We were not in the main file. Close the block for the
6557 if (! ieee_write_byte (info
, (int) ieee_be_record_enum
))
6560 if (strcmp (info
->filename
, filename
) != 0)
6562 /* We are not changing to the main file. Open a block for
6563 the new included file. */
6564 if (! ieee_write_byte (info
, (int) ieee_bb_record_enum
)
6565 || ! ieee_write_byte (info
, 5)
6566 || ! ieee_write_number (info
, 0)
6567 || ! ieee_write_id (info
, filename
))
6570 info
->lineno_filename
= filename
;
6573 return (ieee_write_2bytes (info
, (int) ieee_atn_record_enum
)
6574 && ieee_write_number (info
, info
->lineno_name_indx
)
6575 && ieee_write_number (info
, 0)
6576 && ieee_write_number (info
, 7)
6577 && ieee_write_number (info
, lineno
)
6578 && ieee_write_number (info
, 0)
6579 && ieee_write_asn (info
, info
->lineno_name_indx
, addr
));